tinyupdi 1.5.0__tar.gz

tinyupdi-1.5.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Stefan Wagner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tinyupdi-1.5.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.1
+Name: tinyupdi
+Version: 1.5.0
+Summary: Minimal UPDI Programming Tool for tinyAVR
+Home-page: https://github.com/wagiminator/MCU-Flash-Tools
+Author: Stefan Wagner
+Author-email: Stefan Wagner <wagiminator@web.de>
+Maintainer-email: Stefan Wagner <wagiminator@web.de>
+License: MIT License
+        
+        Copyright (c) 2022 Stefan Wagner
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://wagiminator.github.io/
+Project-URL: Repository, https://github.com/wagiminator/MCU-Flash-Tools
+Project-URL: Issues, https://github.com/wagiminator/MCU-Flash-Tools/issues
+Keywords: AVR,Microchip,ATtiny,tinyAVR,UPDI,microcontroller
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Embedded Systems
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyserial
+
+# tinyUPDI - Minimal UPDI Programming Tool for tinyAVR
+## Description
+This tool allows tinyAVR series 0, 1, and 2 microcontrollers to be programmed using a USB-to-serial converter connected in a special way to the UPDI pin (also called SerialUPDI). More information can be found [here](https://github.com/SpenceKonde/AVR-Guidance/blob/master/UPDI/jtag2updi.md).
+
+## Preparations
+If necessary, a driver for the USB-to-serial converter used must be installed.
+
+## Installation
+- Install [Python3](https://www.pythontutorial.net/getting-started/install-python/).
+- Install [pip](https://pip.pypa.io/en/stable/installation/).
+- Install rvprog: 
+
+```
+pip install tinyupdi
+```
+
+## Usage
+Connect the USB-to-serial converter via USB to the PC and via the circuit described below to the UPDI pin of the microcontroller.
+
+```
+USB2SERIAL                       tinyAVR
++--------+                    +-----------+
+|     RXD| <------------+---> |UPDI (PA0) |
+|        |              |     |           |
+|     TXD| ---|1kOhm|---+     |           |
+|        |                    |           |
+|     VDD| -----------------> |VDD        |
+|     GND| -----------------> |GND        |
++--------+                    +-----------+
+```
+
+Alternatively, a pre-assembled [SerialUPDI programmer](https://github.com/wagiminator/AVR-Programmer) can be used.
+
+```
+Usage: tinyupdi [-h] [-d DEVICE] [-e] [-f FLASH] [-fs [FUSES [FUSES ...]]] [-t TRIM]
+
+Optional arguments:
+  -h, --help                show help message and exit
+  -d, --device              set target device (if not set, it will be auto-detected)
+  -e, --erase               perform a chip erase (implied with --flash)
+  -f FLASH, --flash FLASH   BIN file to flash
+  -fs [FUSES [FUSES ...]], --fuses [FUSES [FUSES ...]]
+                            fuses to set (syntax: fuse_nr:0xvalue)
+  -t TRIM, --trim TRIM      configure oscillator for given frequency (set fuse 2)
+Example:
+tinyupdi -f firmware.bin -fs 6:0x04 7:0x00 8:0x00 -t 8000000
+```
+
+## Links
+1. [MCU Templates](https://github.com/wagiminator/MCU-Templates)
+2. [MCU Development Boards](https://github.com/wagiminator/Development-Boards)
+3. [AVR Development Boards](https://github.com/wagiminator/AVR-Development-Boards)
+4. [SerialUPDI Programmers](https://github.com/wagiminator/AVR-Programmer)

tinyupdi-1.5.0/README.md

@@ -0,0 +1,53 @@
+# tinyUPDI - Minimal UPDI Programming Tool for tinyAVR
+## Description
+This tool allows tinyAVR series 0, 1, and 2 microcontrollers to be programmed using a USB-to-serial converter connected in a special way to the UPDI pin (also called SerialUPDI). More information can be found [here](https://github.com/SpenceKonde/AVR-Guidance/blob/master/UPDI/jtag2updi.md).
+
+## Preparations
+If necessary, a driver for the USB-to-serial converter used must be installed.
+
+## Installation
+- Install [Python3](https://www.pythontutorial.net/getting-started/install-python/).
+- Install [pip](https://pip.pypa.io/en/stable/installation/).
+- Install rvprog: 
+
+```
+pip install tinyupdi
+```
+
+## Usage
+Connect the USB-to-serial converter via USB to the PC and via the circuit described below to the UPDI pin of the microcontroller.
+
+```
+USB2SERIAL                       tinyAVR
++--------+                    +-----------+
+|     RXD| <------------+---> |UPDI (PA0) |
+|        |              |     |           |
+|     TXD| ---|1kOhm|---+     |           |
+|        |                    |           |
+|     VDD| -----------------> |VDD        |
+|     GND| -----------------> |GND        |
++--------+                    +-----------+
+```
+
+Alternatively, a pre-assembled [SerialUPDI programmer](https://github.com/wagiminator/AVR-Programmer) can be used.
+
+```
+Usage: tinyupdi [-h] [-d DEVICE] [-e] [-f FLASH] [-fs [FUSES [FUSES ...]]] [-t TRIM]
+
+Optional arguments:
+  -h, --help                show help message and exit
+  -d, --device              set target device (if not set, it will be auto-detected)
+  -e, --erase               perform a chip erase (implied with --flash)
+  -f FLASH, --flash FLASH   BIN file to flash
+  -fs [FUSES [FUSES ...]], --fuses [FUSES [FUSES ...]]
+                            fuses to set (syntax: fuse_nr:0xvalue)
+  -t TRIM, --trim TRIM      configure oscillator for given frequency (set fuse 2)
+Example:
+tinyupdi -f firmware.bin -fs 6:0x04 7:0x00 8:0x00 -t 8000000
+```
+
+## Links
+1. [MCU Templates](https://github.com/wagiminator/MCU-Templates)
+2. [MCU Development Boards](https://github.com/wagiminator/Development-Boards)
+3. [AVR Development Boards](https://github.com/wagiminator/AVR-Development-Boards)
+4. [SerialUPDI Programmers](https://github.com/wagiminator/AVR-Programmer)

tinyupdi-1.5.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tinyupdi"
+version = "1.5.0"
+authors = [
+    { name="Stefan Wagner", email="wagiminator@web.de" },
+]
+maintainers = [
+    { name="Stefan Wagner", email="wagiminator@web.de" },
+]
+description = "Minimal UPDI Programming Tool for tinyAVR"
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.8"
+dependencies = [
+    "pyserial",
+]
+keywords = ["AVR", "Microchip", "ATtiny", "tinyAVR", "UPDI", "microcontroller"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Embedded Systems",
+]
+
+[project.scripts]
+tinyupdi = "tinyupdi:_main"
+
+[project.urls]
+Homepage = "https://wagiminator.github.io/"
+Repository = "https://github.com/wagiminator/MCU-Flash-Tools"
+Issues = "https://github.com/wagiminator/MCU-Flash-Tools/issues"

tinyupdi-1.5.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tinyupdi-1.5.0/setup.py

@@ -0,0 +1,15 @@
+from setuptools import setup
+
+setup(
+    name='tinyupdi',
+    version='1.5.0',    
+    description='Minimal UPDI Programming Tool for tinyAVR',
+    url='https://github.com/wagiminator/MCU-Flash-Tools',
+    author='Stefan Wagner',
+    author_email='wagiminator@web.de',
+    license='MIT License',
+    packages=['tinyupdi'],
+    install_requires=[
+        'pyserial',                   
+    ],
+)

tinyupdi-1.5.0/tinyupdi/__init__.py

@@ -0,0 +1 @@
+from .tinyupdi import _main

tinyupdi-1.5.0/tinyupdi/tinyupdi.py

@@ -0,0 +1,769 @@
+#!/usr/bin/env python3
+# ===================================================================================
+# Project:   TinyUPDI - Minimal application-specific UPDI programmer based on pyupdi
+# Version:   v1.5
+# Year:      2022
+# Author:    Stefan Wagner
+# Github:    https://github.com/wagiminator
+# License:   MIT License
+# ===================================================================================
+#
+# Description:
+# ------------
+# TinyUPDI is a serial UPDI programmer software that is adapted to a specific
+# application and reduced to the functions required for this. It is normally used
+# for projects with a tinyAVR and a built-in USB to serial adapter to simplify
+# firmware uploading.
+#
+# References:
+# -----------
+# TinyUPDI is essentially based on pyupdi and pymcuprog:
+# - https://github.com/mraardvark/pyupdi
+# - https://github.com/microchip-pic-avr-tools/pymcuprog
+#
+# Dependencies:
+# -------------
+# - pyserial
+#
+# Restrictions:
+# -------------
+# - Target MCU must be a 0, 1, or 2-series tinyAVR.
+# - Only flash and fuses can be programmed.
+# - Firmware file must be a binary (not ELF or HEX!).
+#
+# Operating Instructions:
+# -----------------------
+# - python3 tinyupdi.py [-h] [-d DEVICE] [-e] [-f FLASH] [-fs [FUSES [FUSES ...]]]
+#   -h, --help                show help message and exit
+#   -d, --device              set target device (if not set, it will be auto-detected)
+#   -e, --erase               perform a chip erase (implied with --flash)
+#   -f FLASH, --flash FLASH   BIN file to flash
+#   -fs [FUSES [FUSES ...]], --fuses [FUSES [FUSES ...]]
+#                             fuses to set (syntax: fuse_nr:0xvalue)
+#   -t TRIM, --trim TRIM      configure oscillator for given frequency (fuse 2)
+# - Example:
+#   python3 tinyupdi.py -d attiny202 -f firmware.bin -fs 6:0x04 7:0x00 8:0x00 -t 8000000
+
+
+import re
+import sys
+import time
+import argparse
+import serial
+from serial import Serial
+from serial.tools.list_ports import comports
+
+# If the PID/VID of the USB-to-Serial converter is known, it can be defined here,
+# which can make the auto-detection a lot faster.
+#VID = '1A86'
+#PID = '7523'
+
+
+# ===================================================================================
+# Main Function
+# ===================================================================================
+
+def _main():
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Minimal command line'
+                                     ' interface for UPDI programming')
+    parser.add_argument('-d', '--device', choices=get_supported_devices(),
+                        help='target device (if not set, it will be auto-detected)')
+    parser.add_argument("-e", "--erase", action="store_true",
+                        help="perform a chip erase (implied with --flash)")
+    parser.add_argument('-f', '--flash', help='BIN file to flash')
+    parser.add_argument('-fs', '--fuses', action='append', nargs='*',
+                        help='fuses to set (syntax: fuse_nr:0xvalue)')
+    parser.add_argument('-t', '--trim', help='configure oscillator for given frequency (fuse 2)')
+    args = parser.parse_args(sys.argv[1:])
+
+    # Check arguments
+    if not any( (args.fuses, args.flash, args.erase) ):
+        print('No arguments - no action!')
+        sys.exit(0)
+
+    if args.fuses is not None:
+        fuselist = list()
+        for fslist in args.fuses:
+            for fsarg in fslist:
+                if not re.match('^[0-9]+:0x[0-9a-fA-F]+$', fsarg):
+                    sys.stderr.write('ERROR: Bad fuses format {}. Expected fuse_nr:0xvalue\n'.format(fsarg))
+                    sys.exit(1)
+                lst = fsarg.split(':0x')
+                fuselist.append( (int(lst[0]), int(lst[1], 16)) )
+
+    # Establish connection via serial to UPDI device
+    try:
+        print('Connecting to device ...')
+        tinyupdi = Programmer()
+    except Exception as ex:
+        sys.stderr.write('ERROR: ' + str(ex) + '!\n')
+        sys.exit(1)
+    print('SUCCESS: Found programmer on port %s.' % tinyupdi.port)
+
+    # Programming the device
+    try:
+        # Detect target device
+        print('Detecting target MCU ...')
+        device = tinyupdi.detect()
+        print('SUCCESS: Found %s with %d bytes of flash.' % (device, tinyupdi.flash_size))
+        if (args.device is not None) and (not args.device == device):
+            raise Exception('Found device is not ' + args.device)
+
+        # Perform chip erase
+        if (args.erase) or (args.flash is not None):
+            print('Performing chip erase ...')
+            tinyupdi.erase()
+
+        # Flash binary file
+        if args.flash is not None:
+            print('Flashing %s to %s ...' % (args.flash, device))
+            with open(args.flash, 'rb') as f: data = f.read()
+            tinyupdi.flash_data(data)
+            print('Verifying ...')
+            tinyupdi.verify_data(data)
+            print('SUCCESS: %d bytes written and verified.' % len(data))
+
+        # Write fuses
+        if args.fuses is not None:
+            print('Writing fuses ...')
+            for fuse in fuselist:
+                tinyupdi.set_fuse(fuse[0], fuse[1])
+            print('Verifying fuses ...')
+            for fuse in fuselist:
+                tinyupdi.verify_fuse(fuse[0], fuse[1])
+            print('SUCCESS: Fuses written and verified.')
+                
+        # Write fuse to set oscillator according to frequency
+        if args.trim is not None:
+            print('Setting oscillator for %s Hz ...' % args.trim)
+            osc = tinyupdi.trim(int(args.trim))
+            print('SUCCESS: Oscillator runs at %d MHz with corresponding factory calibration.' % osc)
+
+    except Exception as ex:
+        sys.stderr.write('ERROR: ' + str(ex) + '!\n')
+        tinyupdi.exit()
+        sys.exit(1)
+
+    # Finish all up
+    tinyupdi.exit()
+    print('DONE.')
+    sys.exit(0)
+
+
+# ===================================================================================
+# Programmer Class
+# ===================================================================================
+
+class Programmer(Serial):
+    def __init__(self):
+        super().__init__(baudrate = 230400, timeout = 1, parity=serial.PARITY_EVEN, stopbits=serial.STOPBITS_TWO)
+        self.syscfg_address  = 0x0F00
+        self.nvmctrl_address = 0x1000
+        self.sigrow_address  = 0x1100
+        self.fuses_address   = 0x1280
+        self.userrow_address = 0x1300
+        self.flash_pagesize  = 64
+        self.flash_start     = 0x8000
+        self.flash_size      = 0x0800
+        self.identify()
+
+    # Identify port of programmer and enter programming mode
+    def identify(self):
+        for p in comports():
+            if (('VID' not in globals()) or (VID in p.hwid)) and (('PID' not in globals()) or (PID in p.hwid)):
+                self.port = p.device
+                try:
+                    self.open()
+                except:
+                    continue
+                self.__send_double_break()
+                self.__init()
+                if not self.__check():
+                    self.close()
+                    continue
+                try:
+                    self.__enter_progmode()
+                except:
+                    self.__unlock()
+                return
+        raise Exception('Device not found')
+
+
+    # ------------------------------------------------------------------------------
+    # High-Level Functions
+    # ------------------------------------------------------------------------------
+
+    # Detect device
+    def detect(self):
+        deviceid = self.__get_device_id()
+        for dev in UPDI_DEVICES:
+            if dev['device_id'] == deviceid:
+                self.flash_size = dev['flash_size']
+                self.flash_pagesize = dev['flash_pagesize']
+                return dev['name']
+        raise Exception('Unknown or unsupported device')
+
+    # Disable UPDI and serial connection
+    def exit(self):
+        self.__reset(apply_reset=True)
+        self.__reset(apply_reset=False)
+        self.__stcs(UPDI_CS_CTRLB, (1 << UPDI_CTRLB_UPDIDIS_BIT) | (1 << UPDI_CTRLB_CCDETDIS_BIT))
+        self.close()
+
+    # Does a chip erase using the NVM controller (v0)
+    def erase(self):
+        if not self.__wait_nvm_ready():
+            raise Exception('Timeout waiting for flash ready before erase')
+        self.__execute_nvm_command(UPDI_V0_NVMCTRL_CTRLA_CHIP_ERASE)
+        if not self.__wait_nvm_ready():
+            raise Exception('Timeout waiting for flash ready after erase')
+
+    # Flash bin file
+    def flash_bin(self, filename):
+        with open(filename, 'rb') as f: data = f.read()
+        self.flash_data(data)
+        return len(data)
+
+    # Verify bin file
+    def verify_bin(self, filename):
+        with open(filename, 'rb') as f: data = f.read()
+        self.verify_data(data)
+        return len(data)
+
+    # Flash data
+    def flash_data(self, data):
+        if len(data) > self.flash_size:
+            raise Exception('Not enough memory')
+        self.__write_flash(self.flash_start, data)
+
+    # Verify data
+    def verify_data(self, data):
+        if len(data) > self.flash_size:
+            raise Exception('Not enough memory')
+        readback = self.__read_flash(self.flash_start, len(data))
+        if data != readback:
+            raise Exception('Flash verification failure')
+
+    # Set single fuse
+    def set_fuse(self, fusenum, value):
+        self.__write_fuse(fusenum, value)
+
+    # Verify single fuse
+    def verify_fuse(self, fusenum, value):
+        actual_val = self.__read_fuse(fusenum)
+        if actual_val != value:
+            raise Exception('Fuse ' + str(fusenum) + ' verification failure')
+
+    # Configure oscillator for given system freqency
+    def trim(self, freq):
+        for x in [1, 2, 4, 8, 16, 32, 64, 6, 10, 12, 24, 48]:
+            if round(20000000 / x) == freq:
+                self.set_fuse(0x02, 0x02)
+                self.verify_fuse(0x02, 0x02)
+                return 20
+            if round(16000000 / x) == freq:
+                self.set_fuse(0x02, 0x01)
+                self.verify_fuse(0x02, 0x01)
+                return 16
+        raise Exception('Unsupported frequency')
+
+
+    # ------------------------------------------------------------------------------
+    # Physical Layer for UPDI Stack
+    # ------------------------------------------------------------------------------
+
+    # Send a double break to reset the UPDI port
+    def __send_double_break(self):
+        self.close()
+        temporary_serial = Serial(self.port, 300, stopbits=serial.STOPBITS_ONE, timeout=1)
+        temporary_serial.write([UPDI_BREAK, UPDI_BREAK])
+        temporary_serial.read(2)
+        temporary_serial.close()
+        self.open()
+
+    # Send a char array to UPDI with NO inter-byte delay
+    def __send(self, command):
+        self.write(command)
+        self.read(len(command))
+
+    # Receive a frame of a known number of chars from UPDI
+    def __receive(self, size):
+        return self.read(size)
+
+
+    # ------------------------------------------------------------------------------
+    # Datalink Layer for UPDI Stack
+    # ------------------------------------------------------------------------------
+
+    # Set the inter-byte delay bit and disable collision detection
+    def __init(self):
+        self.__stcs(UPDI_CS_CTRLB, 1 << UPDI_CTRLB_CCDETDIS_BIT)
+        self.__stcs(UPDI_CS_CTRLA, 1 << UPDI_CTRLA_IBDLY_BIT)
+
+    # Check UPDI by loading CS STATUSA
+    def __check(self):
+        if self.__ldcs(UPDI_CS_STATUSA) != 0:
+            return True
+        return False
+
+    # Load data from Control/Status space
+    def __ldcs(self, address):
+        self.__send([UPDI_PHY_SYNC, UPDI_LDCS | (address & 0x0F)])
+        response = self.__receive(1)
+        if len(response) != 1:
+            return 0x00
+        return response[0]
+
+    # Store a value to Control/Status space
+    def __stcs(self, address, value):
+        self.__send([UPDI_PHY_SYNC, UPDI_STCS | (address & 0x0F), value])
+
+    # Load a single byte direct from a 16-bit address
+    def __ld(self, address):
+        self.__send([UPDI_PHY_SYNC, UPDI_LDS | UPDI_ADDRESS_16 | UPDI_DATA_8,
+                   address & 0xFF, (address >> 8) & 0xFF])
+        return self.__receive(1)[0]
+
+    # Load a 16-bit word directly from a 16-bit address
+    def __ld16(self, address):
+        self.__send([UPDI_PHY_SYNC, UPDI_LDS | UPDI_ADDRESS_16 | UPDI_DATA_16,
+                   address & 0xFF, (address >> 8) & 0xFF])
+        return self.__receive(2)
+
+    # Store a single byte value directly to a 16-bit address
+    def __st(self, address, value):
+        self.__send([UPDI_PHY_SYNC, UPDI_STS | UPDI_ADDRESS_16 | UPDI_DATA_8,
+                   address & 0xFF, (address >> 8) & 0xFF])
+        response = self.__receive(1)
+        if len(response) != 1 or response[0] != UPDI_PHY_ACK:
+            raise Exception('Failed to communicate with device (st)')
+        self.__send([value & 0xFF])
+        response = self.__receive(1)
+        if len(response) != 1 or response[0] != UPDI_PHY_ACK:
+            raise Exception('Failed to communicate with device (st)')
+
+    # Store a 16-bit word value directly to a 16-bit address
+    def __st16(self, address, value):
+        self.__send([UPDI_PHY_SYNC, UPDI_STS | UPDI_ADDRESS_16 | UPDI_DATA_16,
+                   address & 0xFF, (address >> 8) & 0xFF])
+        response = self.__receive(1)
+        if len(response) != 1 or response[0] != UPDI_PHY_ACK:
+            raise Exception('Failed to communicate with device (st)')
+        self.__send([value & 0xFF, (value >> 8) & 0xFF])
+        response = self.__receive(1)
+        if len(response) != 1 or response[0] != UPDI_PHY_ACK:
+            raise Exception('Failed to communicate with device (st)')
+
+    # Load a number of bytes from the pointer location with pointer post-increment
+    def __ld_ptr_inc(self, size):
+        self.__send([UPDI_PHY_SYNC, UPDI_LD | UPDI_PTR_INC | UPDI_DATA_8])
+        return self.__receive(size)
+
+    # Load a 16-bit word value from the pointer location with pointer post-increment
+    def __ld_ptr_inc16(self, words):
+        self.__send([UPDI_PHY_SYNC, UPDI_LD | UPDI_PTR_INC | UPDI_DATA_16])
+        return self.__receive(words << 1)
+
+    # Set the pointer location
+    def __st_ptr(self, address):
+        self.__send([UPDI_PHY_SYNC, UPDI_ST | UPDI_PTR_ADDRESS | UPDI_DATA_16,
+                   address & 0xFF, (address >> 8) & 0xFF])
+        response = self.__receive(1)
+        if len(response) != 1 or response[0] != UPDI_PHY_ACK:
+            raise Exception('Failed to communicate with device (st_ptr)')
+
+    # Store data to the pointer location with pointer post-increment
+    def __st_ptr_inc(self, data):
+        self.__send([UPDI_PHY_SYNC, UPDI_ST | UPDI_PTR_INC | UPDI_DATA_8, data[0]])
+        response = self.__receive(1)
+        if len(response) != 1 or response[0] != UPDI_PHY_ACK:
+            raise Exception('Failed to communicate with device (ACK st_ptr_inc)')
+        n = 1
+        while n < len(data):
+            self.__send([data[n]])
+            response = self.__receive(1)
+            if len(response) != 1 or response[0] != UPDI_PHY_ACK:
+                raise Exception('Failed to communicate with device (st_ptr_inc)')
+            n += 1
+
+    # Store a 16-bit word value to the pointer location with pointer post-increment
+    def __st_ptr_inc16(self, data):
+        ctrla_ackon = 1 << UPDI_CTRLA_IBDLY_BIT
+        ctrla_ackoff = ctrla_ackon | (1 << UPDI_CTRLA_RSD_BIT)
+        self.__stcs(UPDI_CS_CTRLA, ctrla_ackoff)
+        self.__send([UPDI_PHY_SYNC, UPDI_ST | UPDI_PTR_INC | UPDI_DATA_16] )
+        self.__send(data)
+        self.__stcs(UPDI_CS_CTRLA, ctrla_ackon)
+
+    # Store a value to the repeat counter
+    def __repeat(self, repeats):
+        if (repeats - 1) > UPDI_MAX_REPEAT_SIZE:
+            raise Exception('Invalid repeat count')
+        repeats -= 1
+        self.__send([UPDI_PHY_SYNC, UPDI_REPEAT | UPDI_REPEAT_BYTE, repeats & 0xFF])
+
+    # Write a key
+    def __key(self, size, key):
+        if len(key) != 8 << size:
+            raise Exception('Invalid Key length')
+        self.__send([UPDI_PHY_SYNC, UPDI_KEY | UPDI_KEY_KEY | size])
+        self.__send(list(reversed(list(key))))
+
+
+    # ------------------------------------------------------------------------------
+    # Application Layer for UPDI Stack
+    # ------------------------------------------------------------------------------
+
+    # Enter NVM programming mode
+    def __enter_progmode(self):
+        if self.__in_prog_mode():
+            return
+        self.__key(UPDI_KEY_64, UPDI_KEY_NVM)
+        key_status = self.__ldcs(UPDI_ASI_KEY_STATUS)
+        if not key_status & (1 << UPDI_ASI_KEY_STATUS_NVMPROG):
+            raise Exception('Key not accepted')
+        self.__reset(apply_reset=True)
+        self.__reset(apply_reset=False)
+        if not self.__wait_unlocked(100):
+            raise Exception('Failed to enter NVM programming mode: device is locked')
+        if not self.__in_prog_mode():
+            raise Exception('Failed to enter NVM programming mode')
+
+    # Get device ID
+    def __get_device_id(self):
+        return int.from_bytes(self.__read_data(self.sigrow_address, 3), byteorder='big')
+
+    # Check whether the NVM PROG flag is up
+    def __in_prog_mode(self):
+        if self.__ldcs(UPDI_ASI_SYS_STATUS) & (1 << UPDI_ASI_SYS_STATUS_NVMPROG):
+            return True
+        return False
+
+    # Wait for the device to be unlocked
+    def __wait_unlocked(self, timeout_ms):
+        timeout = Timeout(timeout_ms)
+        while not timeout.expired():
+            if not self.__ldcs(UPDI_ASI_SYS_STATUS) & (1 << UPDI_ASI_SYS_STATUS_LOCKSTATUS):
+                return True
+        return False
+
+    # Unlock and erase
+    def __unlock(self):
+        self.__key(UPDI_KEY_64, UPDI_KEY_CHIPERASE)
+        key_status = self.__ldcs(UPDI_ASI_KEY_STATUS)
+        if not key_status & (1 << UPDI_ASI_KEY_STATUS_CHIPERASE):
+            raise Exception('Key not accepted')
+        self.__reset(apply_reset=True)
+        self.__reset(apply_reset=False)
+        if not self.__wait_unlocked(500):
+            raise Exception('Failed to chip erase using key')
+
+    # Apply or release UPDI reset condition
+    def __reset(self, apply_reset):
+        if apply_reset:
+            self.__stcs(UPDI_ASI_RESET_REQ, UPDI_RESET_REQ_VALUE)
+        else:
+            self.__stcs(UPDI_ASI_RESET_REQ, 0x00)
+
+    # Wait for the NVM controller to be ready
+    def __wait_nvm_ready(self):
+        timeout = Timeout(10000)
+        while not timeout.expired():
+            status = self.__ld(self.nvmctrl_address + UPDI_NVMCTRL_STATUS)
+            if status & (1 << UPDI_NVM_STATUS_WRITE_ERROR):
+                return False
+            if not status & ((1 << UPDI_NVM_STATUS_EEPROM_BUSY) | (1 << UPDI_NVM_STATUS_FLASH_BUSY)):
+                return True
+        return False
+
+    # Execute an NVM COMMAND on the NVM CTRL
+    def __execute_nvm_command(self, command):
+        return self.__st(self.nvmctrl_address + UPDI_NVMCTRL_CTRLA, command)
+
+    # Write a number of words to memory
+    def __write_data_words(self, address, data):
+        if len(data) == 2:
+            value = data[0] + (data[1] << 8)
+            return self.__st16(address, value)
+        if len(data) > UPDI_MAX_REPEAT_SIZE << 1:
+            raise Exception('Invalid data length')
+        self.__st_ptr(address)
+        self.__repeat(len(data) >> 1)
+        return self.__st_ptr_inc16(data)
+
+    # Writes a number of bytes to memory
+    def __write_data(self, address, data):
+        if len(data) == 1:
+            return self.__st(address, data[0])
+        elif len(data) == 2:
+            self.__st(address, data[0])
+            return self.__st(address + 1, data[1])
+        if len(data) > UPDI_MAX_REPEAT_SIZE:
+            raise Exception('Invalid data length')
+        self.__st_ptr(address)
+        self.__repeat(len(data))
+        return self.__st_ptr_inc(data)
+
+    # Write a page of data to NVM (v0)
+    def __write_nvm(self, address, data, use_word_access=True):
+        if not self.__wait_nvm_ready():
+            raise Exception('Timeout waiting for flash ready before page buffer clear')
+        self.__execute_nvm_command(UPDI_V0_NVMCTRL_CTRLA_PAGE_BUFFER_CLR)
+        if not self.__wait_nvm_ready():
+            raise Exception('Timeout waiting for flash ready after page buffer clear')
+        if use_word_access:
+            self.__write_data_words(address, data)
+        else:
+            self.__write_data(address, data)
+        self.__execute_nvm_command(UPDI_V0_NVMCTRL_CTRLA_WRITE_PAGE)
+        if not self.__wait_nvm_ready():
+            raise Exception('Timeout waiting for flash ready after page write')
+
+    # Write one fuse value (v0)
+    def __write_fuse(self, fusenum, value):
+        if not self.__wait_nvm_ready():
+            raise Exception('Timeout waiting for NVM controller to be ready before fuse write')
+        address = self.fuses_address + fusenum
+        self.__st(self.nvmctrl_address + UPDI_NVMCTRL_ADDRL, address & 0xFF)
+        self.__st(self.nvmctrl_address + UPDI_NVMCTRL_ADDRH, (address >> 8) & 0xFF)
+        self.__st(self.nvmctrl_address + UPDI_NVMCTRL_DATAL, value & 0xFF)
+        self.__execute_nvm_command(UPDI_V0_NVMCTRL_CTRLA_WRITE_FUSE)
+        if not self.__wait_nvm_ready():
+            raise Exception('Timeout waiting for NVM controller to be ready after fuse write')
+
+    # Read a number of bytes of data from UPDI
+    def __read_data(self, address, size):
+        if size > UPDI_MAX_REPEAT_SIZE:
+            raise Exception('Can\'t read that many bytes in one go')
+        self.__st_ptr(address)
+        if size > 1:
+            self.__repeat(size)
+        return self.__ld_ptr_inc(size)
+
+    # Read a number of words of data from UPDI
+    def __read_data_words(self, address, words):
+        if words > UPDI_MAX_REPEAT_SIZE:
+            raise Exception('Can\'t read that many words in one go')
+        self.__st_ptr(address)
+        if words > 1:
+            self.__repeat(words)
+        return self.__ld_ptr_inc16(words)
+
+
+    # ------------------------------------------------------------------------------
+    # NVM programming algorithm
+    # ------------------------------------------------------------------------------
+
+    # Read from flash
+    def __read_flash(self, address, size):
+        pages = size // self.flash_pagesize
+        if size % self.flash_pagesize:
+            pages += 1
+        data = bytes()
+        for _ in range(pages):
+            data += (self.__read_data_words(address, self.flash_pagesize >> 1))
+            address += self.flash_pagesize
+        return data[:size]
+
+    # Write to flash
+    def __write_flash(self, address, data):
+        data = self.__pad_data(data, self.flash_pagesize)
+        pages = self.__page_data(data, self.flash_pagesize)
+        for page in pages:
+            self.__write_nvm(address, page, use_word_access=True)
+            address += len(page)
+
+    # Read one fuse value
+    def __read_fuse(self, fusenum):
+        address = self.fuses_address + fusenum
+        data = self.__ld(address)
+        return data
+
+    # Pad data so that there are full pages
+    def __pad_data(self, data, blocksize):
+        return data + b'\xFF' * (len(data) % blocksize)
+
+    # Divide data into pages
+    def __page_data(self, data, size):
+        total_length = len(data)
+        result = list()
+        while len(result) < total_length / size:
+            result.append(data[:size])
+            data = data[size:]
+        return result
+
+
+# ===================================================================================
+# Timeout Class
+# ===================================================================================
+
+# Simple timeout helper in milliseconds.
+class Timeout:
+    def __init__(self, timeout_ms):
+        self.timeout_ms = timeout_ms
+        self.start_time = time.time()
+
+    def expired(self):
+        return time.time() - self.start_time > self.timeout_ms / 1000.0
+
+
+# ===================================================================================
+# Error Class - Raise an Error
+# ===================================================================================
+
+class PrgError(Exception):
+    def __init__(self, msg='Something went wrong'):
+        super(PrgError, self).__init__(msg)
+        sys.stderr.write('ERROR: ' + msg + '\n')
+        sys.exit(1)
+
+
+# ===================================================================================
+# Device Definitions and Functions
+# ===================================================================================
+
+# Get list of supported device names
+def get_supported_devices():
+    result = list()
+    for d in UPDI_DEVICES:
+        result.append(d['name'])
+    return result
+
+# Device definitions
+UPDI_DEVICES = [
+    {'name': 'attiny202',  'device_id': 0x1E9123, 'flash_size': 0x0800, 'flash_pagesize': 0x40},
+    {'name': 'attiny402',  'device_id': 0x1E9227, 'flash_size': 0x1000, 'flash_pagesize': 0x40},
+    {'name': 'attiny212',  'device_id': 0x1E9121, 'flash_size': 0x0800, 'flash_pagesize': 0x40},
+    {'name': 'attiny412',  'device_id': 0x1E9223, 'flash_size': 0x1000, 'flash_pagesize': 0x40},
+    {'name': 'attiny204',  'device_id': 0x1E9122, 'flash_size': 0x0800, 'flash_pagesize': 0x40},
+    {'name': 'attiny404',  'device_id': 0x1E9226, 'flash_size': 0x1000, 'flash_pagesize': 0x40},
+    {'name': 'attiny804',  'device_id': 0x1E9325, 'flash_size': 0x2000, 'flash_pagesize': 0x40},
+    {'name': 'attiny1604', 'device_id': 0x1E9425, 'flash_size': 0x4000, 'flash_pagesize': 0x40},
+    {'name': 'attiny214',  'device_id': 0x1E9120, 'flash_size': 0x0800, 'flash_pagesize': 0x40},
+    {'name': 'attiny414',  'device_id': 0x1E9222, 'flash_size': 0x1000, 'flash_pagesize': 0x40},
+    {'name': 'attiny814',  'device_id': 0x1E9322, 'flash_size': 0x2000, 'flash_pagesize': 0x40},
+    {'name': 'attiny1614', 'device_id': 0x1E9422, 'flash_size': 0x4000, 'flash_pagesize': 0x40},
+    {'name': 'attiny424',  'device_id': 0x1E922C, 'flash_size': 0x1000, 'flash_pagesize': 0x40},
+    {'name': 'attiny824',  'device_id': 0x1E9329, 'flash_size': 0x2000, 'flash_pagesize': 0x40},
+    {'name': 'attiny1624', 'device_id': 0x1E942A, 'flash_size': 0x4000, 'flash_pagesize': 0x40},
+    {'name': 'attiny3224', 'device_id': 0x1E9528, 'flash_size': 0x8000, 'flash_pagesize': 0x80},
+    {'name': 'attiny406',  'device_id': 0x1E9225, 'flash_size': 0x1000, 'flash_pagesize': 0x40},
+    {'name': 'attiny806',  'device_id': 0x1E9324, 'flash_size': 0x2000, 'flash_pagesize': 0x40},
+    {'name': 'attiny1606', 'device_id': 0x1E9424, 'flash_size': 0x4000, 'flash_pagesize': 0x40},
+    {'name': 'attiny416',  'device_id': 0x1E9221, 'flash_size': 0x1000, 'flash_pagesize': 0x40},
+    {'name': 'attiny816',  'device_id': 0x1E9321, 'flash_size': 0x2000, 'flash_pagesize': 0x40},
+    {'name': 'attiny1616', 'device_id': 0x1E9421, 'flash_size': 0x4000, 'flash_pagesize': 0x40},
+    {'name': 'attiny3216', 'device_id': 0x1E9521, 'flash_size': 0x8000, 'flash_pagesize': 0x80},
+    {'name': 'attiny426',  'device_id': 0x1E922B, 'flash_size': 0x1000, 'flash_pagesize': 0x40},
+    {'name': 'attiny826',  'device_id': 0x1E9328, 'flash_size': 0x2000, 'flash_pagesize': 0x40},
+    {'name': 'attiny1626', 'device_id': 0x1E9429, 'flash_size': 0x4000, 'flash_pagesize': 0x40},
+    {'name': 'attiny3226', 'device_id': 0x1E9527, 'flash_size': 0x8000, 'flash_pagesize': 0x80},
+    {'name': 'attiny417',  'device_id': 0x1E9220, 'flash_size': 0x1000, 'flash_pagesize': 0x40},
+    {'name': 'attiny427',  'device_id': 0x1E922A, 'flash_size': 0x1000, 'flash_pagesize': 0x40},
+    {'name': 'attiny807',  'device_id': 0x1E9323, 'flash_size': 0x2000, 'flash_pagesize': 0x40},
+    {'name': 'attiny817',  'device_id': 0x1E9320, 'flash_size': 0x2000, 'flash_pagesize': 0x40},
+    {'name': 'attiny827',  'device_id': 0x1E9327, 'flash_size': 0x2000, 'flash_pagesize': 0x40},
+    {'name': 'attiny1607', 'device_id': 0x1E9423, 'flash_size': 0x4000, 'flash_pagesize': 0x40},
+    {'name': 'attiny1617', 'device_id': 0x1E9420, 'flash_size': 0x4000, 'flash_pagesize': 0x40},
+    {'name': 'attiny1627', 'device_id': 0x1E9428, 'flash_size': 0x4000, 'flash_pagesize': 0x40},
+    {'name': 'attiny3217', 'device_id': 0x1E9522, 'flash_size': 0x8000, 'flash_pagesize': 0x80},
+    {'name': 'attiny3227', 'device_id': 0x1E9526, 'flash_size': 0x8000, 'flash_pagesize': 0x80}
+]
+
+
+# ===================================================================================
+# UPDI Protocol Constants
+# ===================================================================================
+
+UPDI_BREAK = 0x00
+UPDI_LDS = 0x00
+UPDI_STS = 0x40
+UPDI_LD = 0x20
+UPDI_ST = 0x60
+UPDI_LDCS = 0x80
+UPDI_STCS = 0xC0
+UPDI_REPEAT = 0xA0
+UPDI_KEY = 0xE0
+UPDI_PTR = 0x00
+UPDI_PTR_INC = 0x04
+UPDI_PTR_ADDRESS = 0x08
+UPDI_ADDRESS_8 = 0x00
+UPDI_ADDRESS_16 = 0x04
+UPDI_ADDRESS_24 = 0x08
+UPDI_DATA_8 = 0x00
+UPDI_DATA_16 = 0x01
+UPDI_DATA_24 = 0x02
+
+UPDI_PHY_SYNC = 0x55
+UPDI_PHY_ACK = 0x40
+UPDI_REPEAT_BYTE = 0x00
+UPDI_REPEAT_WORD = 0x01
+UPDI_CS_STATUSA = 0x00
+UPDI_CS_STATUSB = 0x01
+UPDI_CS_CTRLA = 0x02
+UPDI_CS_CTRLB = 0x03
+UPDI_CTRLA_RSD_BIT = 3
+UPDI_CTRLA_IBDLY_BIT = 7
+UPDI_CTRLB_CCDETDIS_BIT = 3
+UPDI_CTRLB_UPDIDIS_BIT = 2
+UPDI_ASI_KEY_STATUS = 0x07
+UPDI_ASI_RESET_REQ = 0x08
+UPDI_ASI_CTRLA = 0x09
+UPDI_ASI_SYS_CTRLA = 0x0A
+UPDI_ASI_SYS_STATUS = 0x0B
+UPDI_ASI_CRC_STATUS = 0x0C
+UPDI_ASI_STATUSA_REVID = 4
+UPDI_ASI_STATUSB_PESIG = 0
+UPDI_ASI_KEY_STATUS_CHIPERASE = 3
+UPDI_ASI_KEY_STATUS_NVMPROG = 4
+UPDI_ASI_KEY_STATUS_UROWWRITE = 5
+UPDI_ASI_SYS_STATUS_RSTSYS = 5
+UPDI_ASI_SYS_STATUS_INSLEEP = 4
+UPDI_ASI_SYS_STATUS_NVMPROG = 3
+UPDI_ASI_SYS_STATUS_UROWPROG = 2
+UPDI_ASI_SYS_STATUS_LOCKSTATUS = 0
+UPDI_ASI_SYS_CTRLA_UROW_FINAL = 1
+UPDI_RESET_REQ_VALUE = 0x59
+UPDI_MAX_REPEAT_SIZE = (0xFF+1)
+
+UPDI_KEY_SIB = 0x04
+UPDI_KEY_KEY = 0x00
+UPDI_KEY_64 = 0x00
+UPDI_KEY_128 = 0x01
+UPDI_KEY_256 = 0x02
+UPDI_KEY_NVM = b'NVMProg '
+UPDI_KEY_CHIPERASE = b'NVMErase'
+UPDI_KEY_UROW = b'NVMUs&te'
+UPDI_SIB_8BYTES = UPDI_KEY_64
+UPDI_SIB_16BYTES = UPDI_KEY_128
+UPDI_SIB_32BYTES = UPDI_KEY_256
+
+UPDI_NVMCTRL_CTRLA = 0x00
+UPDI_NVMCTRL_CTRLB = 0x01
+UPDI_NVMCTRL_STATUS = 0x02
+UPDI_NVMCTRL_INTCTRL = 0x03
+UPDI_NVMCTRL_INTFLAGS = 0x04
+UPDI_NVMCTRL_DATAL = 0x06
+UPDI_NVMCTRL_DATAH = 0x07
+UPDI_NVMCTRL_ADDRL = 0x08
+UPDI_NVMCTRL_ADDRH = 0x09
+
+UPDI_V0_NVMCTRL_CTRLA_NOP = 0x00
+UPDI_V0_NVMCTRL_CTRLA_WRITE_PAGE = 0x01
+UPDI_V0_NVMCTRL_CTRLA_ERASE_PAGE = 0x02
+UPDI_V0_NVMCTRL_CTRLA_ERASE_WRITE_PAGE = 0x03
+UPDI_V0_NVMCTRL_CTRLA_PAGE_BUFFER_CLR = 0x04
+UPDI_V0_NVMCTRL_CTRLA_CHIP_ERASE = 0x05
+UPDI_V0_NVMCTRL_CTRLA_ERASE_EEPROM = 0x06
+UPDI_V0_NVMCTRL_CTRLA_WRITE_FUSE = 0x07
+
+UPDI_NVM_STATUS_WRITE_ERROR = 2
+UPDI_NVM_STATUS_EEPROM_BUSY = 1
+UPDI_NVM_STATUS_FLASH_BUSY = 0
+
+
+# ===================================================================================
+
+if __name__ == "__main__":
+    _main()

tinyupdi-1.5.0/tinyupdi.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.1
+Name: tinyupdi
+Version: 1.5.0
+Summary: Minimal UPDI Programming Tool for tinyAVR
+Home-page: https://github.com/wagiminator/MCU-Flash-Tools
+Author: Stefan Wagner
+Author-email: Stefan Wagner <wagiminator@web.de>
+Maintainer-email: Stefan Wagner <wagiminator@web.de>
+License: MIT License
+        
+        Copyright (c) 2022 Stefan Wagner
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://wagiminator.github.io/
+Project-URL: Repository, https://github.com/wagiminator/MCU-Flash-Tools
+Project-URL: Issues, https://github.com/wagiminator/MCU-Flash-Tools/issues
+Keywords: AVR,Microchip,ATtiny,tinyAVR,UPDI,microcontroller
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Embedded Systems
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyserial
+
+# tinyUPDI - Minimal UPDI Programming Tool for tinyAVR
+## Description
+This tool allows tinyAVR series 0, 1, and 2 microcontrollers to be programmed using a USB-to-serial converter connected in a special way to the UPDI pin (also called SerialUPDI). More information can be found [here](https://github.com/SpenceKonde/AVR-Guidance/blob/master/UPDI/jtag2updi.md).
+
+## Preparations
+If necessary, a driver for the USB-to-serial converter used must be installed.
+
+## Installation
+- Install [Python3](https://www.pythontutorial.net/getting-started/install-python/).
+- Install [pip](https://pip.pypa.io/en/stable/installation/).
+- Install rvprog: 
+
+```
+pip install tinyupdi
+```
+
+## Usage
+Connect the USB-to-serial converter via USB to the PC and via the circuit described below to the UPDI pin of the microcontroller.
+
+```
+USB2SERIAL                       tinyAVR
++--------+                    +-----------+
+|     RXD| <------------+---> |UPDI (PA0) |
+|        |              |     |           |
+|     TXD| ---|1kOhm|---+     |           |
+|        |                    |           |
+|     VDD| -----------------> |VDD        |
+|     GND| -----------------> |GND        |
++--------+                    +-----------+
+```
+
+Alternatively, a pre-assembled [SerialUPDI programmer](https://github.com/wagiminator/AVR-Programmer) can be used.
+
+```
+Usage: tinyupdi [-h] [-d DEVICE] [-e] [-f FLASH] [-fs [FUSES [FUSES ...]]] [-t TRIM]
+
+Optional arguments:
+  -h, --help                show help message and exit
+  -d, --device              set target device (if not set, it will be auto-detected)
+  -e, --erase               perform a chip erase (implied with --flash)
+  -f FLASH, --flash FLASH   BIN file to flash
+  -fs [FUSES [FUSES ...]], --fuses [FUSES [FUSES ...]]
+                            fuses to set (syntax: fuse_nr:0xvalue)
+  -t TRIM, --trim TRIM      configure oscillator for given frequency (set fuse 2)
+Example:
+tinyupdi -f firmware.bin -fs 6:0x04 7:0x00 8:0x00 -t 8000000
+```
+
+## Links
+1. [MCU Templates](https://github.com/wagiminator/MCU-Templates)
+2. [MCU Development Boards](https://github.com/wagiminator/Development-Boards)
+3. [AVR Development Boards](https://github.com/wagiminator/AVR-Development-Boards)
+4. [SerialUPDI Programmers](https://github.com/wagiminator/AVR-Programmer)

tinyupdi-1.5.0/tinyupdi.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+tinyupdi/__init__.py
+tinyupdi/tinyupdi.py
+tinyupdi.egg-info/PKG-INFO
+tinyupdi.egg-info/SOURCES.txt
+tinyupdi.egg-info/dependency_links.txt
+tinyupdi.egg-info/entry_points.txt
+tinyupdi.egg-info/requires.txt
+tinyupdi.egg-info/top_level.txt

tinyupdi-1.5.0/tinyupdi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tinyupdi-1.5.0/tinyupdi.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tinyupdi = tinyupdi:_main

tinyupdi-1.5.0/tinyupdi.egg-info/requires.txt

@@ -0,0 +1 @@
+pyserial

tinyupdi-1.5.0/tinyupdi.egg-info/top_level.txt

@@ -0,0 +1 @@
+tinyupdi