Afer being cooped up for 2 weeks, it was time to go out for a bit of fresh air, stretching my car's legs, and going to the beach for a few walks:
quick stop on skyline
before long, we reached Pescadero beach
Caltrans nicely were closing all the beach parking lots as we arrived
We then drove down Hwy 1 to hit a few beaches:
found a nice surfer
the next beach
where skyline of the beach, ends up
We ended up going to Shark Fin Cove or lunch:
railroad to nowhere
I went to check out the cave which was really a storm drain
didn't smell so good :)
nice hole in the rock
After lunch, we drove back up on bonny doon road. which was find until we hite what looked like snow on the road. How as that possible? Turns out, it hailed so much that the hail accumulated on the ground and looked like snow:
it was melting, but super slick
Eventually, after driving not as fast as I wished due to the uncertain roads, we got to 236 and big basin redwoods, which was closed as expected:
After that, it was a fun drive up 236, and 9 back home.
After rewriting multiple related libraries, it became confusing to people how they fit together, Adafruit::NeoMatrix, FastLED::NeoMatrix, SmartMatrix::GFX, where does Framebuffer::GFX fit in?
Is Adafruit::GFX still there/needed?
How about LEDMatrix, isn't it a better 2D lib?
What hardware backends are supported?
How the modules/drivers fit together
I made this little graph to summarize everything:
the left shows the hardware drivers supported: FastLED, SmartMatrix, ILI9341, SSD1331, ST7735, rpi-rgb-led-matrix (for ArduinoOnPC on Raspberry Pi), FastLED_SDL (for ArduinoOnPC), and X11/Linux (also ArduinoOnPC)
The 2nd column is the list of drivers I wrote for all those hardware drivers
All those drivers I wrote inherit from FrameBuffer::GFX wihch stores the actual framebuffer in FastLED CRGB 24bpp Format
LEDMatrix is an alternative to GFX that is mostly compatible, but offers its own extensions. I you wish to use it, I modified it so that it doesn't store the CRGB array within itself, but accepts an externally generated one (so that it can be shared with SmartMatrix if this is the ultimate backend, and allocated via malloc and not a global array, which is required on ESP32 for bigger sizes). More on whether you'd want to use it, later.
Low Level Drv|Glue Driver for FrameBuffer::GFX
FastLED - FastLED_NeoMatrix -------------\ FastLED CRGB Array
SmartMatrix - SmartMatrix_GFX -----------------\ 24bit FB storage API Support
\ CRGB methods like
AF:ILI9341-\ \ scale8/fadeToBlackBy
AF:SSD1331 |--- FastLED_ArduinoGFX_TFT ----------| | ,FastLED API
AF:ST7735 / FastLED_SPITFT_GFX (for AF) | | / (XY 2D to 1D mapping)
ArduinoGFX/ AF:Adafruit (ArduinoGFX is all in 1) | |
| |
ArduinoOnPc-FastLED-GFX-LEDMatrix arduino - FrameBuffer::GFX------ Adafruit::NeoMatrix +
emulation for linux / Raspberry Pi: | | \ Adafruit::GFX APIs
---------------------------------- / Adafruit::GFX \
rpi-rgb-led-matrix - FastLED_RPIRGBPanel_GFX ---/ LEDMatrix (optional) `LEDMatrix API
ArduinoOnPC X11/linux - FastLED_TFTWrapper_GFX
FastLED_SDL (linux) - FastLED_NeoMatrix -/
Which 2D API: FastLED XY(), Adafruit/FastLED::NeoMatrix, vs LEDMatrix
Old FastLED demos use an XY() function, to access leds[XY(x,y)] to do 2D to 1D mapping. Framebuffer::GFX supports this in a way that you can both read and write while supporting full rotation and tile mapping from NeoMatrix. This is honestly no reason to do this today, you would effectively rewrite the much better XY functionality that's in FastLED::NeoMatrix/Framebuffer::GFX. However, if you have code that uses an XY function, it's fully supported, simply use matrix->XY(x, y) to let NeoMatrix do the real mapping for you without having to worry about writing/rewriting the mapping function for each potential array.
The better and most commonly used API is Adafruit::GFX. Honestly I recommend it because of the sheer number of hardware devices supported by it. It has the downside of only being 16bit color, but if you use it in FrameBuffer::GFX, can you can use 24bit color with it. Its 2nd downside is that on its own, it has no framebuffer, so it is write only. Obviously with Framebuffer::GFX, it does have a framebuffer (which can be a downside on some slower hardware at higher resolutions, see TFT below). To learn more about how to use the GFX API, see https://learn.adafruit.com/adafruit-gfx-graphics-library?view=all
LEDMatrix is a better API with more fancy functions than GFX and native 24bpp color, but it's only meant to work on FastLED, and its matrix tiling support and rotation is pretty non trivial to use compared to NeoMatrix. I would only use it if you need its added functionality. On the plus side, Framebuffer::GFX allows you to run LEDMatrix code on any hardware backend, so you aren't limited there anymore. LEDMatrix pluses are
more primitives, including some flip/mirror screen options
Table_Mark_Estes is just that good, that it's worth having LEDMatrix for
LEDMatrix has Fancy Font Support. In my opinion it's more fancy than most people will need, and Adafruit::GFX built in front support is more than plenty, but it's there if you want it.
LEDSprites is nice if you need sprites, see my LEDSprites-Pacman demo
The SmartMatrix library has its own 2D API, it is quite fancy and includes layers, but it is not supported by FrameBuffer::GFX, so unless you're writing a SmartMatrix only project (which means you won't be able to upgrade to RGBPanels on rPI if you need a higher resolution), I recommend against using it. Technically, someone motivated could make the API work with FrameBuffer::GFX and allow rendering on another backend, but I haven't done that work and don't have the need to do so. If you'd like to contribute that, please do.
The good news is that if you don't know which one to choose Framebuffer::GFX allows you to run all 3 at the same time, thanks to the work done in neomatrix_config.h which while not required, I greatly recommend so that it'll setup everything for you and make it trivial to change from one hardware backend to another one.
This is now the library I recommend for all TFTs instead of the multiple libraries written by Adafruit (supported by FastLED_SPITFT_GFX), not quite with the same interface, and multiple drivers. I definitely recommend https://github.com/moononournation/Arduino_GFX instead for new work.
Arduino_GFX supports running multiple TFTs at the same time if you have different CS pins:
comparison of TFTs
The demos below done on FastLED_SPITFT_GFX look exactly the same with FastLED_ArduinoGFX_TFT except for being faster with this driver.
This is probably the most useful driver I wrote out of all of them, the ability to write your code and debug on linux, without any hardware:
Dealing with pushing bigger framebuffer sizes to TFTs like ILI9341
For long the highest resolution target for arduino chips has been the ILI9341 TFTs. With a resolution of 320x240 over SPI, they push the limits of Framebuffer::GFX a little bit, because it's a lot of pixels to push. Unfortunately, the TFT seems to only support about 14 frames per second for a full refresh, which is needed with the framebuffer approach, and by the time you add required use of PSRAM on ESP32, which is slower than regular RAM but required because ESP32 does not have the required contiguous 224KB of RAM, frame refresh falls down to 8fps. Worse, still, once you add computation of data being sent, demos actually run closer to 5fps.
This is far from ideal, but it's good enough or some uses still, and generally still cool that Framebuffer::GFX can be pushed so far on arduino-like chips. Using RGBPanels does not help there on arduino chips, because there is no arduino like chip that can run such a resolution on RGBPanels (Raspberry Pi can barely do it though, but that's also pushing the limits of the underlying hardware refresh capabilities).
It this ends up being a problem, but you made the decision to stick to the Adafruit::GFX API, you always have the option to remove FrameBuffer::GFX and write directly to the TFT, without having to do full framebuffer refreshes.
If you'd like numbers, I gathered as part of a test between SPI speed, raw TFT speed (empty frame push), loop to push data not from PSRAM, loop to push data from PSRAM. Actual speed in demos is still lower given that it takes time to generate high resolution frames to PSRAM (double PSRAM penalty, one to write, one to read), before they can be pushed.
Arduino::GFX ILI9314
tft/gfx/bypass/copy
40fhz, fps no PSRAM: 25/15/22/14 PSRAM: 25/11/21/8
80fhz, fps no PSRAM: 42/19/33/18 PSRAM: 40/14/32/9 (Arduino_HWSPI)
80fhz, fps no PSRAM: 53/21/38/20 Arduino_ESP32SPI
80fhz, fps no PSRAM: 60/20/34/18 Arduino_ESP32SPI_DMA
4ft+ of snow finally coming to Tahoe, after so little for so long, finally! It was time to go.
The snow line wasn't too low when I started driving up, except for a bit of surprise slush when I was passing a truck. Thankfully my tesla stability control, did the right thing:
strangely, the road was quite clear higher up (localized snowfalls)
Carson Spur was still in very good shape
After a bit under 4H, including a 20mn recharging stop in Manteca, I arrived at Kirkwood just before 15:00:
Sadly, by then only solitude was open, I did 2 runs that weren't bad but on my 2nd run up, I got the very bad news that while Vail said they would stay open that same morning, a few hours later, while I drove up, changed their minds and closed off everything for the season due to COVID-19. Needless to say that I wasn't happy that they couldn't make that decision in the morning, and mislead everyone into coming:
those were 2 expensive runs
Now, life sucked, it was clear that I had to leave kirkwood as quickly as possible, as the weather was worsening, but my car was very discharged. I had to recharge it just enough to get out and hopefully make it to some charging source under the snow line.
I had to take the Omo Ranch Rd by Cook's Station to get the shortest path to the Placerville Supercharger, where I barely arrived with a 5% of battery left. Omo Ranch Rd, while open, is not a safe road with snow, and doesn't get plowed. The top was dicey and I had the tradeoff of getting down quickly to get out of the snow line, without driving off the road due to snow.
The tesla estimator has been very wrong, on the trip out, it told me I'd arrive with 14%, but I arrived with 5% while driving quite slow and taking an unsafe road (the safe road around would not have gotten me there with enough battery left):
estimator went from 14% to 9% to 5% by the time I arrived
thankfully it stabilized at 5%
on the plus side, the new superchargers are fast, I got back to 80% in 30mn
That's definitely been my worst snow trip ever, except for the fact that I avoided crashing my car on the way up after that slide, or running out of battery and having my car die on the side of the road in a snowstorm.
victory, first time I got those new panels to light up
I ended up getting 15 such panels from the nice folks at Azerone, because they were returns as other people couldn't use them due to lack of FM6126A support in the open source drivers at the time:
if only I had proper mounting hardware, this would be a decent 192x160 array
Ok, after writing this blog, I ended up getting a recommendation for rails, which weren't built for this but worked well enough:
you'll need something to cut the rails that are too long. I used a set of bolt cutters I had, some saws may work too, but the rails are pretty thick
holes don't all match, but enough of them do. Note that I put the panels in Z pattern
adding power
on my first try, the metal cut the ribbon cable, so I removed the top loop to avoid having it go towards the metal
Now, I had an expected problem that hzeller/rpi-rgb-led-matrix did not support panels stacked vertically, never mind if every panel was upside down. I ended up writing a new mapper that allowed both vertical stacking and zig-zag. After that, success was had, end result was about 300Hz for 31K pixels with the active-3 board:
That said, while that bigger matrix with those 15 panels was 192x160, I had bigger plans. I got distracted due to other work, but then P2 panel appeared (2mm per pixel). The downsides of those panels is that the copper traces are so small that pixels come off easily, including during shipping:
even pixels that don't pop off can be partially failed
using the active-3 board with 3 chains of one panel each on rPi3
The first issue was that the newer 128x64 panels were FM6126A, which didn't work with default libraries as they need a special init. Thankfully this was added to rpi-rgb-led-matrix. Next issue was that refresh rate was going to suffer, and that's where the rPi solution is great: it allows for 3 channels in parallel thanks to the nice Electrodragon active-3 board.
Chow He from Electrodragon was super nice, and sent me some boards with angled connectors (at my request) so that I could make the whole board more flat for my wearable application. I was really hopeful that I could put the connectors under the board for low profile after cutting the notch and moving it to the other side of the connector:
However, wire routing was such that pins were in the wrong order and it was impossible without re-routing all the wires on the board, so I did the next best thing and put the connector on top of the board, which is still more flush than when it was pointing up:
before (blue), not working (right), and after (left)
bottom is not possible, even after moving the notch
Still, 192x128 is a very nice display that happens to be the same size as my old 96x64 display using P4 panels, but since I ordered spare panels to get around the falling pixel problem, I had enough panels to make a 9x9 array of 384x192. I first tried with with rpi-rgb-panel's video viewer and it worked quite well:
During that time, I did a lot of work on 2D APis for Arduino and lots of backends, and wrote the base class, FrameBuffer::GFX. In a nutshell, it allow talking to a lot of hardware displays, now both on Arduino and Raspberry Pi:
Low Level Drv|Glue Driver for FrameBuffer::GFX
FastLED - FastLED_NeoMatrix -------------\ FastLED CRGB Array
SmartMatrix - SmartMatrix_GFX -----------------\ 24bit FB storage API Support
ILI9341 \ \ CRGB methods like
SSD1331 |--- FastLED_SPITFT_GFX ----------------\ scale8/fadeToBlackBy ,FastLED API
ST7735 / | | / (XY 2D to 1D mapping)
| |
ArduinoOnPc-FastLED-GFX-LEDMatrix arduino - FrameBuffer::GFX------ Adafruit::NeoMatrix +
emulation for linux / Raspberry Pi: | | \ Adafruit::GFX APIs
---------------------------------- / Adafruit::GFX \
rpi-rgb-led-matrix - FastLED_RPIRGBPanel_GFX ---/ LEDMatrix (optional) `LEDMatrix API
ArduinoOnPC X11/linux - FastLED_TFTWrapper_GFX
FastLED_SDL (linux) - FastLED_NeoMatrix -/
This first demo of simple demo code that scaled up pretty quickly, explaining some of the challenges of scaling past 256 pixels in any dimention and 64K pixels total which hits a FastLED uint16_t limit:
This is an early demo of my shirt code running on a display that is so much bigger than what it was built for:
After some work to find a couple of crash bugs that came from scaling up, I was able to run Mark Estes' fantastic demo code I was able to scale up to such big displays without too much trouble. See Table_Mark_Estes1 and 14.
Table_Mark_Estes:
Table_Mark_Estes14:
Just put back an idea of scale between my first panel at 24x32, all the way up to 384x192. Yes, those are the exact same sprites with LEDSprites:
While 384x192 is starting to push the physical refresh limits that are acceptable for a 3 parallel chain setup, I'm going to try 384x256 for fun once I can get the pixel mapping to be correct. Bigger than that will require multiple control boards and synchronization by some network:
this was my first attempt, panel mapping didn't work, I'd have to write my own
Interestingly, SmartMatrix adds panels in the vertical direction by default, while rpi-rgb-led-matrix adds them horizontally. This means I had to write a new Mapper for it: V-Mapper, which allowed me to make 3 parallel horizontal chains. The end result is not great as refresh rate is only 100Hz, but it works:
success!
that was a lot of work for a low resolution screen :)
video still plays
New pictures of Table_Mark_Estes in the higher resolution:
As above, thanks again to Chow He from Electrodragon for the great and cheap active-3 boards, and big thanks to Hongren Su from Azerone for selling me the panels I have used so far. You can find the Azerone store on amazon for panels you can buy and the 128x64 P2 Panels here.
On the software side, many people to thank, but obviously I wouldn't have gotten started with Adafruit, Louis Beaudoin for SmartMatrix on arduino chips, and Henner Zeller for rpi-rgb-led-matrix of course.
Getting Higher Speeds
Pushing 256 lines deep (with 128 pixels wide for each chain) is pushing the limits of how much data you can push and still get an acceptable refresh rate. I had to lower some quality numbers to get a usable refresh rate:
rgb_matrix::RGBMatrix::Options defaults;
defaults.hardware_mapping = "regular"; // or e.g. "adafruit-hat"
defaults.rows = 64;
defaults.cols = 128;
defaults.chain_length = 4;
defaults.parallel = 3;
// 50 is faster but makes the screen dimmer
defaults.pwm_lsb_nanoseconds = 100;
// lower color depth definitely helps refresh
defaults.pwm_bits = 7;
// Time dithering of lower bits
// 2 changes speed from 400Hz (from 160Hz)
// 1 is also a faster option that's a bit brigher
defaults.pwm_dither_bits = 2;
defaults.led_rgb_sequence = "RBG";
defaults.panel_type = "FM6126A";
defaults.pixel_mapper_config = "V-mapper";
This is a temporary frame I made for my 384x256 array, itself made out of 3 smaller 128x192 arrays I was going to use as portable battery powered frames for my outfit. Unfortunately I used one bolt that was a bit too long and damaged a line on one panel when I screwed it in. Doh :(
Thanks to my friend Justice, I learned about this track day, which ended up getting few cars. I was able to attend with my F458C, maybe the last time I get to drive it since I'm looking at selling it, given that I just don't do track driving enough to be worth owning my own racecar. It was a bit bittersweet, but I was able to get a few 1:31 times. Unfortunately, by the time I put fresh tires, the track got warmer, and my times went up instead of down. I know I could have had 1:29 early in the morning, but never got to actually do it, oh well.
The plan is that I'll be able to rent from Fast Toys Club in the future:
ideally that's the one of the cars I'll be able to rent/drive after selling mine
After a quick drivers' meeting, it was time to go on track:
Lots of Mclarens:
Justice took his SVJ, beautiful car:
Ken came with my car and gave me support during the day:
I had fun, despite my times getting worse throughout the day as the track got warmer. In the afternoon, all the rungroups merged, so it was interesting, but it worked out pretty well.
Thanks to Fast Toys Club for the good day.
Since I was at Laguna Seca with my racecar and I had driven in the Model 3 (AWD LR, but not performance, 18" aero wheels), I figured I'd try the Tesla for a few laps. I should have planned this better and re-read my friend Matt Crowley's report when he tried that in his car a while back. Also, I didn't know Matt spent $3500 fixing his brakes after the day. This probably would have talked me out of trying :)
trying to get some charge from the 50A/220V plug I found.
Laguna unplugged me soon thereafter and put a nice note that such power was worth $700 + 40% surcharge, how nice of them, over $1000 for $4's worth of electricity.
ready, all you need is stickers, right? (they fit nicely on top of the mud I got driving in the snow in tahoe)
Anyway, given that ignorance is bliss, I went out with all my crap in the car, I figured removing it wouldn't change much anyway, and planned on doing only 3 laps so as not to thoroughly destroy the brakes. I did manage to hit 119 mph on my 2nd lap, and that was just when the brakes started not working due to overheating. Stopping in turn 2 was going to be "fun" (I made it though).
After 2 laps and boiled brake fluid, but also having passed a lamborghini and a porsche on the outside of the corkscrew, and being blackflagged for it :) I figured I'd call it a day. My 2nd lap (which was far from clean) was 1:56.
Those were not fast drivers, but it was cool to pass a few of them:
I passed several cars on the outside after the corkscrew in my ferrari, but got one in my tesla too :)
Sorry to the driver, I must have scared him a bit, he likely never saw/heard me until 'WTF is that car doing here'
And then there was the lambo I passed fair and square :)
wee!
Here is the first "session": (really 2 full laps and then I got black flagged for passing the porsche and scaring it). I passed the porsche at 3:40 and the lambo at 5:00
I came back for 2 more laps later in the afternoon when the track was warmer, my tires still over inflated, and my brake fluid still boiled (no firm pedal), and I got 2 laps of 1:55. I didn't commit for more speed in the straights because honestly I didn't know that car would stop and I didn't really want to completely destroy my braking hardware. Had done my first lap right, now knowing how to drive that car, I should have been able to get a single lap at 1:50 before the brakes gave up.
4 laps, 13 miles, 35% battery used
Two cleaner laps at 1:55 each, obviously not that fast, but my brake fluid was alrady boiled, my tires were likely too inflated (55psi) and the track was already 3-4 seconds slower than it was in the morning when I started I wonder how much faster the car could have been (I was already 10 mph slower before 2 due to the lack of brakes):
Looks like a full battery would have given 36 miles and 12 laps or so. This makes me question the wisdom of going through the work of tracking a tesla with proper brakes and tires. 12 laps is not a lot, and if you don't have a supercharger nearby (which is still 1h charge), that's not a lot of laps.
Overheating stuff, made other stuff unhappy :)
1.5Kw/mile, it's 1.5H of my house's power used in a single mile
On the plus side, despite all the errors I got, the car recovered when it cooled down, and even the brake fluid got back in a state that my brakes work somewhat. Not as well as before, but enough to stop the car :)
At least I didn't ran the pads down to the backing plates while destroying the rotors. That said, it's still amazing how a single lap at laguna seca can overheat stock breaks and boil brake fluid (which is exactly what happened in my case).
This was stupid, but it was fun. For comparison I did some 1:31's in my Ferrari F458 Challenge GT3 that morning on used tires. Looks like a stock Model 3 Performance with proper tires and brakes, can go 10 seconds faster than my 1:55's, not bad!
Due to a combination of sad timing and terrible season, I hadn't gone to Tahoe a single time this season yet. It took a long time waiting to have a decent enough day to go, and this wasn't going to be a ft+ storm, but the meager 8" was more snow than the entire month of february combined, so it wasn't time to be picky.
The drive up in my M3 was uneventful, I got there in one shot with 14% of battery left when I arrived.
The next morning, looked good. It looked nice, but the powder was not bottomless. You could definitely feel the crud underneath, which was unfortunate. Later in the day, 2 extra inches helped, and wind blowing made some nicer pockets of snow:
I was able to keep snow from burrying my car by using the heater
the line at cornice was surprisingly short for a sunday
the wall looked bony for this time of the season
eagle bowl was very bony
past resort boundary on the backside, was nice as usual
anything wind exposed was definitely bony, though
After a day of reasonably good snowboarding (cold though), I stayed at the towers, where I found something last minute for a couple of nights:
Unfortunately, it was a waste to have stayed for a 2nd day (monday) as anything worthwhile was closed because of the heavy wind. Such is life, but on top of that, somehow heavenly managed to open sky express during that time.
While solitude was as slow as I remember it to be, the few runs I did were not great, even in the trees, some of the snow had iced up hard (or all the new snow had been blown off, leaving the heavy crust underneath)
So, after a few crappy runs on solitude, I just drove home: