ATtiny mit Arduino Code programmieren

Über den Beitrag

Vor geraumer Zeit hatte ich einen Beitrag zum Thema „ATtiny85 / 84 / 45 / 44 /25 / 24 programmieren“ geschrieben. Dabei kam das Boardverwalter Paket „attiny“ von David A. Mellis zum Einsatz. Es gibt allerdings ein anderes Paket namens ATTinyCore von Spence Konde, welches viel mehr Vertreter der ATtiny Familie abdeckt und erheblich komfortabler ist. Zudem sind sowohl der Funktionsumfang, wie auch die Unterschiede der einzelnen Vertreter der ATtiny Familie ganz hervorragend dokumentiert.

Zeit also für einen neuen Beitrag zu diesem Thema! Das kommt auf euch zu:

Vorteile von ATTinyCore vs. attiny

ATTinyCore kann alles, was auch das ältere Paket „attiny“ kann, nur noch mehr. Hier die aus meiner Sicht wichtigsten Vorteile:

  • Ihr könnt derzeit 20 ATtiny MCUs anstelle von 6 programmieren.
  • ATTinyCore beherrscht I2C, SPI und UART (Serial) ohne dass ihr zusätzliche Bibliotheken benötigt.
  • Größere Bootloaderauswahl (gilt allerdings nicht für alle Vertreter):
    • Ohne, d.h. Programmierung per ISP.
    • Optiboot, d.h. „Arduino-like“ Programmierung über Serial.
    • Micronucleus (VUSB), d.h. Programmierung à la Digispark.
  • Mehr Feineinstellungen sind möglich, wie die (De-)Aktivierung von micros()/millis() oder BOD-Level (Brown Out Detection).

Dabei möchte ich besonders den zweiten Punkt hervorheben. Die meisten ATtinys besitzen anstelle einer „echten“ I2C-, SPI- und UART-Schnittstelle eine sogenannte USI-Schnittstelle (Universal Serial Interface). Es ist zwar möglich I2C, SPI und UART über die USI-Schnittstelle zu implementieren, das erfordert aber eine entsprechende Softwarelösung. Und genau die ist in ATTinyCore schon implementiert. 

Die ATtiny Familie – Übersicht

Ich habe in Microchip Studio (ehemals Atmel Studio), der Software von Microchip zum Programmieren der AVR- und SAM-Mikrocontroller, nachgezählt: Dort könnt ihr zwischen 75 verschiedenen ATtiny MCUs auswählen. Man kann wohl eher von einer Großfamilie sprechen.

Welche ATtiny Typen ihr mit ATTinyCore programmieren könnt

Hier eine Liste der ATtiny-MCUs, die für ATtinyCore geeignet sind:

ATtiny Typen, die ihr mit ATTinyCore programmieren könnt.
ATtiny Typen, die ihr mit ATTinyCore programmieren könnt.

Die Tabelle listet nur einige wenige technische Eigenschaften der ATtinys auf. Wer mehr wissen möchte und keine Lust hat, lange Datenblätter zu lesen, dem kann ich wirklich wärmstens empfehlen, in der ATTinyCore Dokumentation auf GitHub zu stöbern.

Nicht abgedeckte ATtiny Typen in ATtinyCore

Es gibt ein weiteres Paket von Spence Konde mit dem Namen megaTinyCore. Dieses deckt die rechts aufgelisteten ATtiny-Typen ab, die sich fundamental von den anderen Familienmitgliedern unterscheiden. Sie werden nicht über ISP, sondern über UPDI  (Universal Programming and Debugging Interface) programmiert. UPDI ist ein „single-wire“ Verfahren, das also über ein einziges Datenkabel läuft.

Über die UPDI-basierten ATtinys werde ich später einmal einen separaten Beitrag machen. Zunächst muss ich mich da selbst noch einarbeiten.

Warum sollte ich ATtiny MCUs verwenden?

Vergleicht ihr die Leistungsstärke von ATtiny MCUs mit denen eines ESP32, ESP8266 oder ATmega Typen, dann sehen die ATtinys nicht unbedingt gut aus. ABER: Sie sind klein, sie sind stromsparend und in der Regel günstig. Für viele Projekte sind die großen MCUs überdimensioniert.

Vorbereitung der Arduino IDE

Geht in der Arduino IDE auf Datei → Einstellungen. Klickt auf das Symbol neben „Zusätzliche Boardverwalter-URLs“. Im aufpoppenden Fenster tragt ihr die folgende Zeile ein:

