Ü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
- Die ATtiny Familie – Übersicht
- Vorbereitung der Arduino IDE
- Upload von Sketchen auf den ATtiny
- Hochladen per ISP und den seriellen Monitor nutzen
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:
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“.
Nun navigiert ihr zu Werkzeuge → Board → Boardverwalter. Gebt „attiny“ als Suchbegriff ein und installiert ATTinyCore von Spence Konde.
Wenn alles geklappt hat, dann solltet ihr jetzt ATTinyCore unter den auswählbaren Boardgruppen finden:
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:
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):
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
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. In der neuen Arduino IDE (Version >= 2.0) müsst ihr dazu Strg + Shift + u drücken oder über das Menu gehen: Sketch → Mit Programmer 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
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.
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.
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
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.
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.
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:
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“):
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!
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:
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:
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.
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.
Versuche den ATtiny2313 mit USBasp über ISP mit der IDE zu programmieren. Als „Board“ wurde ATtinyCore-ATtiny2313/4313, als Programmer USBasp (ATtinyCore) „zwangsläufig“ gewählt. Es gibt keinen USBasp (einfach). Ganz einfaches Programm getestet und ok. Library in Deinem Text installiert. Beim Hochladen aber Fehlermeldung:
„avrdude: set SCK frequency to 187500 Hz
avrdude: warning: cannot set sck period. please check for usbasp firmware update.
avrdude: error: program enable: target doesn’t answer. 0
avrdude: initialization failed, rc=-1
Double check connections and try again, or use -F to override for this check“
Verbindungen sind überprüft und mit cmd: avrdude -p tiny2313 -c usbasp bekomme ich auch die Meldung, dass der ATtiny unter der korrekten Signatur erkannt wird. Hochladen auf ATmega8 (Board) mit USBasp zeigt ein anderes avrdude Ergebnis:
„avrdude: auto set sck period (because given equals null)
avrdude: AVR device initialized and ready to accept instructions
avrdude: device signature = 0x1e9307 (probably m8)“
Was mache ich falsch?
Hallo, kurze Antwort: nichts! Lange Antwort: ich habe gerade zwei USBasp Adapter ausprobiert und bekomme mit beiden dieselbe Warnung. Allerdings klappt der Upload trotzdem (zumindest bei mir). Dann habe ich nach „avrdude: warning: cannot set sck period. please check for usbasp firmware update“ gegoogelt und gesehen, dass wir wohl nicht allein sind mit dieser Meldung. Um die Meldung wegzubekommen, muss man tatsächlich die Firmware des Programmers aktualisieren. Hier habe ich eine Anleitung gefunden, die ich allerdings nicht selbst ausprobiert habe:
https://kopterforum.at/viewtopic.php?t=825
Ich werde meine Programmer so lassen, wie sie sind und die Warnung ignorieren.
VG, Wolfgang
Hallo Wolfgang, merci für die rasche Antwort. Bei mir wird beim ATtiny2313 mit ATtinyCore nichts hochgeladen. Nur der Fehler erscheint, dann Abbruch. Ich habe 2 USBasp, einen Selbstgebauten mit der neuesten Firmware 2005 und einen Gekauften V2.0, der m.E. auch eine neue FW haben sollte (gekauft 2021). Beide melden den gleichen Fehler und laden nicht hoch. Beide habe ich mit meinen Boards ATmega8, 168, 328PB ohne Probleme probiert. Auch lässt sich der Tiny2313 prroblemlos über avrdude von der CMD-line aus ansprechen, ebenso mit Studio7 über ISP programmieren. Ich schließe daraus, dass das Problem doch an ATtinyCore hängt. Man müsste halt die Befehlssequenz von avrdude in ATtinyCore kennen, dann wäre man vielleicht weiter.
Mich wundert z.B. dass „avrdude: set SCK frequency to 187500 Hz“ gesetzt wird. Diese Zeile erscheint bei der Programmierung mit Studio7 oder CMD nicht.
Falls Du noch eine Idee hast, bin ich sehr dankbar, da ich mich eigentlich mal auf eine IDE konzentrieren und nicht dauernd umlernen will.
Gruß Werner
Hallo Werner, da ich das Problem bei mir nicht reproduzieren kann, sind meine Möglichkeiten zu helfen begrenzt.
Du könntest noch probieren, den Bootloader zu brennen. Dabei wird nicht wirklich ein Bootloader gebrannt, sondern nur die geeigneten Fuses gesetzt. Vielleicht ist da irgendetwas im Argen.
Vielleicht findest du hier noch einen Hinweis:
https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/avr/extras/Ref_Programming.md
Ansonsten bleibt noch der Weg, das Problem als Issue direkt auf GitHub zu adressieren.
Und vielleicht könntest du mir noch einmal die komplette Meldung beim Hochladen zusenden (wolfgang.ewald@wolles-elektronikkiste.de). Vielleicht sehe ich ja doch noch was.
VG, Wolfgang
Hallo Wolfgang,
Danke für die Anleitung. Cool, mit wie wenig Bauteilen man diese kleinen Controller betreiben und programmieren kann. Ich habe allerdings irgendein Timing/Clock-Problem:
Ich habe folgenden Code in den ATtiny85 (ohne Bootloader) mit einem AVRisp mkII kompatiblen Gerät geflasht. Zum Glück hatte ich das Teil bereits, da ich mien Arduino Nano mit neuem Bootloader bestücken wollte.
#define OFFTIME 30
#define ONTIME 10
#define PAUSE 400
#define LED_OUT LED_BUILTIN
#define FLASH_COUNT 8
int i;
void setup() {
pinMode(LED_OUT, OUTPUT);
}
void loop() {
for (i = 0; i < FLASH_COUNT; i++) {
digitalWrite(LED_OUT, HIGH); // turn the LED on (HIGH is the voltage level)
delay(ONTIME);
digitalWrite(LED_OUT, LOW); // turn the LED off by making the voltage LOW
delay(OFFTIME);
}
delay(PAUSE);
}
Auf dem Nano blitzt die LED jeweils nur 8 mal ganz kurz auf, macht eine Pause usw. Hier mit dem ATtiny85 ist das nun deutlich langsamer. Ich würde vermuten, so locker Faktor 6-8. Ich habe keine besonderen Einstellungen vorgenommen, was CPU-Frequenz usw. anbelangt. D.h. die Eistellung ist 8MHz internal und Timer/Clock steht auf CPU-Frequenz und nicht auf 32 bzw. 64MHz. (Eigentlich müsste das dann ja noch langsamer werden, oder?)
Wo ist da mein Denkfehler?
Viele Grüße,
Thomas
Hi Thomas,
klicke mal auf Booloader brennen. Du willst zwar keinen Bootlader haben, aber wenn du die Option ohne Bootloader ausgewählt hast, dann werden in dem Fall nur die eFuses gesetzt, mit denen u.a. die Taktrate eingestellt wird. Ich vermute dein ATtiny läuft auf 1 MHz.
VG, Wolfgang
Hallo Wolfgang,
Danke für den Tipp. Ich konnte im ersten Test zwar nur den Optiboot und nicht den Micronucleus brennen, aber jetzt stimmt das Timing-Verhalten des Chips. In der Arduino-Oberfläche (ich habe mich aus Gründen noch nicht getraut, auf die 2.x zu aktualisieren) steht auch etwas davon. Wäre schön, in der Arduino-IDE ein eFuse-Tool zu haben. Vor diesen Sicherungen habe ich echt Respekt. Ich habe mir vor einigen Jahren mal einen 328P damit geziegelsteint.
Das mit dem Micronucleus Bootloader muss ich aber auch noch irgendwie hinbekommen, denn ich habe da aus der Bucht so ein paar keine Platinen für den AT85 mit microUSB-Anschluss und dem Dioden-Gedöns, so dass sich der Chip dann darüber programmieren lassen sollte. Im Moment steckt der µC auf einem Breadboard und ist mit 6 Strippen mit dem ISP verbunden. Frickelig halt…
Viele Grüße,
Thomas
Huhu, okay, der andere Bootloader für „Digispark“ ist jetzt auch mal gebrannt… Man muss extra noch einmal die Programmiert-Methode auf Fresh/ISP oder ähnlich umstellen. Dann kommt auch kein Timeout… Ich merke, steile Lernkurve…
Hallo Wolfgang,
ich habe den Sketch zum „USB zu TTL Adapter“ ausprobiert. Die LED blinkt, auch die am Adapter , der serielle Monitor zeigt aber leider nicht den Text an, sondern nur verdrehte Fragezeichen. Als Adapter habe ich einen FTDI232 angeschlossen. Das gleiche Ergebnis hatte ich auch schon vorher bei anderen Versuchen, den Attiny85 mit dem seriellen Monitor zu verbinden, unter anderem mit SoftwareSeriel.h . Zum Programmieren des Attiny verwende ich den Diamex USB-ISP Programmer. Ich bin jetzt ziehmlich ratlos, vielleicht hast du eine Idee was ich ändern sollte.
Gruß Wolfgang Keller
Hallo Wolfgang,
umgedrehte Fragezeichen treten meistens auf, wenn die Baudrate im Sketch nicht mit der Baudrate im seriellen Monitor übereinstimmt – kannst du das prüfen?
VG, Wolfgang
Hallo Wolfgang,
danke für die schnelle Reaktion. Ja, die Baudraten sind die gleichen. Zur Sicherheit habe ich das Programm mit der IDE 2.1.1 als auch mit der 1.8.16 ausgeführt, mit den gleichen Ergebnissen.
Gruß
Wolfgang
Also, du kannst den Sketch über den Adapter hochladen? D. h. du hast den Bootloader (den mit Optiboot) zunächst per ISP gebrannt und dann den Sketch über den Adapter hochgeladen (nicht per ISP) und dann funktioniert die Ausgabe nicht? Das ist recht eigenartig, denn wenn das Hochladen über den Adapter klappt, ist die serielle Verbindung ja prinzipiell in Ordnung. Das macht mich etwas ratlos. Kannst du mir nochmal sagen, welchen ATtiny du verwendest und welchen Bootloader du gewählt hast?
Ich habe den Sketch über den Diamex USB-ISP Programmer hochgeladen. Ich verwende den Attiny85. Außerdem habe ich die Bibliothek AttinyCore installiert und verwende daraus Attiny25/45/85 (ohne bootloader). Nach dem Hochladen des Sketches schließe ich den Attiny85 über den FTDI232 an einen USB-Eingang am PC an (Port 5). Dann ruf ich über die Arduino IDE den seriellen Monitor auf und erhalte das geschilderte Ergebnis.
Ach so, du nutzt den USB zu TTL Adapter nur für den seriellen Monitor. Im Moment fällt mir kein naheliegender Grund ein. Vielleicht ein Treiberproblem? Aber dann würde ich eigentlich erwarten, dass das Modul gar nicht auswählbar ist. Wie du siehst, fange ich an zu spekulieren. Vielleicht schaust du nochmal auf GitHub in der Dokumentation des Boardpaketes oder stellst dort auch nochmal deine Anfrage. Wenn mir noch etwas einfällt, melde ich mich.
Ok, danke! Ich teste auch weiter, mal mit einem neuen Attiny85. Wenn ich den Fehler finde melde ich mich auch.
Es gibt noch ein paar Einschränkungen hinsichtlich der Baudrate, aber 9600 sollte bei 8 MHz eigentlich gehen. Vielleicht schaust du nochmal hier:
https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/avr/extras/Ref_TinySoftSerial.md
Hallo Wolfgang,
ich hab den Fehler gefunden. Der Attiny85 war anscheinend auf 1 MHz eingestellt. Ich hab auf 8 MHz eingestellt und “ bootloader brennen“ ausgewählt, jetzt bekomme ich im seriellen Monitor den Text angezeigt.
Danke nochmal für deine Unterstützung.
Gruß
Wolfgang
Schön, dass du das Problem lösen konntest und danke, dass dich noch einmal gemeldet hast!
Hallo Wolfgang,
habe gerade einen neuen Rechner aufgesetzt und mußte leider feststellen das der Link
http://drazzy.com/package_drazzy.com_index.json
nicht funktioniert. (Webside nicht erreichbar. / mit anderem Programm vom Handy probiert mit dem Ergebnis „Server down for everyone“)
Hast Du eine Idee wie ich die beiden Files von Spence Konde in die Arduino IDE bekomme ???
Grüße
Frank
Hallo Frank, da scheint es ein Server Problem zu geben. Ich gehe nicht davon aus, dass das von Dauer ist. Aber ist natürlich blöd, wenn man loslegen möchte und dann werden einem Steine in den Weg gelegt. Board Packages lassen sich auch manuell installieren. Ausprobiert habe ich es selbst nicht.
Du kannst das Paket von GitHub herunterladen. Gehe zu:
https://github.com/SpenceKonde/ATTinyCore
dann auf Code, Download Zip.
Dann folge den Anweisungen „Manual Installation“, „Option 1“ hier:
https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/Installation.md
Oder du hast noch ein wenig Geduld…
Hallo Wolfgang,
danke für die schnelle Antwort. Die „Manual Installation“ funktioniert bei mir leider nur auf meinem bestehenden (alten) Rechner mit installierter älterer Version. Da wird die neue Version 2.0.0 als ATTinyCore(im Sketchbook) angezeigt und das Prüfen / Hochladen funktioniert einwandfrei.
Auf meinem neuen Rechner wird dies zwar ebenfalls angezeigt, aber wenn ich versuche einen Tiny zu programmieren gibt es jede Menge Fehlermeldungen…
Nehme an ohne bestehende Installation funktioniert das nicht…
Habe mal Spence Konde direkt angemailt, mal sehen ob ich eine Antwort bekomme 😉
Grüße Frank
Der Server ist anscheinend wieder erreichbar.
Hallo Wolfgang,
Ich habe gerade meinen Digispark Tiny 85 umgesetzt und mal die Geschwindigkeiten gemessen und war absolut erstaunt. Bisher waren die Geschwindigkeiten vom Tiny85 und vom Uno/Nano bei diesem Test in etwa gleich aber jetzt hat es mich fast umgehauen. Folgendes Testprogramm habe ich benutzt:
const uint8_t LOOP_TEST_PIN = 1;
uint8_t state = 0;
void setup(void) {
pinMode (LOOP_TEST_PIN, OUTPUT);
digitalWrite (LOOP_TEST_PIN, LOW);
}
void loop(void){
//Option 1:
state = 1 – state;
digitalWrite (LOOP_TEST_PIN, state);
//Option 2:
PORTB ^= (1<<PB1);
//Option 3:
PINB = bit(1);
}
Bitte hier nur eine Option wählen zum Nachtesten, dia anderen auskommentieren.
Ergebnis:
Option1: Uno/Nano 120 kHz, ATTinyCore 300 kHz
Option2: Uno/Nano 1,13 MHz, ATTinyCore 1,6 MHz
Option3: Uno/Nano 1,59 MHz, ATTinyCore 2,73 MHz
jeweils gemessan am Pin PB1.
Mit einem Zuwachs an Geschwindigkeit hatte ich eigentlich nicht gerechnet und vor allem nicht in dieser Höhe.
Vielen Dank für den tollen Beitrag, jetzt werde ich mal I2C testen, da hatte ich mit den bisher verfügbaren Bibliotheken keinen Erfolg.
Gruß
Günter
Hi Günter, das ist ja ein Ding! Ich hätte solche Unterschiede auch nicht erwartet. Warum das so ist – keine Ahnung, da muss ich mal nachforschen. Vielen lieben Dank! VG, Wolfgang
Hallo Wolfgang,
auf der Suche nach einer Anleitung zum Programmieren/Flashen von ATTinys über Arduino, bin ich auf deiner Seite gelandet. Es ist wirklich super erklärt und auch für einen Noob wie mich sehr verständlich. Ich habe alle Schritte befolgt, baute die „normals“ ISP Schaltung auf und konnte den Bootloader auch „brennen“, bis dahin hat alles funktioniert, nur dann beim Hochladen des Sketches kam immer der Fehler
„Zum Hochladen ist ein Programmer benötigt“
Ich bin bald verückt geworden, habe 10x alles überprüft, neu gesteckt, sämtliche Einstellungen versucht…
Immer kam der gleiche Fehler. Kurz vorm hinschmeißen und ISP Programmer kaufen habe ich mich dann an das Arduino.CC Forum gewendet. Am nächsten Tag waren dann die Fehlerqellen eingekreist und wir haben den Fehler gefunden.
Ich als Noob habe mir vor ein paar Tagen die Arduino IDE installiert, aber nicht beachtet, das es nun eine neue IDE 2.0 gibt – die gab es auch zum Zeitpunkt deines Beitrags auch noch nicht, oder? Naja, auf jeden Fall funktioniert der ATTinyCore nicht mit der IDE 2.0 oder anderst herum – das hatte icht schlichtweg nicht gewußt und beachtet (steht aber auch im der ATTinyCore Doku). IDE 1.8.19 installiert und voilà es funktioniert.
Meinst du du könntest die Info mit in deinen Beitrag nehmen, es gibt bestimmt den einen oder anderen Anfänger der das nicht beachtet und einfach die neuste IDE installiert und sich dann wundert warum das nicht funktioniert.
Viele Grüße
Dennis
Hallo Dennis,
ich habe die Programmierung gerade noch einmal ausprobiert. Einmal mit einem gekauften Programmer und einmal mit einem Arduino als ISP Programmer. Ziel war ein ATtiny85. Beides hat sowohl mit der Arduino IDE 2.0.4 wie auch mit der Version 1.8.19 funktioniert. Allerdings gibt es einen kleinen Unterschied: Mit der Arduino IDE 1.8.19 funktioniert das einfache Hochladen (Pfeilsymbol o. Strg + u), in der neueren Version 2.0.4 ist das Hochladen über das Menü (Sketch -> Hochladen per Programmer) oder über Strg + Shift + u vorzunehmen.
Danke für den Hinweis. Das werde ich ergänzen.
VG, Wolfgang
Hallo Wolfgang,
Vielen Dank für die Info, ich habe es bei mir auch noch mal mit dem Menü (Sketch -> Hochladen per Programmer) versucht und siehe da, es funktioniert. Hätte ich das nur mal gewußt bzw.versucht, dann hätte ich mir viel Zeit gespart. So lernt man halt dazu 😉
Vielen Dank und mach weiter so mit deinem Blog
Grüße
Dennis
Hallo Wolfgang,
will ATTiny88 mit Micronucleus und USB programmieren, den seriellen Monitor nutzen.
https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/avr/extras/ATtiny_x8.md
Welche PINS für D+ und D- ?
Apropos – Respekt für Deine div. Tutorials! Sparen viel Zeit bei eigener Suche.
VG Peter
Hallo Klaus,
D- = PD1 = Arduino Pin 1 = physikalischer Pin 3 (28 Pin IC) / Pin 31 (32 Pin IC)
D+ = PD2 = Arduino Pin 2 = physikalischer Pin 4 (28 Pin IC) / Pin 32 (32 Pin IC)
Die Zuordnung der D-/D+ Pins für die verschiedenen MCUs findest du hier:
https://github.com/SpenceKonde/ATTinyCore/blob/v2.0.0-devThis-is-the-head-submit-PRs-against-this/avr/extras/Ref_Micronucleus.md#configuration-summary
VG, Wolfgang
Danke Wolfgang,
für die prompte Antwort. Versuche RPI Sense HAT LEDs zu aktivieren. PD 1…2 sind leider belegt.
Hoffe das ich weiterkomme.
VG Peter
Hallo Wolfgang,
zunächst einmal herzlichen Dank für Deine Tutorials!
Aber hier gleich mal eine Frage:
Ich bin Deiner Anleitung zum Programmieren eines ATtiny85 gefolgt, Hardware wie abgebildet + 3 zusätzliche LEDs für „Heartbeat, Error und Programming“.
Nach dem Laden des ArduinoISP – Beispiels pulst die Heartbeat – LED langsam vor sich hin.
Alle Einstellungen für den ATtiny sind wie von der IDE vorgegeben.
Wenn ich den Bootloader brennen will, erscheint die Fehlermeldung:
Arduino: 1.8.19 (Windows 10), Board: „ATtiny25/45/85 (No bootloader), Enabled, CPU (CPU frequency), ATtiny85, 8 MHz (internal), EEPROM retained, B.O.D. Disabled (saves power), Enabled“
avrdude: Yikes! Invalid device signature.
Double check connections and try again, or use -F to override
this check.
Fehler beim Brennen des Bootloaders.
Ich habe sowohl die IDE 2.04 als auch die IDE 1.8.19 probiert und mit 2 ATtinys gearbeitet.
Kannst Du bitte einen Blick in Deine Kristallkugel werfen und mir einen Tip zur Lösung geben?
Gruß,
Armin
Hallo Armin, du schreibst, dass die LED nach Upload von ArduinoISP langsam für sich hinpulst. Also bekommst du Sketche auf den ATtiny85 geladen? Oder leuchten schon LEDs am ATtiny85, wenn du nur den ArduinoISP Sketch hochlädst? Aber der ATtiny85 sollte doch zu dem Zeitpunkt noch gar nicht am programmierenden Nano oder UNO hängen!? Und drei LEDs würden ja auch (zu dem Zeitpunkt gar nicht passen, da nur PB3 und PB4 frei sind. Du müsstest noch mal genauer erklären, was du wann wie verbunden hast.
So sollte die Reihenfolge sein:
1) Nur den Nano oder UNO an den Computer hängen. Nano oder UNO als Board auswählen, AVRISP_mkII als Programmer einstellen, ArduinoISP hochladen.
2) Den ATtiny85 wie oben abgebildet mit dem Nano oder UNO verbinden. Kondensator zwischen Reset und GND am Nono/UNO nicht vergessen, Polung des Kondensators beachten.
3) Den ATtiny als Board auswählen, Programmer: Arduino as ISP, Bootloader brennen.
4) Einstellungen lassen, wie sie sind und Sketche hochladen.
x-fach erfolgreich geprüft!
VG, Wolfgang
Hallo Wolfgang,
danke für die superschnelle Antwort!
Zur Erklärung meines Aufbaus:
Ich habe mir einen Programmier-Adapter gebaut, der zusätzlich zu den notwendigen Leitungen noch Status-LEDs hat:
D7: Programming
D8: Error
D9: Heartbeat
Ich bin so vorgegangen wie von Dir geschrieben und habe beim „Bootloader brennen“ die Fehlermeldung „Failed chip erase“ bekommen.
Nach weiteren Versuchen gabs die Meldung „Bootloader flashen failed: Device Signature
= 0x000000“.
Irgendwann kam dann die „Yikes!Invalid device signature!“
Ich habe dannnach weiteren Versuchen endlich die Meldung „Bootloader geflashed “
bekommen – leider ist mein UNO jetzt auch ausser Gefecht.
Ich habe bei „Instructables“ einen Vorschlag für einen „Fuse Doctor“ gefunden, um die ATtinys wiederzubeleben – mal sehen.
Wenn ich den Eintrag von Dennis früher gelesen hätte, wäre mir vielleicht viel Stirnrunzeln erspart geblieben.
VG Armin
Hallo Armin,
die Prozedur zum Brennen des Bootloaders ist bei den Arduino Versionen identisch. Ein bisschen merkwürdig, denn warum weiß die Arduino IDE beim Bootloader brennen, dass ein Programmer vorhanden ist, aber beim Programmupload nicht!? Nicht die einzige Merkwürdigkeit der neuen IDE, aber das ist ein anderes Thema.
Auch wenn ich mich wiederhole: die Prozedur funktioniert – im Prinzip! Wenn es bei dir nicht funktioniert, dann ist irgendetwas anders, was nicht notwendigerweise bedeutet, dass du irgendetwas falsch gemacht hast. Updates von IDEs (wie gerade gesehen), Bibliotheken, Änderungen in der Hardware, Wechselwirkungen mit anderen Bibliotheken und und und… manchmal ist auch nur ein Kabel kaputt. Und das herauszufinden ist die Herausforderung.
Je mehr Informationen ich habe, desto höher sind die Erfolgschancen. Falls du noch motiviert bist: Fotos vom Aufbau wären evtl. aufschlussreich (an: Wolfgang.Ewald@wolles-elektronikkiste.de). Ebenso alle Meldungen beim Kompilieren und Hochladen bzw. Brennen des Bootloaders, die die Arduino IDE ausspuckt. Dazu solltest du in den Voreinstellungen alle Kompilerwarnungen aktivieren und die Häkchen bei „Ausführliche Ausgabe während….“ setzen.
VG, Wolfgang
Hallo Wolfgang,
nochmals Dank für Deine Mühe!
ich habe für den Moment folgende Entscheidungen getroffen:
* zurück zur „alten“ IDE, mit Dark Scheme wegen der besseren Lesbarkeit
* zunächst bei der ATtiny-Brennerei pausieren und erstmal nachdenken
* „Rettung“ meiner verfuseten ATtinys mit dem hier:
https://www.instructables.com/Simple-and-cheap-Fuse-Doctor-for-Attiny
beschriebenen Tool.
Ich habe Dir die Details des Programmier-Shields per Mail zugeschickt.
VG Armin
Hallo Armin,
ich weiß nicht, ob du schon dazu gekommen bist meine e-mail anzuschauen.
Ich denke auch für die anderen Leser, die ggf. verunsichert sind, ist es wichtig zu wissen, dass hier anscheinend der von dir verwendete Programmer einen Designfehler hat (jedenfalls mein Fazit). Die zugrundeliegende Schaltung scheint richtig, aber das Platinen-Layout passt nicht zur Schaltung. Solltest du mal dort reklamieren, wo du das Layout her hast – damit kannst du vielleicht anderen viel Zeit und Ärger ersparen.
VG, Wolfgang
Hallo Wolfgang,
habe ATTiny88 mit ATMEL-ICE und Arduino IDE 2.0.2 mit Hilfe des ATTinyCore Pakets programmiert.
Beim Test funktionierte die Pin Notation im og. Blink Beispiel nicht.
// ändern von int ledPin = 4 in…
const int ledPin=PIN_PA3; // hier beispielsweise für Port A3 Pin 6
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
digitalWrite(ledPin, HIGH);
delay(500);
digitalWrite(ledPin, LOW);
delay(500);
}
jetzt blinkt es 😉
VG Peter
Guten morgen Wolfgang,
ich habe nun ein größeres Projekt laufen, bei demich doch debuggen möchte.
Ich habe mich daher für Upload mit Optiboot Bootloader enschieden. Den Bootloader habe ich gebrannt. Der Beispielsketch läuft und die serielle Ausgabe passt. Nun möchte ich den ATTiny nicht jedes mal auf den Ardunio-ISP umstecken, sonder den komfort des Upload mittels USB-zu-TTL Adapter nutzen. Also habe ich auch den Ground zu RST Taster eingefügt und es probiert. Leider scheint es ein Problem zu geben das
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x80
Ein wenig gegoogelt habe ich schon der Bootloader ist offenkundig drauf, sonst hätte ich keine serielle Ausgabe.
Ich bin etwas ratlos… notfalls müsste ich nochmal einen TTL Adapter mit DTS kaufen, oder müsste es mit dem Taster von Ground zu RST in jedem falle funktionieren?
Danke für die tolle Arbeit!
VG
Leif
Hallo Leif,
ich kann natürlich kein Garantien geben, dass das mit jedem USB-zu-TTL Adapter funktioniert, der auf dieser Welt erhältlich ist, aber es sollte gehen. Die Tatsache, dass du eine serielle Ausgabe hast, heißt nicht dass du den Bootloader drauf hast. Der Bootloader sorgt nur dafür, dass die Programme über RX/TX hochgeladen werden. Die Funktion der seriellen Schnittstelle als Ein-/Ausgabe ist auch so vorhanden. Also falls du es nicht getan hast dann brenne den Optiboot Bootloader für ATtiny 45/85. Du bekommst eine Rückmeldung ob es geklappt hat oder nicht. Kannst dich ja nochmal melden, wenn es trotzdem nicht geht.
VG, Wolfgang
Hallo „Wolle“ 🙂
Wollte Dir nur mal sagen, dass Du hier echt einen guten Job mit Deiner Seite machst ….
Lese ich immer wieder gerne und es hilft mir immer 🙂
Danke !! Mach weiter so 🙂
Herzlichen Dank!
Hallo Herr Ewald,
ich habe Variante 1, Nano zum Programmer gemacht, dann mit Attiny verbunden, Bootloader „gebrannt“ und dies alles ohne Fehlermeldung. Im letzten Schritt, Sketch Blink laden erhalte ich dann jedoch die Meldung, es ist ein Programmer notwendig. Wo liegt möglicherweise mein Fehler. Vielen Dank! Thomas
Hallo Thomas,
ich sage mal „Du“ – umgekehrt natürlich auch gerne! Immerhin, der Bootloader wird schon mal gebrannt. Das heißt an den Verbindungen kann es schon mal nicht liegen. Als Board ist „ATtiny25/45/85 (no Bootloader)“ und als Chip „ATtiny85“, richtig? Als Programmer muss „Arduino as ISP“ ausgewählt sein. Und hast du beim Hochladen „Hochladen per Programmer“ (oder Strg+Umschalt+U oder Umschalt mit Klick auf den Hochladepfeil) gewählt? Wenn es das alles nicht ist, dann gehe bitte in die Voreinstellungen und wähle Compilerwarnungen „Alle“ und sende mit mir die Meldungen zu (wolfgang.ewald@wolles-elektronikkiste.de).
VG, Wolfgang
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.
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
Das hilft mir gerade konkret weiter. Danke für diesen ausführlichen Beitrag.
Und ich danke für die Rückmeldung!
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
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
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!
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
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!
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
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