DIY UPDI high / low voltage programmer, UART switcher with reset possibility

[TRudolphi]

Some while ago I came across this library for the handy ATTiny controllers
 with only one pin needed for programming. These controllers are very useful for
 compact Arduino compatible designs.

One thing I was missing was a UPDI programmer which switches after the programming
-cycle back to the UART, so it can be used for tracing / debugging in the Arduino terminal
 (just like the ordinary Arduino boards).

So I designed some circuits for it.

• Simple 74HC4053-based UART-switcher with reset possibility
• A low / high voltage UPDI programmer and UART-switcher with reset-
possibility,
  so it can also be used when the target has a bootloader

After the flashing, the terminal gets active again, all over the same FTDI-USB-serial
-interface.
It is build with common parts.

Here is a link to my Github repository, complete with schematics and Arduino-sketch!

https://github.com/TRudolphi/MegaTinyProgrammer_LowMemoryLib/blob/main/UpdiProgrammerSwitcher.md

I made the programmers on an experiment-board, I have not (yet) a pcb for it.

I hope this programmer is useful for other makers!

[SpenceKonde]

Cool, interesting approach to the 12v pulse. My plan (have a board design that will go on my wierd stuff mini panel in next board order. I'm trying to avoid any firmware being needed - and I think i've got the method figured out: RTS and DTR. There's a 4P2T switch on the board to swap between serial monitor and UPDI modes. In UPDI mode: Power is fed to a MAX662 (Actually, likely a fake from china - I;m not about to pay Maxims prices). the RX and TX pins are connected for UPDI, and DTR is routed to a 339. Other circuits of the 339 are used to sense the current voltage coming out of the MAX662, and it both listens to and can drive the UPDI line (that takes the logic level issue that is endemic to SerialUPDI out of the picture and protects it from 12v. It's powered with the +12v, and you can tweak the reference voltage to make sure that we can understand it. To do HV, it will assert RTS, pulling the MAX662 shutdown pin low through a diode, and turning on the 12v, waits until the voltage is determined to be high enough ( comparator pulls another line low in that case, going to a modem control input and an LED. When it sees that, it will then pulse DTR low, which through the comparator (to protect it from the 12v that the gate of the p-channel fet has to be pulled to) will deliver HV. We will release both lines at that point and begin our programming attempt. And it's got a switch to allow you to put the 12v pulse on a pin other than UPDI, because pretty soon we will need to have a way to do that ;-)

[TRudolphi]

I also tried it first without firmware also to use the RTS pin, but you have to be aware, when the UART terminal is active both RTS and DTR are going LOW too, so that state is not unique. The MAX662 is interesting, but unfortunate only works on 5Volt. When you do it with a little controller all can be done automatic and with a tight timing, also the automatic switching between the UART terminal and the programming cycle (as with the ordinary Arduino boards).
With the programmer and your library I finally have the same possibilities back as I had with the good old PIC processors I was using in the early days (single chip in a SOIC package).

[Dlloydev]

Nice programmer!

I see your 12V pulse is quite fast (220μs) and there's some turn-off delay. Looks OK, but its possible that the pulse width and/or turn-off delay could be an issue in some rare situations. Unfortunately, the nature of the required HV pulse is poorly or incorrectly documented, however I've monitored its characteristics using an Atmel Power Debugger. Basically, their 12V pulse has razor sharp (ton/toff) with only 50μs duration.

I've duplicated the 50μs pulse with my Updi-Key design (please copy/use any part of it). This works without fail on my bread-board proto-type. Also works independently of whatever development software you're using (even works directly with the MPLAB Snap debugger, converting it to HV UPDI). The analog switch I used in the design is fast, 12V tolerant and works really well.

The boost converter for the 12V supply that I used is here (1.4-5.5Vin), this has light current loading effect ... worked while driven by an FTDI serial adapter that has 3.3V output that is internally derived from an output pin! (but of course, I recommend using an adequate 3.3V supply)

[TRudolphi]

I agree with you, the documentation is not very clear about the timing. I saw a tHV_ramp between 10ns and 4ms, but that is dealing the slope. The duration of the pulse I got from some projects found on the internet, explaining times between 100 and 500us, so I thought 200us was a nice in-between value. If you tink 50us is better, I can change that. I don't have a lot of devices, so I can not guarantee that it is working in all cases.
I saw another thread where you explaining some difficulties with some 32kb devices, but I don't have these.

The ISL43210 analog switch was indeed just I was looking for, now you have also a proper isolation between the 12Volt and 3.3/5Volt circuit! For my first proto-type I used what I had around my work-bench, including an Ali-express inexpensive 12Volt step-up converter.

Concerning the FTDI interface: I have one patched with a 3.3Volt regulator from the USB-power, then the power-source is much better.

I have also one TODO: when the PA0 is programmed as an output, the chip needs a power-cycle before setting the 12Volt pulse activation. This is not implemented and tested yet.

[Dlloydev]

This is the UPDI signal (complete programming cycle) on the Power Debugger when programming an Attiny1604 with UPDI pin (PA0) set to GPIO (output) ...

Zooming in on the 12 pulse ...

Whoops - it's only about 30μs. (I was using about 50μs for the Updi-Key)

With UPDI set to GPIO, there's a double-break, then power-cycle, then 12V pulse, then Key code is sent prior to the programming phase.
Check the code here for how I did this using an Attiny202. Note: I'm not releasing the Updi-Key as a product ... it's 100% open source so anyone can use whatever they need.

[jvasileff]

Are you planning to use this with the Arduino IDE? I've noticed the Arduino IDE conveniently closes the serial port terminal connection during programming, so one port can be very easily shared for the two uses.

But what is much less convenient is using terminal program (like screen) for debugging and CLI tools for programming - you have to manually disconnect the terminal each time you want to flash the device. I'm wondering if anyone has found a workaround for this (short of using the Arduino IDE). I'd really like to use just one UART, but this has always been a showstopper for me, so for now I've been using CP2105 dual-UART chips, which are expensive and buggy.

[TRudolphi]

Yes I use this programmer with Arduino. When the terminal is running, and you press the programming button all is automatically switches to the programming mode. after programming is done, the serial port is working again. All is working just like an ordinary Arduino board. It can work with UPDI or an internal bootloader.
I could not find a programmer who has these features, so I decided to design and build such a programmer (just for my own hobby). I now still busy with finetuning the firmware.

[TRudolphi]

@Dlloydev Thanks for sharing the measurement, this is very helpful! I try to change the firmware so it also does a power cycle (just as in your design). I do not need to send the keys, because that is done by the PC python scripts.