http://drazzy.com/package_drazzy.com_index.json

Dann schließt ihr die Fenster mit Klick auf „OK“.

ATtiny Programmierung mit der Arduino IDE: Boardverwalter URL für ATTinyCore eintragen
Boardverwalter URL für ATTinyCore eintragen

Nun navigiert ihr zu Werkzeuge → Board → Boardverwalter. Gebt „attiny“ als Suchbegriff ein und installiert ATTinyCore von Spence Konde.

ATtiny Programmierung mit der Arduino IDE: ATTinyCore Paket installieren
ATTinyCore Paket installieren

Wenn alles geklappt hat, dann solltet ihr jetzt ATTinyCore unter den auswählbaren Boardgruppen finden:

Riesenauswahl an ATtinys und Optionen nach Installation von ATtinyCore
Riesenauswahl an ATtinys und Optionen

Upload von Sketchen auf den ATtiny

Jetzt kommt der interessantere Teil, denn jetzt laden wir Sketche auf den ATtiny. Dabei gibt es, wie schon erwähnt, drei Methoden. Als Anschauungsobjekt verwende ich den beliebten ATtiny85. Ich habe aber auch einen ATtiny4313, einen ATtiny861 und einen ATtiny1634 erfolgreich mit den jeweils verfügbaren Optionen getestet.

Zur besseren Orientierung ist hier die Pinbelegung des ATtiny85:

Pinout des ATtiny85
Pinout des ATtiny85

Die hier vorgestellten Methoden lassen sich leicht auf die anderen ATtinys übertragen.

Option 1: Upload ohne Bootloader (ISP)

Die gängigste, „natürliche“ Methode, einen Mikrocontroller zu programmieren, ist ISP (In-System-Programming). Die Bezeichnung soll verdeutlichen, dass der Mikrocontroller in seiner Anwendungsumgebung programmiert werden kann. Er muss also nicht vor seinem Einbau separat vorbereitet werden.

Die ISP Programmierung erfolgt über die Pins der SPI Schnittstelle. Da auch die Pinbezeichnungen gleich sind (MOSI, MISO, SCK) ist die Verkabelung einfach.

Variante 1: Der Arduino als ISP Programmer

Vorbereitung

Die schlechte Nachricht ist, dass ihr zum Programmieren per ISP einen Programmer braucht. Die gute Nachricht lautet, dass ihr einen Arduino UNO oder Nano zum Programmer machen könnt. Dazu müsst ihr nur eines tun:

  • Ladet den Sketch ArduinoISP auf das Board, das als Programmer dienen soll. Ihr findet den Sketch in der Arduino IDE unter Datei → Beispiele → Mitgelieferte Beispiele → ArduinoISP.

Jetzt verbindet ihr euren eben erzeugten Programmer wie folgt mit dem ATtiny (Beispiel Arduino Nano):

Arduino Nano als ISP Programmer für den ATtiny85
Arduino Nano als ISP Programmer für den ATtiny85

Auf dem Arduinoboard ist MOSI der digitale Pin 11, MISO ist 12 und SCK ist 13. Wo sich die entsprechenden Pins beim Mikrocontroller befinden, ist leicht über sein Pinoutschema herauszubekommen. Den digitalen Pin 10 des Arduino verbindet ihr mit dem Resetpin des ATtiny. An den Reset-Pin des Arduino hängt ihr noch einen Kondensator (10 µF). Die LED an PB4 verwenden wir später. Für die Programmierung braucht ihr sie nicht.

Falls ihr erst die Schaltung aufgebaut habt und dann den ArduinoISP Sketch hochladen wollt, kann der Kondensator Probleme bereiten. Entfernt ihn beim Hochladen.

Hochladen
Settings für den ATtiny in der Arduino IDE
Settings für den ATtiny85

Jetzt wählt ihr in der Arduino IDE die Boardfamilie und das Board aus.

Dann könnt ihr noch einige Einstellungen vornehmen, wie beispielsweise die Taktrate. Lasst die weiteren Optionen am besten erst mal so wie sie sind.

Als Programmer stellt ihr „Arduino as ISP“ ein.

