mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Arduino Digispark (attiny85) Toolchain in CodeBlocks


Announcement: there is an English version of this forum on EmbDev.net. Posts you create there will be displayed on Mikrocontroller.net and EmbDev.net.
Autor: Arthur Ingo (Gast)
Datum:

Bewertung
-2 lesenswert
nicht lesenswert
Nabend allerseits,
also kurz gesagt: Ich frage mich, wie ich meinen Digispark (ein 
arduino-"atto", wenn überhaupt, mit attiny85 und speziellem 
Bootloader/Treiber) statt unter der Arduino-IDE, unter Code Blocks zum 
laufen bekomme.

Ich sitze jetzt schon den ganzen Tag daran.. Unter der Arduino-IDE 
läufts, allerdings ist die IDE ja wohl ...simpel... :) (oder überseh ich 
was entscheidendes?)

Ich habe:
- Code Blocks (tatsächlich)
- AVR-GCC (diverse Versionen)
- micronucleus(.exe)* (avrdude-Ersatz für den spez. Bootloader, wenn ich 
das richtig verstehe)
- die Arduino-Dateien* vom Digispark (arduino.h, etc.)
*aus dem Digispark Arduino-Paket

Damit müsste das doch eigentlich irgendwie gehen..

Ich hoffe, ich habe den richtigen Compiler in die IDE eingebunden. Ich 
hab hier mehrere zur Auswahl:
- den originalen aus der Arduino-1.8.5-IDE (nutze ich gerade)
- den heruntergeladene aus der Arduino-1.8.5-IDE, der zum 
Digispark-Paket gehört (ld.exe macht Probleme, kommt aber trotzdem was 
raus..)
- den aus der älteren Digispark-Arduino-IDE
- dann gibts noch WinAVR und diverse Neuauflagen (noch nicht getestet)

Code Blocks bietet sogar eine Arduino-Projekt-Vorlage an, aber ich weiß 
nicht wie aktuell und gut die für den digispark geeignet ist.  Es 
scheint sogar ein Simulator dabei zu sein - das wäre natürlich ein 
feiner Bonus, wenn ich den auch noch zum Laufen bekomme...Sei aber 
erstmal Nebensache.


Hier mal die Ausgabe vom Micronucleus:
usage: micronucleus [--help] [--run] [--dump-progress] [--fast-mode] [--type intel-hex|raw] [--timeout integer] [--erase-only] filename

  --type [intel-hex, raw]: Set upload file type to either intel hex or raw
                           bytes (intel hex is default)
          --dump-progress: Output progress data in computer-friendly form
                           for driving GUIs
             --erase-only: Erase the device without programming. Fills the
                           program memory with 0xFFFF. Any files are ignored.
              --fast-mode: Speed up the timing of micronucleus. Do not use if
                           you encounter USB errors.
                    --run: Ask bootloader to run the program when finished
                           uploading provided program
      --timeout [integer]: Timeout after waiting specified number of seconds
                 filename: Path to intel hex or raw data file to upload,
                           or "-" to read from stdin

Commandline tool version: 2.0a4
Vielleicht kann mir ja jemand sagen, wie ich den zu bedienen habe..

Micronucleus.exe will wohl mit hex-Files gefüttert werden. Aber wie 
bekomme ich die aus dem Compiler heraus? Ganz besonders die richtige?
Als Ziel hätte ich neben GUI/console-app, dll,.., eig nur "native". 
Damit habe ich mir schon eine *.sys erstellt.. War das richtig??? :/

Sieht also zumindest so aus, als hätte ich an alle nötigen Pfade zu 
Headern  gedacht.. Oder weiß wer, ob da noch was fehlt für später?


Also...
Ich frage mich, welche Compiler-Flags und Micronuleus-Fags ich brauche, 
damit das so läuft, wie in der Arduino-IDE
Ach könnt ich doch der IDE beim Arbeiten zusehen.. Geht das?? Irgendwo 
muss das doch auch stehen. Denn, wenn ich das richtig sehe, ist die IDE 
auch nur ne Zusammenstellung von Texteditor, Compiler und 'Uploader'..!?

