Mikrokontroller programmieren

[Chandler B. (chandler)]

Hallo, ich habe ein Problem und hoffe hier die Lösung zu finden.
Mein Problem ist, dass ich noch nicht so viel Ahnung vom Programmieren 
habe. Ich habe mir einen LED-Cube gebaut, der auch soweit funktioniert. 
Auch ein Programm habe ich mir mit AVR-Studio 4.18 geschrieben und 
konnte davon eine .hex-datei erstellt. Auch habe ich mir AVRdude 
installiert.
Jetzt verstehe ihc nicht ganz, wie ich das ganze auf den Kontroller 
(ATtiny2313) bekomme. Habe mir dazu einen usb-isp programmer 
(http://www.amazon.de/ISP-Programmer-ATMEL-STK500-ATmega-ATtiny/dp/B0068M158K/ref=sr_1_4?ie=UTF8&qid=1369476065&sr=8-4&keywords=usb+isp) 
besorgt. Ich habe dazu die Datei avr-isp.inf datei aus dem netz besorgt 
und konnte diesen auch installieren. Die Ausgänge des ISP-Steckers habe 
ich mit Steckverbindungen mit meinem Kontroller (welcher auf einem 
Steckbrett ist) verbunden. Das größte Problem ist jetzt bei den 
Einstellungen. Stecke ihc den USB im Computer, wird er im Gerätemanager 
als AVR ISP-Programmer am COM4 erkannt.
Im AVR Studio gehe ich auf Tools-Program AVR-Connect. (Im beiliegenden 
Zettel des Programmers steht, dass Stk500v2 Protokoll verwendet wird) In 
AVR STudio kann ihc allerdings nur STK500 or AVRISP auswählen (oder auch 
andere, aber dieses hört sich am nähesten an). Als Port wähle ich COM4. 
Im sich darauf öffnenden Fenster suche ich im Menü Main den Attiny2313 
und im Program bei Flash suche ich die HEX file. Nun klicke ich auf 
Program und ich bekomme eine Fehlermeldung

ISP Mode Error
A problem occurred when executing the command. Make sure that you are 
using the correct programming method. Current mode is ISP. See the 
command output for more info.
The troubleshooting section in the help nsystem contains more 
information on what way have caused the problems. To open the help 
system, click the Help button below.
Quick Tips: Verify that the device is placed in the correct socket and 
that the ISP cable is properly connected. Check that the ISP programming 
frequency specified on the 'Main' page is well below 1/4 of the clock 
frequency of the device. Extra precaution should be made when using the 
CKDIV fuse and/or CLock Prescaler Register (CLKPR) on parts supporting 
this.

Habe auch zunächst auf dieser Seite (und bei Google) nach Lösungen 
gesucht (daraufhin habe ich mir ja zunächst AVRdude besorgt) aber nichts 
wirklich in dieser Richtung gefunden. Hoffe, dass irgendjemand eine 
Lösung für dieses Problem weis oder ein Tutorial für dummies hat.

gruß
Chandler

[Wusel D. (stefanfrings_de)]

Ich würde erstmal das Service Pack 3 (oder AVR 4.19) installieren und 
dann sehen, ob der Programmer da mit drin ist. Ich meine, er ist dabei. 
Kann gerade nicht nachsehen.

Alternativ kannst Du avrdude verwenden:

avrdude -p t2313 -c stk500v2 -P COM4 -U flash:w:meinesoftware.hex:i

http://www.ladyada.net/learn/avr/avrdude.html

[Hubert G. (hubertg)]

Und auch die Programmierfrequenz beachten. Bei einem neuen Kontroller 
muss diese <250kHz sein. Auf der Seite einzustellen auf der du den 
Kontroller ausgewählt hast.

[Wolfgang (Gast)]

Chandler Bing schrieb:
> Ich habe dazu die Datei avr-isp.inf datei aus dem netz besorgt
> und konnte diesen auch installieren.

Hast du dazu Datei oder einen Link? So läßt sich das schlecht 
nachvollziehen.
Da beim Produkt angegeben ist: "Softwareunterstützung: AVR Studio 
(COM1..COM9)" sollte sich der Programmierer schon direkt in die AVR 
Studio IDE integrieren lassen.

[Chandler B. (chandler)]

So, habe mir AVR Studio 4.19 besorgt. Da ich dachte, dass es genau so 
funktioniert, habe ihc die alten datein alle gelöscht. Wenn ich aber 
jetzt Build (F7) machen möchte, bekomme ich nur Fehler

Build
Build started 25.5.2013 at 17:32:30
mmcu=atmega128 -Wall -gdwarf-2 -Os -std=gnu99 -funsigned-char 
-funsigned-bitfields -fpack-struct -fshort-enums -MD -MP -MT Cube_1.o 
-MF dep/Cube_1.o.d  -c  ../Cube_1.c
/usr/bin/sh: -Wall: command not found
make: [Cube_1.o] Error 127 (ignored)
mmcu=atmega128 -Wl,-Map=Cube_1.map Cube_1.o     -o Cube_1.elf
/usr/bin/sh: -Wl,-Map=Cube_1.map: command not found
make: [Cube_1.elf] Error 127 (ignored)
avr-objcopy -O ihex -R .eeprom -R .fuse -R .lock -R .signature 
Cube_1.elf Cube_1.hex
avr-objcopy: 'Cube_1.elf': No such file
make: *** [Cube_1.hex] Error 1
Build failed with 1 errors and 0 warnings...

Message
Error creating plugin : AvrLcdPlugin
Loaded plugin STK500
gcc plug-in: No AVR Toolchain installation found. The AVR GCC plug-in 
can still be used if you set up your own build tools.
Loaded plugin AVR GCC
gcc plug-in: No AVR Toolchain installation found. The AVR GCC plug-in 
can still be used if you set up your own build tools.
gcc plug-in: Output directory C:\Users\Johannes\Documents\AVR 
Studio\3x3x3 LED_CUBE\default\ does not exist
gcc plug-in: Created directory C:\Users\Johannes\Documents\AVR 
Studio\3x3x3 LED_CUBE\default\
gcc plug-in: No AVR Toolchain installation found. The AVR GCC plug-in 
can still be used if you set up your own build tools.
gcc plug-in: No AVR Toolchain installation found. The AVR GCC plug-in 
can still be used if you set up your own build tools.
gcc plug-in: No AVR Toolchain installation found. The AVR GCC plug-in 
can still be used if you set up your own build tools.
gcc plug-in: No AVR Toolchain installation found. The AVR GCC plug-in 
can still be used if you set up your own build tools.


Da bin ich noch am suchen, woran es liegen kann.
Die Frequenz war mit 57,60kHz schon vorgegeben. (also <250kHz)

Die Datei avr-isp.inf habe ich von 
http://forum.diamex.de/content.php?26-programmierger%E4te

Aber auch bei dieser Version, kann ich nicht STK500v2 auswählen (sondern 
nur STK500)

[Chandler B. (chandler)]

Bekomme es irgendwie nicht mehr hin, AVR Studio zum laufen zu bekommen. 
EIn bekannter hat mir dann .hex-file erstellt und zugeschickt.
Jetzt habe ich diese auf dem Desktop liegen und wollte es über avrdude 
machen. Dazu habe ich start- und dann cmd eingegeben. In diesem Fenster 
bin ihc zum Desktoppfad gegangen, da dort die datei liegt. dann habe ich 
folgendes eingegeben:
avrdude -c STK500v2 -p attiny2313 -P COM4 -U flash:w:Cube_1.hex

dann gibt er mir folgendes aus:
avrdude: stk500v2_command<>: command failed
avrdude: stk500v2_command<>: unknown status 0xc9
avrdude: stk500v2_program_enable<>: cannot get connection status
avrdude: initialization failed, rc=-1
         Double check connections and try again,or use -F to override
         this check.

avrdude done. Tank you.


Habe aber alles noch mehrere male kontrolliert und scheint mir richtig 
zu sein.

Jemand einen Hinweis?
bin solangsam echt am verzweifeln.

[Axel D. (axel_jeromin)]

Als mit dem Diamex Programmer hatte ich auch so meine 
Startschwierigkeiten:
aber Dein Fehler mit dem Build hat nicht mit dem Programmer zu tun. Da 
ist noch ein Fehler beim Kompilieren vorhanden.

Wenn der Fehler weg ist:

In der HArdwarekonfig von Windows suchen auf welchen Port der Programmer 
angeschlossen ist.

AVR Studio 5 Installieren (oder 4.19) Steht in der Beschreibung!

Programmierfrequenz mal auf den langsamsten Wert runterstellen.

Softwareupdate beim Programmer machen. Dazu hier im Forum nach Diamex 
suchen, da steht irgendwo ein Hinweis von mir drinn. Im Diamex Forum 
habe ich sofort Hilfe vom Entwickler dazu bekommen.

siehe auch hier: Beitrag "Re: Diamex USB ISP Programmer installieren funktioniert nicht"


Grüße
Axel

[danke (Gast)]

Servus,

ich habe hier auch noch so ein Teil rumliegen. Von einem Freund. Der hat 
mich auch viel Zeit gekostet. Sieht von Gehäuse her genau so aus 
allerdings kann ich über die Herkunft nichts sagen.

Bei mir läuft er unter Linux und Win7 als avrispmkII mit avrdude. 
Allerdings braucht er die Option -B anfangs mit den Wert 196 inzwischen 
läuft er auch mit 2 also -B 196 & -B 2. Was das ding für eine macke hat 
weis ich nicht aber ich würde auf jeden fall dazu raten lieber ein paar 
euro mehr auszugeben und genau zu wissen wie ich das Gerät zu benutzen 
habe.

Versuche es doch zum testen einfach mal einem read auf die fuse bits. Da 
kannst du erstmal nix kaput machen. Dann kannst du alle möglichen 
Treiber und Programmer kombinationen mit avrdude testen. Wenn es 
mehrmals hintereinander funktioniert kannst du ihn Programmieren.

PS: Auch entgegen der rezension bei Amazon läuft der Programmer mit dem 
AVR-Studio 5 bei mir parallel zum jtag adapter.

[isnah (Gast)]

Im Zusammengang mit avrdude weiss ich im Moment nicht ob die Befehle 
"upper lower case sensitive" sind. Aber probiere doch mal mit "-c 
stk500v2.

[Ralph S. (jjflash)]

... AVRdude ist definitiv "case sensitiv" ...

Die Befehlszeile die du eingegeben liest sich schon (fast) richtig (kann 
ich im Moment nicht kontrollieren, weil ich mein "Equipment" nicht zur 
Hand habe).

Ich denke (1000% sicher bin ich mir nicht) der Partdevicename eines 
ATtiny2313 lautet bei AVRDude "t2313" ...

Das Atmel Studio verweigert mit manchen Programmern schon die 
Zusammenarbeit (was der Grund ist, weshalb ich nur noch über AVRDude ... 
welches von selbstgeschriebenen Programmen aufgerufen wird ... die 
Controller flashe).

In deinem Fall kann es auch sein, dass die Default-Baudrate für das 
STK500 Protokoll falsch ist...

versuch es vielleicht mal mit:

avrdude -c STK500v2 -p t2313 -P COM4 -b 115200 -U flash:w:Cube_1.hex

oder, wenn der ISP-Programmer langsamer läuft mit:

avrdude -c STK500v2 -p t2313 -P COM4 -b 19200 -U flash:w:Cube_1.hex

Prinzipiell kannst du auch testen, ob Dein Programmer deinen Controller 
grundsätzlich "kennt":

avrdude -c STK500v2 -p t2313 -P COM4 -b 19200

Hier müßte ein Controllerstatus zurück geliefert werden ...

[Chandler B. (chandler)]

Irgendwas ist komisch. wenn ich eingebe
avrdude -c STK500v2 -p t2313 -P COM4 -b 19200
kommt die Meldung:
avrdude: stk500v2_command<>: command failed
avrdude: initialization failed, rc=-1
         Double check connections and try again, or use -F to override
         this check.
avrdude done. Thank you.

Das hätte ich ja nie gedacht, dass das schwieriegsta am Programmieren 
das Übertragen des Codes auf den Kontroller ist. Würde es aber sehr 
ungerne aufgeben.

[Wusel D. (stefanfrings_de)]

Du hast AVR Stduio 4.19 installiert und offensichtlich vergessen, den 
Pfad zur AVR Toolchain im Projekt zu konfigurieren. Alternativ zur AVR 
Toolchain kannst Du auch den Compiler von WinAVR verwenden. Aber auch 
das musst Du in den Projekt-Optionen einstellen.

> Das hätte ich ja nie gedacht, dass das schwieriegsta am
> Programmieren das Übertragen des Codes auf den Kontroller ist

Meinen ersten ISP Programmer hatte ich zurück geschickt, weil er 
versagte, sobald man den AVR mit weniger als 1Mhz getaktet hatte. Die 
Fähigkeit, die Firmware upzugraden hatte auch nicht funktioniert. Ich 
bekam allerdings anstandslos und zügig einen funktionierenden Ersatz.

Also ja: diese ISP Programmer sind leider nicht so unproblematisch, wie 
man das gerne hätte. Mit dem "Original" AVR ISP MK-II hatte ich 
allerdings noch nie Probleme. Deswegen gebe ich den auch nicht aus der 
Hand.

Die Hersteller der Programmer machen es sich aber auch sehr einfach. 
Einerseits preisen SIe diverse Zusatzfunktionen an, die das Produkt 
besonders attraktiv machen sollen. Andererseits liefern sie es meist 
ohne Software aus. Wenn irgendein programm nicht damit zusammen 
arbeitet, heisst es lapidar "Dann ist dein programm fehlerhaft". Besser 
ist die Situation bei Atmel, denn wenn deren AVR Studio mit mit den 
darin gelisteten originalen Programmern zusammen arbeitet, dann darf man 
(hoffentlich) Hilfe von Atmel erwarten.

[Chandler B. (chandler)]

Ich habe das Problem gelöst.
und zwar musste ich noch den Parameter '-B x ' schreiben. Warum weiss 
ich nciht genau, aber ich habe diesen Hinweis auf dem Forum von Diamex 
bekommen.
Trotzdem danke an alle für die Tips.

[Chandler B. (chandler)]

Ich habe da noch einmal eine rückfrage. Das Übertragen der Programme 
bekome ich jetzt gut (meiner meinung nach) hin. Allerdings gibt es da 
noch andere komische auffälligkeiten.
Ich habe das PRogramm in C

#define F_CPU 1000000UL

#include <avr/io.h>
#include <util/delay.h>

// ******************************************
// Hauptprogramm
// ******************************************
int main (void) {


  //********************************************
  // Initialisierung von Variablen und Ausgängen
  //********************************************

  DDRA = 0xff; // PortA als Ausgang deklarieren
  PORTA = 0xff; // Ports auf LOW schalten

  DDRB = 0xff; // PortB als Ausgang deklarieren
  PORTB = 0xff; // Ports auf LOW schalten

  DDRD = 0xff; // PortD als Ausgang deklarieren
  PORTD = 0xff; // Ports auf LOW schalten


  // Variablen deklarieren

  unsigned int Bild = 0x00; // Aktuelle Bildnummer
  unsigned int MaxBild = 5; // Zahl der Bilder in der Animation
  unsigned char Ebene = 0x00; // Ebenen-Zaehler
  unsigned char Dauer = 0x00; // Anzeigedauer des Bildes
  unsigned int Temp = 0x00; // für Berechnungen
  unsigned long Offset = 0x00; // Position der zu holenden Daten

  char Muster[36] = {
0b01000001, 0b00010001, 0b00100000, 0b00000000, 0b00010000, 0b00000000,
 0b01000001, 0b00010001, 0b00100001, 0b00010001, 0b00010000, 0b00000000,
 0b01000001, 0b00010001, 0b00100001, 0b00010001, 0b00010001, 0b00010001,
 0b01000000, 0b10010010, 0b00100000, 0b10010010, 0b00010000, 0b10010010,
 0b01000000, 0b01010100, 0b00100000, 0b01010100, 0b00010000, 0b01010100,
 0b01000000, 0b00111000, 0b00100000, 0b00111000, 0b00010000, 0b00111000

   };

  // *********************
  // Endlosschlaufe
  // *********************

  while(1){
    for (Bild=0x00;Bild<MaxBild;Bild++) {
      for (Dauer=0x00;Dauer<=27;Dauer++) {
        for (Ebene=0x00;Ebene<3;Ebene++) {
          Offset = Bild * 6; // Offset berechnen, 6 Byte pro Bild
          Temp = Ebene * 2; // 2 Byte pro Ebene
          Offset = Offset + Temp;
          PORTD = Muster[Offset]; // 1. Byte-Muster ausgeben
          Offset = Offset + 1;
          PORTB = Muster[Offset]; // 2. Byte-Muster ausgeben
          _delay_ms(5); // Diese Ebene für 5 ms anzeigen   
        } // Ende Ebenen-Schleife
      } // Ende Dauer-Schleife
    } // Ende der Bild-Schleife
  } // Ende Endlosschleife
  return 0;
} // Ende Hauptprogramm (Main)

Wenn ich nur wenige Bilder habe,funktioniert es auch so wie es soll. 
Wenn ihc aber mehrere Bilder habe, dann macht der kontroller die ersten 
Bilder noch richtig und irgendwann falsch (lässt falsche LED's 
leuchten). bei ganz vielen BIlder (170) flackert einfach nur alles.

Aber das Programm ist kleiner als 2kB, von daher habe ich gedacht, dass 
es keine probleme geben könnte.

[Karl H. (kbuchegg)]

Chandler Bing schrieb:

> Aber das Programm ist kleiner als 2kB, von daher habe ich gedacht, dass
> es keine probleme geben könnte.

Die Größe des Programms ist nicht die einzige Beschränkung. Dein µC 
verfügt nur über eine begrenzte Menge an SRAM. Und die wird dir hier zum 
Verhängnis.

Das eigentliche Problem ist aber ein anderes. Das eigentliche Problem 
ist, dass du den 15.ten SChritt vor dem ersten machen willst ohne die 
vorhergehenden Schritte zu lernen.

AVR-GCC-Tutorial

[Lukas T. (tapy)]

Auf jeden Fall mal den Port über den Gerätemanager auf COM2 legen. Das 
ist ein Problem dieser Kombi, es geht mit COM1 und COM2 immer, sonst 
nicht unbedingt.

[Chandler B. (chandler)]

auch mit COM1 oder COM2 kann ich nur 9 Bilder abspielen lassen.
Jetzt gucke ich mir erst mal das Tutorial an.

[Ralph S. (jjflash)]

... das hat mit der Schnittstelle COM1 oder COM2 überhaupt gar nix zu 
tun. Er kann ja mittlerweile mit dem Diamex Dateien übertragen.

Ob er das nun aus AVR-GCC oder mit dem Studio tut ist wurst (auch das 
Atmel Studio verwendet den AVR-GCC) und die Pfade sind auch korrekt 
gesetzt (sonst würde die Quelle nicht kompiliert werden).

Uploads in den Controller klappen ja ... und in seinem Programm 
verwendet er keinerlei USART.

Karl Heinz hat da schon vollkommen Recht.

Er verwendet einen ATtiny2313 ... und der hat (meines Wissens) nur 128 
Byte SRAM...

... und dafür verwendet er schon im obigen Programm 48 Bytes...

Du solltest deine Bitmuster nicht ins RAM kopieren lassen sondern den 
Compiler explizit anweisen, die Muster ins Flashrom zu legen:

So im Stile:

static const variablename[anzahl] PROGMEM = { 1,2,3,4,5,6 };

oder so ähnlich ...

... und dann mal in einem Tutorial nachlesen, für was

PGM_BYTE_READ

da ist !

Da lernt man dann auch gleich mit Zeiger umzugehen !

Gruß,
R. Seelig

PS: gutes gelingen !

[Ralph S. (jjflash)]

... sorry, muß natürlich PGM_READ_BYTE heißen !

[Chandler B. (chandler)]

Hallo,
ich habe noch zwei letzte Fragen. Zuerst aber noch einmal ein riesiges 
Dankeschön an Karl Heinz (für die Tutorial Seite) und an Ralph (für den 
Hinweis mit PGM_READ_BYTE).

1. Frage: Ich habe jetzt folgendes geschrieben:

#define F_CPU 1000000UL

#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <inttypes.h>

// ******************************************
// Hauptprogramm
// ******************************************
int main (void) {


  //********************************************
  // Initialisierung von Variablen und Ausgängen
  //********************************************

  DDRA = 0xff; // PortA als Ausgang deklarieren
  PORTA = 0xff; // Ports auf LOW schalten

  DDRB = 0xff; // PortB als Ausgang deklarieren
  PORTB = 0xff; // Ports auf LOW schalten

  DDRD = 0xff; // PortD als Ausgang deklarieren
  PORTD = 0xff; // Ports auf LOW schalten


  // Variablen deklarieren

  unsigned int Bild = 0x00; // Aktuelle Bildnummer
  unsigned int MaxBild = 170; // Zahl der Bilder in der Animation
  unsigned char Ebene = 0x00; // Ebenen-Zaehler
  unsigned char Dauer = 0x00; // Anzeigedauer des Bildes
  unsigned int Temp = 0x00; // für Berechnungen
  unsigned long Offset = 0x00; // Position der zu holenden Daten

 static const char pgmMuster [] PROGMEM = {
 0b01000001, 0b11111111, 0b00100001, 0b11111111, 0b00010001, 0b11111111,
 0b01000000, 0b00000000, 0b00100000, 0b00000000, 0b00010000, 0b00000000,
 0b01000001, 0b11111111, 0b00100001, 0b11111111, 0b00010001, 0b11111111,
 0b01000000, 0b00000000, 0b00100000, 0b00000000, 0b00010000, 0b00000000,
 0b01000001, 0b00010001, 0b00100000, 0b00000000, 0b00010000, 0b00000000,
 0b01000001, 0b00010001, 0b00100001, 0b00010001, 0b00010000, 0b00000000,
...
  };

  // *********************
  // Endlosschlaufe
  // *********************

  while(1){
    for (Bild=0x00;Bild<MaxBild;Bild++) {
      for (Dauer=0x00;Dauer<=27;Dauer++) {
        for (Ebene=0x00;Ebene<3;Ebene++) {
          Offset = Bild * 6; // Offset berechnen, 6 Byte pro Bild
          Temp = Ebene * 2; // 2 Byte pro Ebene
          Offset = Offset + Temp;
          PORTD = pgm_read_byte(&pgmMuster[Offset]); // 1. Byte-Muster ausgeben
          Offset = Offset + 1;
          PORTB = pgm_read_byte(&pgmMuster[Offset]); // 2. Byte-Muster ausgeben
          _delay_ms(5); // Diese Ebene für 5 ms anzeigen   
        } // Ende Ebenen-Schleife
      } // Ende Dauer-Schleife
    } // Ende der Bild-Schleife
  } // Ende Endlosschleife
  return 0;
} // Ende Hauptprogramm (Main)

So hat es funktioniert. Meine Frage wäre, ob dies auch so richtig ist 
oder ob es nur zufällig funktioniert hat.

Meine zweite Frage wäre über das AVR STudio.
Wenn ihc den Code geschrieben habe und dann F7 drücke bekomme ich unten 
im Build-Fenster zwei Werte

Program:    1232 bytes (60.2% Full)
(.text + .data + .bootloader)

Data:          0 bytes (0.0% Full)
(.data + .bss + .noinit)


Ist Programm, die größe des Programms, welches im Flash-Speicher geladen 
wird und Data die größe, die im SRAM gespeichert wird? weil beim zweiten 
Wert hatte ich vorher irgendetwas mit 780% oder so und jetzt 0%.

Noch einmal ein riesiges Dankeschön an alle, die mir geholfen haben, den 
code auf den kontroller zu bringen.

Chandler

[Wusel D. (stefanfrings_de)]

So ist es richtig.

Da Dein Programm keine statischen Variablen (außerhalb aller 
Funktionen/Prozeduren) hat, zeigt der Compiler 0.0% an. Dein Programm 
verwendet nur dynamische Variablen, die nur zur Laufzeit der main() 
Funktion Platz auf dem Stack (=RAM) belegen.

Der Compiler zählt nur den Speicherbedarf, der permanent belegt ist, 
also schon VOR dem Aufruf der main() Funktion.

Wenn Du z.B. irgendwo außerhalb aller Funktionen "int a=2" schreibst, 
dann belegst Du 2 Bytes im Data Segement (=Flash) UND 2 Bytes im RAM.

Schreibst Du hingegen "int a", dann belegst Du nur RAM.

Dein pgmMuster belegt nach der Änderung nur noch Speicher im Data 
Segment aber kein RAM. Dafür sind die Daten aber auch nicht mehr 
"normal" adressierbar, wie man es mit gewöhnlichen Variablen machen 
würde.