Vor dem ersten Programmupload klickt ihr auf „Bootloader brennen“. Das ist irreführend, denn es wird kein Bootloader gebrannt, sondern es werden lediglich die sogenannten Fuse-Bits gesetzt. Dabei handelt es sich um nicht-volatile, also permanent eingestellte Bits, mit denen die eben beschriebenen Einstellungen im Mikrocontroller vorgenommen werden.

Und nun könnt ihr endlich einen Sketch hochladen. Für gewöhnlich teste ich erst einmal, ob ein einfacher Blinksketch wie der folgende funktioniert:

int ledPin = 4;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);   
  delay(500);                     
  digitalWrite(ledPin, LOW);    
  delay(500);                     
}

 

Variante 2: Andere ISP-Programmer verwenden

Programmer-Übersicht
USBtinyISP Programmer
ISP Breadboardadapter
ISP Breadboardadapter

Wenn ihr hinsichtlich der ATtiny Programmierung auf den Geschmack gekommen seid, empfehle ich die Anschaffung eines ISP Programmers. Eine preiswerte Option ist der USBtinyISP, den ihr für <10 Euro z.B. bei Amazon bekommt. Falls ein Treiber benötigt wird, schaut hier bei Adafruit.

Am besten investiert ihr dann noch in einen ISP-Breadboardapter (rechts), der euch das Leben erheblich vereinfacht und die Gefahr von Falschverkabelungen deutlich mindert.

Ähnlich günstig sind USBasp Programmer. Zu dem Teil, das ich gekauft habe (s.u.), gab es sogar eine gute Anleitung, was ja sonst leider selten ist.

USBasp Programmer

Ein etwas teurerer Programmer, der dann aber auch sowohl mit der Arduino IDE wie auch mit Microchip Studio funktioniert, ist der Diamex USB-ISP. Ihr bekommt ihn hier für etwas über 20 Euro. Alternativ gibt es diese Teile als Tremex USB ISP Programmer z. B. bei Amazon.

Diamex / Tremex USB-ISP Programmer
Diamex USB-ISP Programmer

Die Luxus-Variante ist der ATATMEL-ICE Programmer (kurz: ATMEL-ICE). Er funktioniert mit der Arduino IDE, mit Microchip Studio, beherrscht debugWire und UPID. Dafür legt ihr dann allerdings um die 150 Euro auf den Tisch…

Anschluss an den ATtiny und Hochladen
ISP Anschlusschema

Der Anschluss an den ATtiny ist mithilfe des rechts abgebildeten Schemas für den ISP Stecker selbsterklärend.

Da man sich dabei leicht vertun kann, möchte ich noch einmal für Breadboardschaltungen den schon erwähnten Adapter empfehlen.

Zum Hochladen von Sketchen wählt ihr in der Arduino IDE den Ziel-Mikrocontroller, den Programmer und brennt vor dem ersten Hochladen den Bootloader. Dann könnt ihr den ersten Probesketch hochladen.

Option 2 – Upload mit Optiboot Bootloader

Über den Optiboot Bootloader

Diese Methode ist diejenige, die auch auf den Arduino Boards zum Einsatz kommt. Der Optiboot Bootloader sorgt dafür, dass die Sketche über die serielle Schnittstelle (USI beim ATtiny, sonst UART) hochgeladen werden. Vorteilhaft ist, dass weniger Leitungen als beim Hochladen per ISP benötigt werden. Außerdem könnt ihr den seriellen Monitor wie bei Verwendung eines Arduino Entwicklungsboards benutzen. Der große Nachteil ist, dass der Bootloader fast 600 Bytes des Flashspeichers belegt. Deswegen unterstützt ATTinyCore den Optiboot-Bootloader nicht für die ATtinys mit 2 kB Speicher.

Bootloader brennen

Leider kommt ihr nicht umhin, den Optiboot-Bootloader per ISP auf den ATtiny zu brennen. D.h. zumindest einmal müsst ihr also eine der zuvor beschrieben Prozeduren (Option 1 oder 2) anwenden. Bei der Einstellung des Ziel-Mikrocontrollers wählt ihr die Optibootvariante.

USB zu TTL Adapter

Damit die USB-Schnittstelle eures PCs mit der seriellen Schnittstelle des ATtiny kommunizieren kann, braucht ihr einen Adapter. Den findet ihr in Online-Shops für wenige Euro unter der Bezeichnung „USB-zu-TTL“, „USB-UART“ oder „FT232RL-FTDI“ Adapter.

Verschiedene USB zu TTL Serial Adapter zur ATtiny Programmierung
Verschiedene USB-zu-TTL Serial Adapter