Ist da draußen zufällig wer, der die nötige Erfahrung hat, mir weiter zu 
helfen??

Mfg
ArthurIngo

Autor: batman (Gast)
Datum:

Bewertung
2 lesenswert
nicht lesenswert
Was spricht gegen ein (Custom-) Makefile?

Autor: Arthur Ingo (Gast)
Datum:

Bewertung
-1 lesenswert
nicht lesenswert
..Erstmal verstehen, was das mit Code Blocks zutun hat (das spricht auch 
schon dagegen :))
Aber ich glaube ich hab den Ansatz inzwischen verstanden..

Ich habe bislang nur Desktop-Programme in CB kompiliert (Das hier ist 
meine erste Berührung mit µCs ..und von dem Keyboard-Sim bin ich schon 
mal echt 'geflashed';)). Also Target auswählen(GUI, Konsole, dll,..) + 
kompilieren + linken, fertig..
Makefiles hab ich höchstens mal von einer Lib kompiliert, aber noch nie 
selbst geschrieben.


Aber es gibt auch gute Nachrichten:
Ich hab die Arduino-IDE-Anleitung für den digispark, bzw avr-gcc 
gefunden.

Jetzt die schlechte:
Wenn ich das richtig sehe, geht das über das normale "Target aussuchen + 
kompilieren + linken" hinaus.
Im Netz findet man noch einfache Beispiele, wie man mit avr-objcopy.exe 
.hex-files erstellt. Ich habs aus ner .exe versucht: Die .hex ist 
'leer', sagt der Uploader.
Das Arduino-Rezept scheint auch komplexer zu sein. ..zu komplex, um das 
per Hand zu machen..
Außerdem siehts so aus, als würde da nie eine exe erstellt werden..

Jetzt frage ich mich:
1. Kann mir jemand erklären, was das Rezept genau mach? Und warum?
2. Wie automatisiere ich das Rezept in CB?

..Mir fallen da 2. Möglichkeiten ein:
Entweder ich nehme ein '(custom) Makefile'... Ich weiß aber nicht, wie 
ich das umsetze. Für jemanden, der sich mit Makefiles auskennt ist das 
sicher gar kein Problem. Kann mir da jemand evtl. helfen???
Oder ich arbeite CB-intern mit Post-Build-Steps. Aber ich glaube, das 
ist eigentlich nicht dafür gedacht. Denn z.B. weiß ich nicht, wie ich 
dann um die unnötige .exe herum komme und umständlich könnte es auch 
werden..

Aber was weiß ich.. Auch mit CB-Variablen/-Skripten hab ich noch nicht 
viel zu tun gehabt.
Hat jemand nen Rat für mich?



So, hier noch das Rezept:
# AVR compile variables
# --------------------- 

# Default "compiler.path" is correct, change only if you want to overidde the initial value
compiler.path={runtime.tools.avr-gcc.path}/bin/
compiler.c.cmd=avr-gcc
compiler.c.flags=-c -g -Os -w -ffunction-sections -fdata-sections -MMD
compiler.c.elf.flags=-Os -Wl,--gc-sections
compiler.c.elf.cmd=avr-gcc
compiler.S.flags=-c -g -x assembler-with-cpp
compiler.cpp.cmd=avr-g++
compiler.cpp.flags=-c -g -Os -w -fno-exceptions -ffunction-sections -fdata-sections -MMD
compiler.ar.cmd=avr-ar
compiler.ar.flags=rcs
compiler.objcopy.cmd=avr-objcopy
compiler.objcopy.eep.flags=-O ihex -j .eeprom --set-section-flags=.eeprom=alloc,load --no-change-warnings --change-section-lma .eeprom=0
compiler.elf2hex.flags=-O ihex -R .eeprom
compiler.elf2hex.cmd=avr-objcopy
compiler.ldflags=
compiler.size.cmd=avr-size
# this can be overriden in boards.txt
build.extra_flags=

# AVR compile patterns
# --------------------

## Compile c files
recipe.c.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.c.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {build.extra_flags} {includes} "{source_file}" -o "{object_file}"

