Greg Steiert @steieio@qoto.org

@funkylab @osmocom @LaF0rge I would argue that macOS and Android are even worse than Microsoft (iOS is fundamentally broken). It is very difficult to build an accessible platform agnostic solution with DFU. USB MSC can even work with Android or ChromeOS. That opens up cheap hardware that you could put in a middle school classroom.

@piggo @funkylab I agree with the fragility of the mbed implementation, and so did Michal Moksal who came up with UF2. He came up with some clever ways to get the data through in spite of the OS. His blog post "One chip to flash them all" describes the motivation and method: https://makecode.com/blog/one-chip-to-flash-them-all

@funkylab Great question. DFU was intended for this but everyone implements it differently and the drivers are not built into operating systems by default, so you need to write a custom application and build it for every operating system you want to support. MSC (Mass Storage Class) used by USB drives is supported in everything (even Android) without a custom app. The blog post I linked to explains why they developed UF2 at Microsoft

UF2 works for data too.

The USB Flashing Format (UF2) was developed as a way to update firmware on microcontrollers, but it works equally well for data. Let’s look at how and why you might want to do that using the real world application of loading an FPGA.

The great thing about UF2 is that it emulates a USB thumb drive so images can be transferred by dragging and dropping the properly formatted file using the drivers that are standard in every operating system. The key is the specially formulated packets that you can read about in this blog:
https://makecode.com/blog/one-chip-to-flash-them-all
I also spoke about it at Crowd Supply Teardown 2023:
https://www.youtube.com/watch?v=AdoWZkSSaoA

While primarily created for firmware updates, it can transfer data just as easily. In the case of loading an FPGA, the firmware that loads the image into the FPGA does not need to change for each new image. One way to transfer the data is to convert the image to a C array and build it with the firmware, but that would require rebuilding the firmware for every new image which is not necessary. Instead of converting the image to a C array, you can convert it to UF2 packets so that it can be loaded directly into flash without rebuilding.

I did just this when I ported Altera’s JBC player code to the Raspberry Pi Pico board. The RP2040 implements a UF2 bootloader in its ROM, and the SDK produces a UF2 file when building the code. The same bootloader can be used to load an FPGA JBC image into the flash by converting the file to UF2 packets with the uf2conv utility.

The JBC player firmware needs to know where the JBC FPGA image is located, and the size. To make sure the firmware is compatible with the image, and make it easier to use, I decided to combine the firmware UF2 image with the JBC UF2 image. I created a custom UF2 converter that would take the firmware output from the RP2040 SDK, add a 256byte header with the JBC image size, and append the JBC image.

The header is 256 bytes to fill one UF2 block, so I added some additional information such as a description of the image. The output is a combined file similar to if you had included the JBC file as a C array, but in this case, to replace the JBC image, you do not need to have the RP2040 SDK installed, you only need to run a Python script.

You can learn more about the process and some quirks with the RP2040 ROM UF2 implementation in this Crowd Supply Teardown Session:
https://www.youtube.com/watch?v=Ns5RiT4F2Mw

The code is available on GitHub:
https://github.com/steieio/jbcuf2
And I used it in a workshop at Crowd Supply Teardown 2024:
https://github.com/gsteiert/pico-dirty-blaster-workshop

@azonenberg @gsuberland do they make single row you can press fit from both sides? Do any of the distributors list pin count? That could be an indirect way to check for extra center taps.

@crowdsupply @helenleigh Don't miss your chance to win an #FPGA dev kit!

Only three days until I join @Helenleigh in a @crowdsupply Teardown Session. Find out what SVF, JAM, JBC, UF2, and MCU have to do with loading an #FPGA, and you might even win an #Altera MAX 10 development kit for your own.
https://m.youtube.com/watch?v=Ns5RiT4F2Mw

@crowdsupply @helenleigh
I guess they will let anyone on this.
Wish me luck.

Ever wonder how to program an FPGA through an MCU?

That is what I showed people how to do in my workshop at @crowdsupply Teardown 2024. The participants didn't even need to install any software as the method emulates a USB thumb drive for drag-n-drop programming.

If you are interested in how this works or where I got the idea, I will be speaking with @helenleigh in a Teardown Session on YouTube at noon Pacific Time on December 5th.
https://www.youtube.com/watch?v=Ns5RiT4F2Mw

I'll talk about where I got the idea, and how a failed first attempt lead to an even better solution. Along the way, I'll cover some of the various methods for loading an FPGA and their tradeoffs and other background details. This will also touch on my favorite UF2 file format.

Let me know in the comments if there is something specific you wold like me to cover.

The instructions and code from the workshop are available on GitHub if you want to try it yourself:
https://github.com/gsteiert/pico-dirty-blaster-workshop

A few lucky viewers of the live-stream will get a workshop kit including the MAX10 FPGA based 10M08 Evaluation Kit courtesy of Altera.

#FPGA #microcontroller

Did you ever wonder how much current you can draw from the energy harvested output of an NFC EEPROM? I did, and I built a board to measure it.

The ST25DV and NXP NTAG I2C PLUS are designed for the same antenna loading so I was able to design a board that would support both devices. The results were a little surprising. The NXP NTAG I2C PLUS does a much better job regulating the output voltage. The ST25DV starts at about 4V with no load, and drops off rather quickly. I could draw almost 5mA before dropping below the 2.7V minimum voltage of the WCH32V003 with the NT3H2211, but less than 4mA from the ST25DV. Based on this data, I switched my beeping, blinking business-card designs to the NT3H2211.

Learn more about the project on Hackaday:
https://hackaday.io/project/177897-beeping-blinking-business-card-badge-b4/log/221646-power-estimates

We really need to give more credit to NXP for creating tools like SPSDK in Python, available through #PyPI, with source on #GitHub, and documentation on #readthedocs. Their MCUXpresso SDK is also available on GitHub.

If for no other reason, to shame other vendors into following their lead. Am I wrong?

https://spsdk.readthedocs.io/en/latest/

Just submitted another #tinytapeout
This could be addictive
Thank you @matthewvenn
It is yet another take on programmable logic, implementing a state machine using SPI flash: https://github.com/steieio/tt02-sfsm-wokwi

Happy Halloween