Anschluss an den ATtiny

Verbindet den RX-Pin eures Adapters mit AIN0 des ATtiny und TX mit AIN1. Dann verbindet ihr noch VCC mit VCC und GND mit GND. Der Taster an Reset des ATtiny soll nur andeuten, dass ihr Reset bei Bedarf auf GND ziehen können sollt. Das wird für den Upload bnötigt.

ATtiny – Anschluss an einen USB zu TTL Serial Adapter

Alternativ zum Taster nutzt ihr – sofern vorhanden – den DTR Pin des Adapters für den Upload. Dafür müsst ihr den DTR Pin des Adapter mit dem Reset Pin des ATtiny über einen Kondensator verbinden und einen Pull-Up Widerstand hinzufügen:

Upload mithilfe des DTR Pins
Upload mithilfe des DTR Pins

Sketche hochladen

Wählt den Port, an dem der USB-zu-TTL Adapter hängt. Es ist egal, welchen Programmer ihr einstellt. Nun ladet euren Sketch hoch. Dazu wartet ihr, bis der Sketch kompiliert ist und der eigentliche Upload beginnen soll. Dann führt einen Reset am ATtiny aus. Hier kommt jetzt der Taster zum Einsatz (oder der DTR Pin). Ich habe den Testsketch etwas erweitert, um zu prüfen, ob die Ausgabe am seriellen Monitor funktioniert.

const int ledPin = 4;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  Serial.println("Hello World");
  digitalWrite(ledPin, HIGH);   
  delay(500);                     
  digitalWrite(ledPin, LOW);    
  delay(500);                     
}

 

Option 3 – Micronucleus: wir bauen einen Digispark!

Über den Micronucleus

Der Micronucleus ist der Bootloader, der auf den Digispark Boards verwendet wird. Dabei wird der ATtiny ohne Adapter direkt über USB programmiert. Um das zu ermöglichen, nutzt der Micronucleus eine Technik namens VUSB. Damit können auch Bauteile, die keine Hardware USB-Schnittstelle besitzen, über USB angesprochen werden.

Ein gewisser Vorteil des Micronucleus ist, dass ihr den Reset-Pin des ATtiny in einen GPIO umwandeln könnt. Der Nachteil ist – wie beim Optiboot – die Reduktion des verfügbaren Flash-Speichers. Leider ist der Speicherbedarf des Micronucleus noch größer. Von den 8192 Bytes eines ATtiny85 bleiben euch nur 6586 Bytes für eure Programme.

Vorbereitung

Falls ihr noch nicht mit dem Digispark gearbeitet haben solltet, dann müsst ihr zunächst einen Treiber für den Micronucleus installieren, den ihr hier herunterladen könnt. Entpackt die Zip-Datei und führt „Install Drivers.exe“ für ein 32-Bit System aus oder „DPInst64.exe“ für ein 64-Bit System.

Dann müsst ihr auch hier zunächst den Bootloader einmalig per ISP brennen („Fresh Install“):

Bootloader brennen - Optionen der Arduino IDE
Bootloader brennen – Optionen der Arduino IDE

Für den Reset-Pin könnt ihr „Reset“ oder „GPIO“ wählen. Mit „GPIO“ habt ihr einen GPIO mehr zur Verfügung, könnt den ATtiny dann allerdings nicht mehr per ISP programmieren. Dazu müsstet ihr erst ein Bootloader-Upgrade per USB durchführen und dabei dem Reset-Pin seine Resetfunktion zurückgeben.

Schaltung

Für die Schaltung benötigt ihr, außer dem ATtiny, zwei 68 Ω Widerstände, einen 1.5 kΩ Widerstand und zwei 3.6 Volt Zenerdioden. Die Zenerdioden dienen dem Schutz der USB-Schnittstelle eures Computers, denn die Datenleitungen laufen auf 3.3 Volt. Seid also vorsichtig, was ihr tut!

Schaltung für die ATtiny Programmierung mit dem Micronucleus Bootloader
Schaltung für die Programmierung mit dem Micronucleus Bootloader

Für den USB-Anschluss empfehle ich ein USB Break-Out Modul, das ihr für < 1 Euro in Online-Shops bekommt. So sah die Schaltung dann auf dem Breadboard aus:

Breadboardschaltung à la Digispark

