AVR/Arduino Eigenbau nimmt keine Programme mehr an (ATmega168)

[Stormxy (Gast)]

Hallo (hoffentlich) liebe Leute,
ich wende mich mal an euch, da ich mit meinem (zugegebener Maßen stark 
beschränktem) Latein am Ende bin :/

Folgendes:
Ich habe von einem Schülerwettbewerb hier noch ein Arduino kompatiblen 
Bausatz mit vier Stellen 7 Segment LED Display rumliegen gehabt und 
dachte mir die Tage der ließe sich doch als Digitaluhr verwenden.

Habe mir dafür die Timerinterrupts etwas näher angesehen und es dabei 
irgendwie geschafft durch ein Programmupload den Mikrocontroller 
unprogrammierbar zu machen. Er startet wohl noch (es blinken zufällige 
LED Segmente auf der Anzeige auf) und ist auch resetbar, aber nimmt 
keine Programme mehr über den Arduino Upload entgegen. Auf den seriellen 
Leitungen sind zwei LEDs verlötet die die Aktivität anzeigen, während 
des Uploads blinken diese normalerweise erst kurz und leuchten dann fast 
dauerhaft bis der Mikrocontroller wieder mit dem neuen Programm startet, 
nun jedoch blinken sie kurz, leuchten dann viel zu kurz dauerhaft und 
der Mikrocontroller zeigt wieder Unsinn auf der Anzeige an. Arduino gibt 
nach etwas Wartezeit dann auch eine entsprechende Fehlermeldung aus:

avrdude: stk500_paged_write(): (a) protocol error, expect=0x14, resp=0x64
avrdude: stk500_cmd(): programmer is out of sync

Das alles wäre sicherlich kein Problem, wenn ich über entsprechende 
Hardware und das zugehörige Wissen verfügen würde, aber naja…

Der „Mikrocontroller“ (also die Schaltung) ist ein Bausatz von der Intel 
Leibniz Challenge 2012 (mittlerweile leider eingestellter 
Schülerwettbewerb), die Einzelteile bekam man zugeschickt und wurden auf 
einem Steckbrett selbst (nach Anleitung) zusammengebaut. Im Kern werkelt 
ein ATmega168-20PU, der von einem externen 16MHz Quarz versorgt wird, 
Strom gibt’s von einem USB-TTL-Konverter, der wohl extra für den 
Wettbewerb hergestellt wurde, dementsprechend habe ich keine Ahnung, was 
der vielleicht noch alles beim Programmieren macht. Ein ähnliches 
Problem ergibt sich beim Mikrocontroller, wie ich mir mittlerweile 
denken kann, musste der ja mit einem Bootloader vorprogrammiert worden 
sein, ob überhaupt und wenn ja mit welchem weiß ich aber leider nicht. 
Jedenfalls ist die ganze Sache kompatibel mit dem Arduino Nano mit 
Atmega168. Ich häng mal das Schaltbild an.

Kommen wir also zur Software, programmiert habe ich das Teil mit 
Arduino. Ich bin mir ziemlich sicher, dass es irgendwie mit dem letzten 
Programmupload zusammenhing, den das Programm machte nicht was es soll, 
und sofort danach ging nichts mehr, an der Hardware hatte ich zudem 
nichts verändert. Das Programm war mehr oder weniger ein Testprogramm um 
ein wenig mit dem Timerinterrupt rumzuspielen. Es soll abwechselnd zwei 
unterschiedliche lange Zeiten bis zum nächsten Interrupt einstellen, 
damit ich dadurch später durch „Leerzyklen“ beim Multiplexen der Anzeige 
(also zwischenzeitlich immer alle Stellen ausschalten) die Helligkeit 
der Anzeige verringern kann.

