Guten Abend,
ich habe folgendes Problem:
In der Anwendung Arduino habe ich ein Programm erstellt, welches ich auf
ATTINYs flashen möchte. An sich kein Problem, aber sehr
arbeitsaufwendig, da ich 100 ATTINYs flashen möchte. Jeder ATTINY
bekommt dabei eine individuelle I2C-Adresse und ID.
Sobald die richtige Adresse bei Arduino eingestellt ist, erzeuge ich mit
Arduino eine HEX-Datei. Diese HEX-Datei öffne ich mit einem Flash-Tool,
welches die ATTINYs dann letztendlich flasht.
Dieser Prozess ist somit überhaupt nicht optimiert, was ich ändern
möchte. Den momentan benötige ich +- 1 Minute pro ATTINY, was definitiv
zu lange ist, vor allem bei 100 Stück...
Meine Frage richtet sich an dieser Stelle an die Prozessoptimierung.
Der Wunschzustand ist das öffnen einer Anwendung, die in der Anwendung
Arduino die beiden Parameter (ID, Adresse) verändern kann, dann
automatisch das HEX-File erzeugt und danach das Flashen initialisert und
durchführt, sodass ich, als Bediener, nur noch die Attinys in den Sockel
legen muss.
Mein Ansatz war eine Batch-Datei, in der ich mittels Shortcuts die
nötigen Befehle aufrufe, doch mit meinem Wissensstand kann man keine
Shortcuts mit einer Batch-Datei ausführen.
Gibt es eine andere Anwendung/Programmiersprache, mit der man auch bei
Arduino die entsprechenden Zeilen hochzählen lassen kann, bzw. mittels
Shortcuts alles steuern kann?
Falscher Ansatz.
Modifiziere direkt das .Hex File, dafür musst du dich natürlich ein
bisschen mit linker und make befassen um die adressbereiche zu
definieren und frei zu halten.
Oder du nutzt das eeprom zum speichern der Adressen, dann gibt's dafür
ein extra Hex mit wenig inhalt.
Das modifizierte Hex wird dann geflasht.
Dafür gibt's fertige Tools, Segger zb bietet das in jflash sogar ab
werk..
Nic schrieb:> 1 Minute pro ATTINY
Dann hättest du jetzt schon 40 Stück fertig. Nur keine Angst, die
fehlenden 60 schaffst du auch noch.
Es geht manchmal schneller, mit ungünstigen Werkzeugen etwas zu
erledigen, als sich erst in ein neues Werkzeug einzuarbeiten.
Ich drücke dir die Daumen.
MfG von der Spree
Frank
Bin nicht 100%ig sicher, ob ich die Problemstellung richtig verstanden
habe, daher erzähle ich evtl. gerade Unsinn. Aber eventuell wäre
folgender Ansatz möglich/sinnvoll:
- Statt der Arduino-IDE nimmst Du PlatformIO zum kompilieren und flashen
- die sich mit bei jedem Attiny verändernden Parameter I2C-Adresse und
ID übergibst Du als #define per "-D" Kommandozeilenparameter, z.B.
"-DI2C_ADDRESS=23 -DID=32"
- Das ganze packst Du in ein Shell-Script/Batch-Datei, die dann in einer
Schleife nach und nach für jeden der Attinys zuerst die passende
Firmware kompiliert und dann flasht
Gibt es dafür nicht sed? Also in die Originaldatei einen markanten
Platzhalter an die Stelle der Adresse und dann in einer Schleife den
Platzhalter gegen einen Counter ersetzen, dabei die Datei ans Ziel
schreiben (das macht der sed), dann neu compilieren und flashen. Wie
die entsprechenden Konsolenbefehle dafür aussehen, das sollte sich doch
herausfinden lassen.
ThomasW schrieb:> Gibt es dafür nicht sed?
Und 100000 andere Tools, die das Gleiche (und mehr) leisten könnten.
Das Problem ist: in alle muss man sich einarbeiten und dafür ist der TO
offensichtlich zu faul.
Er ist ja sogar schon zu faul dazu gewesen, selbst so ein Tool zu
suchen...
c-hater schrieb:> Das Problem ist: in alle muss man sich einarbeiten und dafür ist der TO> offensichtlich zu faul.
Kann man sich nicht erst dann einarbeiten, wenn man weiß worin?
c-hater schrieb:> Er ist ja sogar schon zu faul dazu gewesen, selbst so ein Tool zu> suchen...
weil er nicht genau weiß wonach er suchen soll und nun Rat von
erfahrenen Leuten sucht, da stellt er ne Frage in einem Forum. Was für
ne verrückte Welt ...
Hier geht es bereits um kleine Industriemengen.
Also könnte sich -nach dem Dauereinsatz unter Umwelteinflüssen- ja die
Frage stellen, ob ein gewisses Exemplar nach einer Zeit immernoch das
korrekte Programm in seinem FlashROM hat.
Wenn nun per "-DI2C_ADDRESS=23 -DID=32" (oder per "sed" oder per
Desktopautomation oder...) Der Flashinhalt individualisiert wird, also
jedes Exemplar andere Prüfsumme aufweist, müsste dies aufwändig
administrativ gebuchhaltet werden um nach Zeit im Zweifelsfall
vergleichen zu können.
Bitte für jede Version des Programms...
Die "Richtige Lösung[TM]" muss also darauf hinaus dass pro
Programmversion die Prüfsumme für alle Exemplare gleich ist und solche
Exemplarindividualdaten im gesonderten EEPROM-Datenbereich abgelegt ist.
Auch Ersatzduplikate anfertigen wird so machbar.
(ich weis jetzt nicht f. kleine Tinys, aber den selben Quellcode heute
und in 1 Wo/nach reboot des Entwicklungsrechners/nach Compilerupdate
ergibt durchaus unterschiedliche Prüfsummen d. Flashinhaltes)
Wenn solche Exemplarindividualdaten mehr werden als ins EEPROM passen,
muss das FlashROM partitioniert werden und die Geschichte führt durchaus
bald zu (Flash(ROM))tauglichen Dateisysteme.
Dieses Fass passt von der Größe eher nicht mehr zu ATtiny, erwähne ich
also nur so als Ausblick, für die Welt in 32bit & co...
Hallo
ThomasW da brauchst du gar nicht zu analysieren:
So ist er einfach "unser" c-hater (und so ca. 5 andere forenbekannte
"Spezialisten") - fachlich durchaus Ahnung, aber voll Vorurteile,
Vorverurteilungen und im Besitz der Absoluten Wahrheit...
c-hater schrieb:> Das Problem ist: offensichtlich zu faul.
Ich sehe das Problem eher da, dass man eine bestimmte Version bauen
will, die bereits im Source Repository so gekennzeichnet ist. Nicht erst
bauen (dabei als Seiteneffekt den Quelltext ändern) und dann die neue
Versionsnummer einchecken.
Stefanus
>Man kann Arduino Sketche ohne IDE mit einer Batch-Datei compilieren und>flashen:>https://github.com/arduino/Arduino/blob/master/build/shared/manpage.adoc
Der Link von Stefanus sollte eigentlich schon ausreichen.
Man muss nur noch herausbekommen, wie man die "-D" Optionien die man
überlicherweise beim GCC findet, in die Parameterliste mit aufnimmt.
( mit -D kann man in der Kommandozeile des GCC Definitionen anhängen,
die im Programm dann wie #defines wirken ).
Nic schrieb:> In der Anwendung Arduino habe ich ein Programm erstellt, welches ich auf> ATTINYs flashen möchte. An sich kein Problem, aber sehr> arbeitsaufwendig, da ich 100 ATTINYs flashen möchte. Jeder ATTINY> bekommt dabei eine individuelle I2C-Adresse und ID.
Im richtigen Leben definiert man sich eine struct{}, die alle
exemplarspezifischen Konstanten sowie eine Prüfsumme (wichtig!) enthält.
Dann erstellt man im Linkerskript ein eigenes Segment, in das per
#pragma oder __attribute__(section=...) nur diese struct plaziert wird.
Oder: Flash-Adresse definieren, per memcpy_P() direkt den Flash-Inhalt
in die struct im RAM laden, und los gehts. Ist vielleicht einfacher,
braucht aber extra RAM, was doof ist, wenn man nur 512 Bytes hat.
Jetzt kann man das Programm compilieren und ein Hexfile daraus machen.
Die Details dazu findest Du in der Gnu-Dokumentation.
Ich würde jetzt aus den hex mit objcopy oder hex2bin ein Binärfile
machen, weil das einfacher zu bearbeiten ist. Wo Deine
exemplarspezifischen Konstanten sind, weißt Du - das hast Du nämlich im
Linkerskript festgelegt. Also ist es auch kein Problem, die Position im
.bin zu finden, zu modifizieren und wieder ein flashbares .hex zu
erzeugen.
Ich würde eine Prüfsumme in die struct aufnehmen, damit Du feststellen
kannst, ob das geflashte Binery bereits passend konfiguriert ist.
Du könntest sogar erst das Programm und erst in einem zweiten Schritt
die exemplarspezifischen Daten flashen. Dann sollten die Defaultwerte im
Programm-Binary 0xff sein, damit Du diesen Bereich überprogrammieren
kannst.
Und: Deine struct sollte im Flash an einer Page-Grenze beginnen. Du
kannst das Flash nicht byteweise löschen und beschreiben, sondern immer
nur ganze Pages. Steht alles im Datenblatt.
fchk
Nic schrieb:> An sich kein Problem, aber sehr> arbeitsaufwendig, da ich 100 ATTINYs flashen möchte. Jeder ATTINY> bekommt dabei eine individuelle I2C-Adresse und ID.> Sobald die richtige Adresse bei Arduino eingestellt ist, erzeuge ich mit> Arduino eine HEX-Datei. Diese HEX-Datei öffne ich mit einem Flash-Tool,> welches die ATTINYs dann letztendlich flasht.
Sehr aufwändig und man mag gar nicht an das nächste Firmware-Update
denken.
Warum flasht du sie nicht alle auf eine Default-Adresse, die du irgendwo
ins EEPROM schreibst?
Dann nimmst du einen zweiten Controller, dessen einzige Aufgabe es ist,
auf dem Bus nach einem TINY mit Default-Adresse zu suchen. Sobald er
einen findet, schiebt er ihm eine I2C-Adresse und eine ID zu und der
ATTiny merkt sich beides für nächste Mal.
Die TINYs steckst du dann der Reihe nach kurz mal auf den
ID-Vergabe-Controller und schickst ihnen ihre zugeordneten persönlichen
Daten.