Welche Pins ihr bei anderen ATtinys mit den USB-Anschlüssen verbinden müsst, findet ihr in der ATTinyCore Dokumentation auf GitHub. Folgt diesem Link und klickt dann auf den ATtiny eurer Wahl.

Den vollständigen Schaltplan für einen Digispark findet ihr hier. Da ist dann auch der Festspannungsregler und die On-Board LED enthalten.

Sketche hochladen

Das Hochladen funktioniert wie bei einem Digispark. Das heißt, ihr verbindet eure Schaltung zunächst noch nicht über USB mit dem Computer. Als Programmer wählt ihr in der Arduino IDE den „Micronucleus“. Dann startet ihr das Hochladen. Die USB-Verbindung stellt ihr erst her, wenn ihr dazu aufgefordert werdet:

Upload per Micronucleus
Upload per Micronucleus

Hochladen per ISP und den seriellen Monitor nutzen

Ihr wollt keinen Bootloader und trotzdem den seriellen Monitor nutzen? Da gibt es zwei Möglichkeiten.

Option 1: zusätzlich den USB zu TTL Serial Adapter verwenden

Ihr verfahrt zum Hochladen der Sketche so, wie oben für ISP beschrieben und schließt zusätzlich den USB-zu-TTL Adapter an. In der Schaltung unten verwende ich dafür die Serial Pins AIN0 und AIN1. Alternativ könnt ihr auch ein SoftwareSerial einrichten.

Arduino als ISP mit USB zu TTL Adapter für den seriellen Monitor
Arduino als ISP mit USB-zu-TTL Adapter für den seriellen Monitor

Option 2: mit modifiziertem ArduinoISP Sketch

Eine schöne Alternative habe ich hier gefunden. Ein schlauer Mensch hat den ArduinoISP Sketch so modifiziert, dass ihr keinen zusätzlichen Adapter braucht, um den seriellen Monitor zu nutzen. Sehr smart! Ich habe es ausprobiert und es funktioniert einwandfrei.

Danksagung

Das Paket ATTinyCore von Spence Konde ist einfach fantastisch!  Vielen Dank.