Wie gesagt über großartige Hardware verfüge ich nicht (insbesondere 
nicht über einen separaten Programmer), vielleicht ließe sich höchstens 
noch was basteln (z.B. http://arduino.cc/en/Hacking/ParallelProgrammer 
wofür mir jedoch noch ein Parallelkabel fehlt).
Ursprünglich dachte ich ja wirklich das Programm sei Schuld, aber 
eigentlich sollte der Bootloader ja unabhängig vom Programm sein (und 
Arduino Idiotensicher), also muss ich es ja irgendwie geschafft haben 
den Bootloader zu beschädigen? Ich bin echt verwirrt :S
Also wenn ich das Teil wieder zum laufen bekommen könnte, wäre das echt 
super! Ich finde die Mikrocontroller Programmierung nämlich eigentlich 
ganz interessant, aber habe jetzt auch keine großen Projekte vor, dass 
es sich lohnt extra Hardware anzuschaffen.  Super wär‘s auch wenn ihr 
mir vielleicht auch helfen könntet zu verstehen, was wohl beim 
Programmieren auf dem Board passiert (früher dachte ich immer der 
USB-TTL-Konverter würde die Arbeit erledigen, aber das macht ja wohl 
doch der Bootloader des uC selbst oder doch nicht?).

Vielen Dank im Voraus und sorry für den Roman
Stormxy




PS: Hier mal mein letzte Code, der den uC abgeschossen hat:

//Die ordnet nur den IOxx den entsprechenden richtigen Pin zu
#include <IOpins.h>

#include <avr/io.h>
#include <avr/interrupt.h>


// 8 Segmente der Siebensegmentanzeige
//     ___        A: oben
//    | A |       F: oben links
//  F |___| B     B: oben rechts
//    | G |       G: mitte
//  E |___| C     E: unten links
//      D   . DP  C: unten rechts
//                D: unten
//                DP: Dezimalpunkt
byte IOSegmente [8] = {
IO23,  //   A: oben
IO24,  //   B: oben rechts
IO25,  //   C: unten rechts
IO26,  //   D: unten
IO6 ,  //   E: unten links
IO11,  //   F: oben links
IO12,  //   G: mitte
IO13,  //  DP: Dezimalpunkt
};

// Position der 4 Siebensegmentanzeigen
//     ___    ___    ___    ___
//    |   |  |   |  |   |  |   |
//    |___|  |___|  |___|  |___|
//    |   |  |   |  |   |  |   |
//    |___|. |___|. |___|. |___|.
//      1      2      3      4
byte IOAnzeigen [4] = {
IO19,  // Anzeige 1
IO18,  // Anzeige 2
IO17,  // Anzeige 3
IO14,  // Anzeige 4
};

PROGMEM prog_uchar disChars[64] = {//Hab ich zum Posten bischen gekürzt (...)
//ABCDEFGDP      0=AN 1=AUS
 B00000011, // 0
 B10011111, // 1
 B00100101, // 2
 B00001101, // 3
 B10011001, // 4
 B01001001, // 5
 B01000001, // 6
 B00011111, // 7
 B00000001, // 8
 B00001001, // 9
 
//...
 
 B11111111, //  keine Anzeige / Leerzeichen
};

byte disaktiveDisplay = 0;
byte cou=0;
int cou2=0;
boolean protectISR=true;
boolean state=true;
double onPercent=1;

ISR(TIMER1_COMPA_vect) {
  if (!protectISR) 
  sei();
  if (state) {
  cou2++;
  if (cou2==1000) {
    cou2=0;
    cou=(cou+1)%7;
  }

  //---Anzeigen
  for(byte i=0; i<4;i++) { // Deaktiviere alle nicht benoetigten Anzeigen
    digitalWrite(IOAnzeigen[i],HIGH);
  }

  for(byte i=0; i<7;i++) {   // Aktiviere Segmente
    digitalWrite(IOSegmente[i], pgm_read_byte_near(disChars+disaktiveDisplay+cou) & (128 >> i));
  }

  digitalWrite(IOAnzeigen[disaktiveDisplay],LOW); // Aktiviere eine Anzeige

  disaktiveDisplay=(disaktiveDisplay + 1) % 4;
  
  setInteruptTime(0.004*onPercent  ,!protectISR);
  } else {
    for(byte i=0; i<4;i++) { // Deaktiviere alle nicht benoetigten Anzeigen
      digitalWrite(IOAnzeigen[i],HIGH);
    }
    setInteruptTime(0.004*(1-onPercent)  ,!protectISR);
  }
  state=!state;
  if (protectISR)
  sei();
  //Serial.println(TCNT1)
}