## Compile c++ files
recipe.cpp.o.pattern="{compiler.path}{compiler.cpp.cmd}" {compiler.cpp.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {build.extra_flags} {includes} "{source_file}" -o "{object_file}"

## Compile S files
recipe.S.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.S.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {build.extra_flags} {includes} "{source_file}" -o "{object_file}"

## Create archives
recipe.ar.pattern="{compiler.path}{compiler.ar.cmd}" {compiler.ar.flags} "{archive_file_path}" "{object_file}"

## Combine gc-sections, archives, and objects
recipe.c.combine.pattern="{compiler.path}{compiler.c.elf.cmd}" {compiler.c.elf.flags} -mmcu={build.mcu} -o "{build.path}/{build.project_name}.elf" {object_files} "{archive_file_path}" "-L{build.path}" -lm

## Create eeprom
recipe.objcopy.eep.pattern="{compiler.path}{compiler.objcopy.cmd}" {compiler.objcopy.eep.flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.eep"

## Create hex
recipe.objcopy.hex.pattern="{compiler.path}{compiler.elf2hex.cmd}" {compiler.elf2hex.flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.hex"

## Compute size
recipe.size.pattern="{compiler.path}{compiler.size.cmd}" -A "{build.path}/{build.project_name}.elf"
recipe.size.regex=^(?:\.text|\.data|\.bootloader)\s+([0-9]+).*
recipe.size.regex.data=^(?:\.data|\.bss|\.noinit)\s+([0-9]+).*
recipe.size.regex.eeprom=^(?:\.eeprom)\s+([0-9]+).*


Die "patterns" werden mehr oder weniger einfach so abgearbeitet, nehm 
ich an. Es steht zwar dran, was passiert, aber kann mir jemand sagen, 
warum das so gemacht wird und nicht z.B. so, wie im Netz beschrieben 
(nur mit avr-objcopy)?

Autor: Stefanus F. (Firma: Äppel) (stefanus)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Die ersten Erfahrungen mit µC macht man am Besten ohne USB.

Dein Programmieradapter darf gerne eine USB Schnittstelle haben, aber 
das sollte es dann auch gewesen sein.

Die Sache ist nämlich die, dass USB Software sehr komplex ist. Du hast 
hier mit Software an beiden Enden des Kabels zu kämpfen. Dazu noch ein 
Mikrocontroller, der die USB Spezifikation nicht einmal richtig erfüllt.

Dieser Digispark scheint klein und niedlich, es hat aber schon mehrere 
gute Gründe, dass man Anfängern eher einen Arduino UNO vor die Nase 
setzt. Einen davon habe ich gerade genannt.

Autor: Arthur Ingo (Gast)
Datum:

Bewertung
-1 lesenswert
nicht lesenswert
Hab auch davon gelesen, dass die Digispark USB-Schnittstelle nicht so 
ganz konform ist. Wohl weil in Software realisiert.. Aber es reicht, um 
mit einem mitgelieferten Testprogramm(PC) zu kommunizieren (wie auch 
immer das genau geht und wie auch immer man so ein Programm schreibt - 
das würd ich mit Hilfe einer vernünftigen IDE evtl heraus finden 
können..).
Der Digispark funktioniert ja problemlos mit der Arduino-IDE bzw. an 
sich. Man kann sogar ne hex für nen ISP-Programmer drauf laden. Ich hab 
nur leider sonst keine µC zum programmieren.. Wenn das soweit ist, werd 
ich bestimmt eh nochmal vorbei schauen.;)
Ich wollte erstmal schauen, was es überhaupt mit dem Arduino-Kram auf 
sich hat, darum der Digispark..

Noch eine kleine Frage zum attiny85: Kann ich eigentlich gleichzeitig 
mehrere Ein-/Ausgänge analog lesen/schreiben?? Weiß nicht so genau, was 
der ADC so kann..

Autor: Martin H. (horo)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wenn Du USB über PB3 & PB4 betreibst, dann steht (eigentlich) nur noch 
ADC1 auf PB2 zur Verfügung - aber Du kannst zusätzlich ADC0 auf PB5 
(dem /Reset-Eingang) verwenden, wenn das Signal nie kleiner als Vcc/2 
wird, also Werte zwischen 2.5 und 5V. Das reicht z.B., um einen LM135 
einzulesen, wenn die Temperatur sicher > 0°C ist. Als PWM-Ausgänge sind 
PB0 und PB1 möglich.

Autor: Stefanus F. (Firma: Äppel) (stefanus)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Da der µC nur einen ADC enthält, kann er nicht mehrere analoge Eingänge 
gleichzeitig einlesen. Es geht nur einer nach dem anderen.

Da Dir die Arduino IDE nicht gefällt, möchtest du vielleicht eine andere 
IDE lediglich als besseren Texteditor verwenden aber weiterhin mit der 
Arduino IDE compilieren und hochladen. So mache ich das, um Probleme mit 
diversen Plugins zu vermeiden.

Ich habe die Vorgehensweise auf der folgenden Seite für drei IDEs 
beschrieben. Codeblocks ist allerdings nicht dabei. Schau Sie Dir 
trotzdem mal an. Die Vorgehensweise ist nämlich im Prinzip immer die 
gleiche:
http://stefanfrings.de/avr_tools/index.html

Autor: Arthur Ingo (Gast)
Datum:

Bewertung
-2 lesenswert
nicht lesenswert
Hallo,
über deine Seite bin ich nebenbei schon gestolpert. Ich habs inzwischen 
hinbekommen. ..Ist schon schlecht wenn man einfach alle Compiler-Flags 
übernimmt, und ein -w dabei ist. Dann merkt man evtl nicht, dass man 
source-files vergessen hat einzubinden..

Jetzt stelle ich mir gleich ein paar neue Frage:

Was passiert dann, wenn ich im Code direkt nacheiander ein analogRead() 
von Pin1 und Pin2 ausführe?

Eine Lösung ist wahrscheinlich eher ein workaround: Ich binde jetzt 
immer alle nötigen, und nur die, source-files von hand ein, damit die 
hex nicht größer wird als nötig. Wird mit den richtigen flags sogar 
kleiner als die der Arduino-IDE!
Wieso schmeißt der Compiler nicht alles raus, was nicht gebraucht wird? 
Bzw. kann ich ihn dazu bringen?

In dem Arduino-Rezept sieht man, dass ein archiv (lib) erstellt wird 
(enthält wohl alles, was so zu einem Projekt gehören kann). Diesen 
Schritt lasse ich aus. Weiß jemand, wozu das gut ist?
Außerdem wird eine .eep erstellt, für den eeprom. Aber wozu ist die 
allgemein gut? Und speziell, weil micronucleus nichts damit anfangen 
kann, so wie ich das sehe..?!

Beim Digispark sind Beispiele dabei, wie man ihn als "Tastatur-Player" 
(registriert sich als HID-Tastatur) nutzen kann. Oder als 
"Digiusb-Player" (keine Ahnung, was da nach welchem Standard übertragen 
wird, aber man braucht einen treiber und ein terminal-programm (kanns 
mir vielleicht wer erklären, oder mir nen Hinweis geben?)).
Jetzt frage ich mich, ob man auch eine Art Midi-Player realisieren 
kann.. Ich hab sogar schon ein wenig Ahnung vom Midi-Protokoll. Aber ich 
weiß absolut nicht, wie ich mit USB umgehe und wie ich dem OS mitteile, 
dass ich ein Midi-Gerät bin (erkennt OS ohne extra Treiber) und auch 
nicht, was ich dann mit einer OS-Antwort mache, wenns überhaupt eine 
gibt. Kann mir da jemand weiter helfen?
Kann ich evtl. von einem der Beispiele anfangen mit den Midiplayer, oder 
ist das eine ganz andere Richtung (immerhin muss der ja ebenfalls mit 
dem USB-Port des PCs sprechen, denke ich mal)?

Autor: Stefanus F. (Firma: Äppel) (stefanus)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Deine ganzen Arduino spezifischen Fragen kann ich nicht beantworten. 
Stelle diese besser im Support Forum von Arduino.

Das *.eep File enthält Daten für das EEprom. So etwas KANN man in den 
Quelltext einbetten, machen aber nur wenige Leute.

Mit einem Midi Player meinst du vermutlich ein Gerät, das Midi Daten 
empfängt und Töne erzeugt. Das kannst du mit AVR Mikrocontrollern 
vergessen. Dafür gibt es spezielle Chips zum Beispiel von Yamaha und 
Roland. Wenn Du nicht gerade vor hast, ein ernsthaftes Musikinstrument 
zu entwickeln, würde ich Dir dazu raten, fertige Geräte dieser beiden 
marken zu kaufen.

Autor: Martin H. (horo)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Arthur Ingo schrieb:
> Jetzt frage ich mich, ob man auch eine Art Midi-Player realisieren
> kann..

Kann man...
https://forums.obdev.at/viewtopic.php?f=8&t=1352&start=90#p32118

Autor: Arthur Ingo (Gast)
Datum:

Bewertung
-1 lesenswert
nicht lesenswert
Ich dachte, damit kann ich nen paar leds zum blinken bringen, ne 
Temperatur messen und nen Motor steuern und das wars.. Hätte nicht 
gedacht, dass man damit auch mit dem PC kommunizieren kann.
Das was du meinst ist vielleicht ein Midi-Synth. Davon hab ich schon ein 
Video auf YT gesehen.. Ich meine eher eine Art mp3-Player nur mit 
(USB-)Midi-Interface als Ausgang. Also Melodie auf den attiny laden, an 
den pc, der ihn als Midi-Gerät erkennt, und mit seinem lieblings 
Soft-Synth den Klängen lauschen..

V-USB, schon mal gehört. Ich kann ja froh sein, dass es libs dafür gibt, 
aber ich würde auch gern wissen, wie man sowas selbst schreibt. Meint 
ihr, das ist viel Arbeit (..so viel passt ja nicht in den Speicher...)?!
Erst copy & paste, wenn ich verstanden habe was ich da kopiere...

Danke jedenfalls.

P.S. Ich steig dann doch von Arduino auf richtiges AVR um: Ein simples 
Blinkprogramm braucht direkt 80byte und mit dem ganzen Arduino-Kram 
700byte.. Vermutlich wird da zwar schon viel vorweg geladen, aber nen 
bisschen overhead wird es bestimmt immer geben..
Da fummel ich lieber an Registern herum. Dann kann man auch solchen 
Quatsch machen, wie z.B. die LED an PB1 ganz schwach zum blinken 
bringen, indem man ihn aus Versehen nicht als Ausgang schaltet, sondern 
als Eingang und dann den Pullup-Widerstand peridoisch dazu schaltet... 
..hab mich doch erst sehr gewundert.
Was dann natürlich fehlt, sind ein paar nette Arduino-Libs..

Autor: Stefanus F. (Firma: Äppel) (stefanus)
Datum:

Bewertung
1 lesenswert
nicht lesenswert
Backe erst einmal kleine Brötchen.

USB ist ein sehr komplexer Themenbereich, der auf tausenden Seiten 
spezifiziert ist. Nur ein winziger Bruchteil der Programmierer, die USB 
nutzen, könnten die Libraries dazu selbst programmieren.

Autor: Timmo H. (masterfx)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also ich bin gerade dabei auf PlatformIO umzustellen. Damit kann man 
eigentlich alles Programmieren und das alles mit einer einheitlichen 
Entwicklungsumgebung mit allem Schnickschnack was die Arduino IDE halt 
nicht bietet. Arduino inkl. Digispark wird natürlich auch unterstützt 
und inzwischen ist eigentlich auch alles an Arduino libs mit drin. Man 
muss natürlich nicht auf ein Framework zurückgreifen wenn man nicht 
will. (das gilt natürlich auch für die Arduino IDE. Du musst nicht die 
Arduino Lib nutzen, du kannst wie du lustig bist wie gehabt in den 
Registern umfummeln). Insb. beim Digispark bist du aber an den 
Bootloader gebunden, da der Reset-Pin deaktiviert wurde um einen I/O pin 
mehr zu haben. Da wirst du den Bootloader nur mit HV Programming wieder 
los). Aber der Digispark ist schon nett. Habe mir damit einen RFID 
Reader gebaut der mich damit am PC ein- und ausloggt indem er sich als 
HID-Tastatur ausgibt)

: Bearbeitet durch User

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.