11 thoughts on “ATtiny mit Arduino Code programmieren

  1. Hallo Herr Ewald.
    Vielen Dank für den ATtiny Beitrag. Die ATtiny sind sind meine kleinen Favoriten, weil ATtiny +LED passt in ein Matchbox Auto, dafür ist selbst der Arduino nano zu groß. Ich habe einen ATtiny84, der mit einem RFM95 Funkmodul über SPI kommuniziert. Dazu benötige ich die RFM95.h und tiny_SPI.h Bibliothek.
    Habe ich das richtig verstanden, daß wenn ich den Boardverwalter ATTinyCore von Spence Konde verwende, daß ich auch auf die tiny_SPI.h Bibliothek verzichten kann, weil der ATtiny das von Hause aus schon versteht? Bekommt er das über „Bootloader brennen “ beigebracht?
    Danke für die vielen Erklärungen in deinen Beiträgen, das hilft, denn ich frickel öfter was zusammen, ohne zu verstehen.
    Gruß,
    UKnopf.

    1. Hallo Herr Knopf,
      Meine Formulierung im Beitrag muss ich nochmal ändern. Die ist im Moment missverständlich. SPI.h muss trotzdem eingebunden werden. Es funktioniert aber ohne dass weitere bzw. andere Bibliotheken benötigt werden.
      VG, Wolfgang Ewald

  2. Guten Abend Wolfgang,
    ich habe mich die letzten Wochen durch genau die von Dir beschriebenen Wege zu quälen versucht und bin an Option2 Optiboot leider gescheitert. Ich hatte die Hoffnung eine seriell Monitorausgabe zu bekommen, die aber am Ende nur mit software serial lief. Software serial hat unglücklicherweise die Funktion implementiert, die bei einem PCINT oder INT0 aufgerufen wird (ich weiß gerade nicht mehr welche von beiden, faktisch brauche ich sie aber beide, da INT0 im Sleep Mode sehr limitiert ist und andererseits PCINT kein Rising oder Falling unterscheiden kann)
    Jedenfalls ist Software serial nicht parallel mit interrupts nutzbar. Verstehe ich es jetzt richtig, dass AIN0 und AIN1 auch ohne software serial eine Monitorausgabe liefern?
    Lohnt es sich also zu meinem Gescheiterten Versuch zurückzukehren, statt einen ATMEL-ICE zu kaufen, den ich praktisch schon im Warenkorb hatte alsDein heutiger Beitrag erschien?

    Guter Beitrag übrigens, abermals vielen vielen Dank

    1. Hallo Leif,

      ja, das ist richtig. AIN0 und AIN1 brauchen kein SoftwareSerial, aber nur, wenn der Optiboot Bootloader zuvor gebrannt wurde. Genau so wie ich es beschrieben habe, funktioniert es. Stellt sich die Frage was bei deinen gescheiterten Versuch nicht geklappt hat. Vielleicht versuchst du nochmal meine Anleitung. Und wenn es nicht funktioniert, dann kannst du mir ja nochmal im Detail mitteilen an welcher Stelle de Dinge nicht geklappt haben, was nicht geklappt hat und ggf. welche Fehlermeldungen es gab.

      Ansonsten ist vielleicht noch die Methode ganz unten mit dem modifizierten ArduinoISP Sketch interessant.

      Viel Erfolg!

      VG, Wolfgang

      1. Also: Warum ich gescheitert bin. Weil ich zuviele unsortierte Informationen ungefiltert zu verschiedenen Möglichkeiten hatte.
        Es ist immer ungemein Hilfreich Deine Beiträge zu lesen weil Du die Informationen so strukturiert aufbereitest. Das gefällt mir unheimlich gut und ich wähle daher Deine Anleitung immer vor Gadetronix und mikrocontroller.net weil ich erst nach dem Lesen Deiner Beiträge die anderen Beiträge verstehe.
        Was ich falsch gemacht habe? Ich habe mich mit softserial auseinandergesetzt und dann gemerkt, dass es zwar funktioniert, im aktuellen Projekt aber die Bibliothek mit meinem eigenen Code collidiert, da beide auf die gleichen ISR Vektoren nutzen.
        Dann bin ich auf „TinyDebugSerial“ gestoßen – auch ohne Erfolg.

        Ich habe es heute nach deiner Anleitung versucht. Einen CO2102 drangedängelt den ich liegen hatte und: Läuft. Mir fehlte die Info, dass Optiboot mir eine Ausgabe auch ohne softserial ermöglicht.

        Ich weiß nicht wie schnell Optiboot startet, werde es daher nur beim Entwickeln, nicht aber im Endprodukt einsetzen, da ich sehr sehr schnelle Watchdog resets benötige von denen der Anwender nichts merken soll.

        Zum debuggen ist es aber genau was ich gesucht habe.

        Frage: Wenn ich statt des billigen CP2102 einen FT232RL mit DTS Anschluss kaufen würde…. Könnte der DTS Pin den Reset Taster ersetzen?

        VG und herzlichen Dank!

        1. Das mit dem DTR habe ich ausprobiert und es funktionierte nicht. Ich will aber nicht ausschließen, dass ich irgendetwas übersehen habe. Ich probiere es nochmal aus aber werde wohl erst in den nächsten Tagen dazu kommen.
          Und danke für das positive Feedback!
          VG, Wolfgang

        2. Es geht auch mit dem DTR Pin. Man muss allerdings 0.1 µF zwischen DTR und Reset setzen und einen Pull-Up Widerstand hinzufügen. Ich habe den Beitrag entsprechend erweitert. Wie ich das herausgefunden habe: Der Arduino Pro Mini hat einen DTR Pin. Da habe ich einfach mal geschaut, wie der verdrahtet ist. Gut, dass du gefragt hast!

  3. Hallo Wolfgang
    Bist du dir sicher, das der Attiny 841 auch damit programmiert werden kann? Dieser Attiny ist beim I2C Bus ganz anders zu programmieren. Da ich schon längere Zeit mit diesem arbeite, hatte ich zu Anfang grosse Probleme damit.
    achim

    1. Hallo Achim,

      generell programmieren geht auf jeden Fall. Auch I2C geht, mit gewissen Beschränkungen.

      Ein großer Vorteil an ATtinyCore ist die hervorragende Dokumentation. Für jeden ATtiny ist beschrieben, was geht und was nicht und mit welchen Einschränkungen. Hier der Link zum Abschnitt über I2C für die ATtinyX41-Reihe:

      https://github.com/SpenceKonde/ATTinyCore/blob/master/avr/extras/ATtiny_x41.md#i2c-support

      Du kannst es ja mal probieren.

      Grüße, Wolfgang

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.