void disSetup() {  
    cli();
      // initialize Timer1
    TCCR1A = 0;     // set entire TCCR1A register to 0
    TCCR1B = 0;     // same for TCCR1B
 
    // set compare match register to desired timer count:
    //16Mhz Clock
    double time=4; //4,194304 max!
    //OCR1A =int(time*16*1000/1024*1000-1); 
    OCR1A = (unsigned int) (time*15625-1); 
    // turn on CTC mode:
    TCCR1B |= (1 << WGM12);
    // Set CS10 and CS12 bits for 1024 prescaler:
    TCCR1B |= (1 << CS10);
    TCCR1B |= (1 << CS12);
    // enable timer compare interrupt:
    TIMSK1 |= (1 << OCIE1A);
    // enable global interrupts:
    sei();
  
  // -------------------------------------------
  // Konfigurieren der vier Anzeigen als Ausgaenge
  // -------------------------------------------
  for (byte a=0; a<4; a++) {
    pinMode(IOAnzeigen[a], OUTPUT);
  }
  // -------------------------------------------
  // Konfigurieren der 8 Segmente als Ausgaenge
  // -------------------------------------------
  for (byte a=0; a<8; a++) {
    pinMode(IOSegmente[a], OUTPUT);
  }
  digitalWrite(IOSegmente[7], HIGH);  //DP abschalten
}


void setup() {
disSetup();
Serial.begin(9600);
setInteruptTime(0.004);
}


void loop() {
}

void setInteruptTime(double time, boolean disableInterupts) {
  if (disableInterupts)
    cli();
  if (time > 0.000064) 
  OCR1A = (unsigned int) (time*15625-1); 
  else 
  OCR1A = 2; //Bin mir nicht mehr sicher ob hier beim letzen Upload nicht doch vielleicht 1 oder eine andere Zahl stand :S

  if(TCNT1 >= OCR1A) {
    TIMER1_COMPA_vect(); //ISR manuell Auslösen
    TCNT1 = 0; // Timer resten sodass er 
  }
  if (disableInterupts)
    sei();
}

void setInteruptTime(double time) {
  setInteruptTime(time, true) ;
}

[tomske (Gast)]

Hi, versuch doch mal, nach der Fehlermeldung zu suchen... Ich habs mit 
dem Schnipsel "protocol error, expect=0x14, resp=0x64" und "arduino" 
probiert und bekomme einen ganzen Sack voller Möglichkeiten, die aber 
jeweils wieder Fragen an Dein Setup aufwerfen... (Version der IDE, Größe 
des Programms usw.) Vielleicht ist da ein Hinweis für Dich dabei.

[Ert (Gast)]

Bei mir sind schon einige FTDI-Chip kaputt gegangen, evtl ist nur das 
die Fehlerquelle...

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Stormxy schrieb:
> //Die ordnet nur den IOxx den entsprechenden richtigen Pin zu
> #include <IOpins.h>
>
> #include <avr/io.h>
> #include <avr/interrupt.h>

M.E. solltest du erst die /avr/io.h einbinden und dann deine 
Pindefinitionen. Allerdings weiss ich ja nicht, wie du die Definitionen 
gemacht hast. Da kann schon mal was schief gehen.

[Stormxy (Gast)]

Danke für die Antworten,
geht leider immer noch nicht :/

Ert schrieb:
> Bei mir sind schon einige FTDI-Chip kaputt gegangen, evtl ist nur das
> die Fehlerquelle...
Kann ich leider schlecht überprüfen, hab aber mal die Spannung, die er 
abgibt gemessen (waren ~4,8V sollte also passen) und RX und TX 
kurzgeschlossen (bekam im Terminal alles was ich dem Chip gesendet habe 
genauso zurück), also würde ich sagen der sollte es nicht sein, wäre 
auch ein etwas plötzliches ableben des Chips.

Matthias Sch. schrieb:
> M.E. solltest du erst die /avr/io.h einbinden und dann deine
> Pindefinitionen. Allerdings weiss ich ja nicht, wie du die Definitionen
> gemacht hast. Da kann schon mal was schief gehen.
Gut möglich. Die IOpins.h wurde beim Wettbewerb als Material gestellt 
und daher habe ich die immer noch eingebunden, definitionen sind ganz 
simpel, z.B.

#ifndef ___IOpins____
#define ___IOpins____

#define IO2  0     // Serial RX
#define IO3  1     // Serial TX
#define IO4  2     // Switch 3
.......
#define SWITCH_PRESSED 0
#define SWITCH_RELEASED 1

#endif

Jedenfalls hilft mir das beim Problem nicht viel, da ich nichtmal mehr

void setup() {}
void loop() {}

oder generell irgendwas hochgeladen bekomme :/

tomske schrieb:
> Hi, versuch doch mal, nach der Fehlermeldung zu suchen... Ich habs mit
> dem Schnipsel "protocol error, expect=0x14, resp=0x64" und "arduino"
> probiert und bekomme einen ganzen Sack voller Möglichkeiten, die aber
> jeweils wieder Fragen an Dein Setup aufwerfen... (Version der IDE, Größe
> des Programms usw.) Vielleicht ist da ein Hinweis für Dich dabei.
Danke, daran habe ich garnicht dran gedacht mal mit der konretten 
Meldung zu googlen (hab nur mit einer Beschreibung gegoogelt und war 
recht erfolglos), aber auch damit bisher wenig Erfolg...
Immerhin habe ich es dadurch jetzt geschaft mal eine LED an den ATmega 
Pin anzuschließen die der Arduino Bootloader verwendet, die 
leuchtet/blinkt jetzt beim Boardreset und Programmierversuchen, aber 
wirklich schlau werde ich auch nicht drauß.

Hoffe also weiter auf Ideen und Erklärungen!

[Jürgen (Gast)]

Ich habe mal ein Arduino kompatibles Board weggeschmissen weil ich nicht 
mehr daran gedacht hatte, das DebugWire an war und ich es nicht 
ausgeschaltet hatte. Allerdinsg nutze ich die Boards nicht mit der 
Arduino IDE sondern mit AVR-Studio.
Bin schier daran verzweifelt in meiner unerfahrenheit. :D
Als dann die Müllabfuhr da war und den entsorgte kam der 
nachvollziehbare und getestete Geistesblitz.

[Stormxy (Gast)]

Habe das Problem mittlerweile selbst in den Griff bekommen.
Nachdem es eigentlich nur am Bootloader liegen konnte, habe ich nun doch 
den Eigenbau Parallel Programmer gebastlelt und an meinen alten Rechner, 
der zum Glück noch über eine Parallel Schnittstelle verfügt, 
angeschlossen. Musste zwar in 4 unterschiedlichen PDFs wühlen um die 
Verkabelung auch sicher richtig hinzubekommen und noch paar andere 
Hindernisse überwinden, aber am Ende hat tatsächlich alles geklappt und 
Arduino konnte den Bootloader neu auf den Atmega schreiben, womit dieser 
nun wieder seine Arbeit verrichtet.

Wie ich es geschafft habe den Bootloader nur mittels Arduino überhaupt 
zu beschädigen, ist mir jedoch immer noch ein Rätsel :S

Naja wenigstens ist mir jetzt viel klarer wie der ganze 
Programmiervorgang eigentlich abläuft :)