Arduino UNO spinnt

Hallo Freunde,

Ich habe ein Problemchen, Ich steuere mit meinem Arduino UNO in meinem Aquarium meine Strömungspumpen, das ging auch jetzt 4 Tage gut dann stellte ich Gestern Abend fest das der kasten in dem der Arduino verbaut ist so Warm wurde. als ich den Kasten auf machte und mit dem Finger fühlte war der Arduino richtig Heiß, also habe ich einen Füfter in den kasten mit eingebaut. Jedoch als ich Heute Morgen aufstand standen die Pumpen still und die Status LEDs die mit verbaut waren , waren aus. Ich habe alles ab gebaut von der Schaltung und den Controller an ein USB Kabel gehangen. die Grüne Power LED geht voll an und die LED vor dem Pin 13 Blinkt, und der Arduino wird auch nicht mehr Warm. jedoch hatte ich mir so gedacht das sich eventuell durch die Hitze das aufgespielte Programm aufgehangen hat, da ich es auch nicht mehr durch Resetten ans laufen bekomme. wollte ich den Code neu aufspielen und habe den Controller an den PC gehangen. aber nichts , bei Kontrollieren des Programms ist alles OK, beim Upload kommt die Fehlermeldung: avrdude: stk500_getsync(): not in sync: resp=0x00, da ich keine Englisch kann ist es für mich schwer was in Google zu finden was mein Problem lös. Ich habe mir gedacht das eventuell hier einer ist der das Problem kennt. an dem UNO hängt eine Raley Karte mit vier Raleys so das das die Leitungen der Pumpen sauber getrennt sind und das Programm hat ja auch die Pumpen 4 Tage gesteuert. Ich weis nicht mehr weiter....... denn ich habe das Programm schon öffters Upgeloadet.

lG

Ich kann dir nur bedingt zu deinem speziellen Projekt weiterhelfen, aber 2 Dinge fallen mir dazu ein:

  1. Diese Fehlermeldung bekomme ich häufig, wenn ich den Arduino neu Programmieren will, während er mit irgendwelchen Kabeln verbunden ist. Zieh mal alle Kabel usw. (bis auf USB natürlich) ab und probier es dann nochmal.

  2. Besonders warm sollte der eigentlich nur werden wenn zu viel Strom durchfließt. Die Pumpen hängen aber nicht direkt am Arduino Vin oder 5V Ausgang oder? Falls ja müsstest du das statt dessen Transistoren verwenden.

nein ich habe eine Relay Karte wo die Pumpen angeschlossen sind und das mit den kaben abziehen war lieb gemeint aber ich habe den Controller lediglich am USB hängen. Die meldung kommt jedesmal wenn das Programm Upload und mir schon die Meldung raus gibt wie groß das Programm ist und wieviel Speicher noch verfügbar ist, dann kommt sofort danach die Meldung.

l.G.

malerlein:
Kontrollieren des Programms ist alles OK, beim Upload kommt die Fehlermeldung: avrdude: stk500_getsync(): not in sync: resp=0x00

Eine Antwort (response, resp) von 0x00 heißt, dass der Arduino gar nicht mehr auf Deinen Uploadversuch reagiert. Tot.

Im einfachsten Fall hast Du die Boardeinstellung auf ein falsches Arduino-Board geändert ("Tools-Board"), aber wenn das richtige Board und der richtige COM-Port eingestellt ist und mit Deiner Beschreibung, wie Du den Arduino vorher gegrillt hast, spricht einiges dafür, dass Du den Controller oder ein anderes Bauteil auf der Platine gekillt hast.

Ein Arduino im Normalbetrieb wird nicht warm. Ein typisches Arduino-Board zieht bei 5V vielleicht 40 mA, macht 200mW = 0,2 Watt, da tritt keine nennenswerte Erwärmung auf.

Ich würde erstmal prüfen, woran es lag, dass der Arduino so warm wurde.

Entweder hast Du einen schweren Schaltungsfehler begangen, z.B. den Spulenstrom für Deine Relais direkt aus den Arduino-Pins gezogen und dabei die erlaubten max. 40 mA pro Pin oder 200mA pro Arduino an den Pins gesamt überschritten.

Oder Du hast sogar einen Kurzschluss programmiert, also irgendwo einen pinMode auf OUTPUT gesetzt, wo der Pin dann mit einem falschen Pegel verbunden war.

Vielleicht postest Du mal was zu Schaltbild, Stromversorgung und was wo angeschlossen und programmiert war. Denn wenn Dein Arduino jetzt tatsächlich defekt sein sollte, würde ich bei unveränderter Schaltung und Programmierung auf keinen Fall einen neuen dranhängen.

@malerlein:
Wenn du keinen UNO smd hast, kannst du den ATmega328 einfach austauschen da ein Sockel verbaut ist.
Dann fehlt der Bootloader, es gibt aber auch ATmega328 mit Arduinoloader zu kaufen. (3 Euro)

Die Erklärung verstehe ich jetzt nicht so richtig, wenn etwas mit der Programierung nicht gestimmt hätte, dann wäre der Uno doch bestimmt keine 4 Tage ohne Ausfall gelaufen und der Uno wurde mit 9V bestomt und die Pinbelegung geht lediglich auf die Platine der Relay Karte , so das alle vier Relas gezogen werden , also einmal 2 Rechte und einmal 2 Linke und von den Pumpen kommen die Kabel je an ein Relay Braun , Blau, Braun, Blau und gleichfarbig vom Netz. so das wenn das Relay abschaltet der Leiter und die Null komplett getrennt sind. ich mache mal en Bild von dem UNO so wie er verkabelt ist und der Relay Karte und stelle den

/*
Pumpensteuerung für Jürgen Mantell

Mai 2013 von markus.sawo@gmail.com

Zwei Pumpen werden über jeweils zwei Relais zufällig gesteuert, wobei beide Pumpen nicht zusammen aus sein dürfen.
Es werden zwei Relais pro Pumpe genutzt, um beide AC-Phasen sicher zu trennen.

Pinbelegung:

Pumpe 1 A = Pin 2
Pumpe 1 B = Pin 3

Pumpe 2 A = Pin 4
Pumpe 2 B = Pin 5

Status LED 1 = Pin 8
Status LED 2 = Pin 9

*/

// Gesamtgeschwindigkeit, also Faktor mit dem die Zufallszahlen multipliziert werden. Standard 1, höhere Zahlen = langsamer

float multiplikator = 1;

// Sonstige Variablen:

int pumpe1_A = 2;
int pumpe1_B = 3;

int pumpe2_A = 4;
int pumpe2_B = 5;

int led1 = 8;
int led2 = 9;

long zufall1 = 0;
long zufall2 = 0;

long minwert_1 = 0;
long minwert_2 = 0;

int zufall_pumpe = 0;
int zufall_led = 0;

int pumpen_check = 0;

int Status_1 = HIGH;
int Status_2 = HIGH;

long altMillis1 = 0;
long altMillis2 = 0;

void setup() {

// Hier werden die grundlegenende Einstellungen vorgenommen: Funktion der Pins (hier Ausgang)

pinMode(pumpe1_A, OUTPUT);
pinMode(pumpe1_B, OUTPUT);
pinMode(pumpe2_A, OUTPUT);
pinMode(pumpe2_B, OUTPUT);

pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);

randomSeed(analogRead(0));

// Serielle Verbindung aufmachen, falls man am PC was nachschauen möchte:

Serial.begin(9600);

}

void loop() {

// Alles was hier in loop(); steht, läuft immer wieder durch solange Strom am Controller ist

// Erstmal die aktuelle Zeit in zwei Variablen schreiben:

unsigned long jetztMillis1 = millis();
unsigned long jetztMillis2 = millis();

// #############################
// Routine für Pumpe #1
// #############################
//
// Ist die zufällige Zeit für Pumpe 1 schon abgelaufen?
// Siehe dazu auch: www.arduino.cc/en/Tutorial/BlinkWithoutDelay

if(jetztMillis1 - altMillis1 > zufall1) {

// Letzter Intervall?

altMillis1 = jetztMillis1;

// Zufallszahl zwischen 5min und 20min erzeugen:

zufall1 = random(600000, 1500000);

// Multiplikator nimmt die zufällige Zahl mal, um die Geschwindigkeit zu steuern.

zufall1 = zufall1 * multiplikator ;

// In Minuten umrechnen:

minwert_1 = zufall1 / 60000;

// Status der Pumpe umdrehen und Ausgabe auf Serial Port(AN/AUS)

if (Status_1 == HIGH)

{
Status_1 = LOW;

Serial.println("----------------------------- ");
Serial.print("Pumpe 1 Intervall AN ");
Serial.print(minwert_1);
Serial.print(" Minuten");
Serial.println("");
}
else
{
Status_1 = HIGH;

Serial.println("----------------------------- ");
Serial.print("Pumpe 1 Intervall AUS ");
Serial.print(minwert_1);
Serial.print(" Minuten");
Serial.println("");
}

// Werte an die Relais und LED schreiben:

digitalWrite(pumpe1_A, Status_1);
digitalWrite(pumpe1_B, Status_1);
digitalWrite(led1, Status_1);

// Für die gerade erzeugte Zufallszahl haben wir noch nicht gecheckt, ob beide Pumpen aus sind (siehe Routine für Pumpencheck):

pumpen_check = 0;

}

// #############################
// Routine für Pumpe #2
// #############################
//
// Ist die zufällige Zeit für Pumpe 2 schon abgelaufen?

if(jetztMillis2 - altMillis2 > zufall2) {

// Letzter Intervall?

altMillis2 = jetztMillis2;

// Zufallszahl zwischen 5min und 20min erzeugen:

zufall2 = random(600000, 1500000);

// Multiplikator nimmt die zufällige Zahl mal, um die Geschwindigkeit zu steuern.

zufall2 = zufall2 * multiplikator ;

// In Minuten umrechnen:

minwert_2 = zufall2 / 60000;

// Status der Pumpe umdrehen und Ausgabe auf Serial Port(AN/AUS)

if (Status_2 == HIGH)

{
Status_2 = LOW;

Serial.println("----------------------------- ");
Serial.print("Pumpe 2 Intervall AN ");
Serial.print(minwert_2);
Serial.print(" Minuten");
Serial.println("");
}
else
{
Status_2 = HIGH;

Serial.println("----------------------------- ");
Serial.print("Pumpe 2 Intervall AUS ");
Serial.print(minwert_2);
Serial.print(" Minuten");
Serial.println("");
}
// Werte an die Relais und LED schreiben:

digitalWrite(pumpe2_A, Status_2);
digitalWrite(pumpe2_B, Status_2);
digitalWrite(led2, Status_2);

// Für die gerade erzeugte Zufallszahl haben wir noch nicht gecheckt, ob beide Pumpen aus sind (siehe Routine für Pumpencheck):

pumpen_check = 0;

}

// #############################
// Routine für Pumpencheck
// #############################
//
// Dieser Teil kontrolliert ob beide Pumpen aus sind und wir für diese Zufallszahlen noch nicht geprüft hatten (pumpen_check == 0);
// Wenn das der Fall ist wird zufällig eine der beiden Pumpen ausgewählt:

if (Status_1 == HIGH && Status_2 == HIGH && pumpen_check == 0)

{

// Zufallszahl generieren zwischen 1 und 2 (3 muss als obergrenze angegeben werden, da Obergrenze exklusive)

zufall_pumpe = random(1,3);

// Nachricht auf Serial Port ausgeben:

Serial.println("");
Serial.println("############################################# ");
Serial.print("# Beide Pumpen aus - Schalte Pumpe Nr. ");
Serial.print(zufall_pumpe);
Serial.print(" an #");
Serial.println("");
Serial.println("############################################# ");
Serial.println("");

// Unterscheiden welche der beiden Pumpen ausgewählt wurde und Werte schreiben:

// Pumpe 1

if ( zufall_pumpe == 1 )

{

// Werte an die Relais und LED schreiben:

digitalWrite(pumpe1_A, LOW);
digitalWrite(pumpe1_B, LOW);
digitalWrite(led1, LOW);

}

// oder Pumpe 2

if ( zufall_pumpe == 2 )

{

// Werte an die Relais und LED schreiben:

digitalWrite(pumpe2_A, LOW);
digitalWrite(pumpe2_B, LOW);
digitalWrite(led2, LOW);

}

// pumpen_check wird gleich 1 gesetzt, es wurde also für dieses Set Zufallszahlen schon gecheckt ob beide Pumpen aus sind.
// Dieser Wert wird nach dem Erzeugen einer neuen Zufallszahl in den Pumpenroutinen wieder = 0 gesetzt.

pumpen_check = 1;
}

// Kurze Warteschleife von 20ms damit sich das Programm nicht selbst überholt.

delay(20);

}

Doch das ist ein SMD hat mir ein Bekannter besorgt und Programmiert, war ja auch alles in Ordnung, aber wenn ich Ihn gebraten habe , dann werde ich mir jetzt noch einen Mega holen und da das Programm laufen lassen. Die sind ja nicht so Teuer :cold_sweat:

malerlein:
Die Erklärung verstehe ich jetzt nicht so richtig, wenn etwas mit der Programierung nicht gestimmt hätte, dann wäre der Uno doch bestimmt keine 4 Tage ohne Ausfall gelaufen

Das weiß man nicht. Überlastungen außerhalb der Spezifikation müssen nicht unmittelbar zum Versagen von Bauteilen führen.

In Deinem Bild sehe ich links am Bildrand zwei Stücken blauen Draht gezogen.
Von wo nach wo hast Du da was verbunden?

Damit habe ich eine Brücke von GND nach Pin9 und GND nach Pin8 gelegt, damit die Relay Karte Strom erhält und die Pumpen im Dauerbetrieb sind. sonst müsste ich die Pumpen wieder abbauen und neue Kabel mit stecker anbringen. Das ist ja nichts anderes als das was der Controler auch macht er schaltet zu verschiedenen Zeiten GND auf Pin8 oder Pin9 damit die Relays anziehen und die Pumpen laufen.

malerlein:
Damit habe ich eine Brücke von GND nach Pin9 und GND nach Pin8 gelegt, damit die Relay Karte Strom erhält und die Pumpen im Dauerbetrieb sind. sonst müsste ich die Pumpen wieder abbauen und neue Kabel mit stecker anbringen. Das ist ja nichts anderes als das was der Controler auch macht er schaltet zu verschiedenen Zeiten GND auf Pin8 oder Pin9 damit die Relays anziehen und die Pumpen laufen.

OK, Ich versuche es Dir zu erklären.

// Du deklarierst Deine Pins:
int led1 = 8;
int led2 = 9;
...
// im Setup setzt Du diese auf OUTPUT
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
// jetzt sind pin-8 und pin-9 auf OUTPUT und LOW
// also noch kein Problem, falls mit Ground verbunden, ist einfach nur GND mit GND verbunden.

Und irgendwann später das:

digitalWrite(pumpe1_A, Status_1);
digitalWrite(pumpe1_B, Status_1);
digitalWrite(led1, Status_1);
// jetzt hast Du einen Kurzschluss an led1=8, wenn Status1==HIGH

digitalWrite(pumpe2_A, Status_2);
digitalWrite(pumpe2_B, Status_2);
digitalWrite(led2, Status_2);
// jetzt hast Du einen Kurzschluss an led2=9, wenn Status2==HIGH

Ein OUTPUT ist immer niederohmig, je nachdem ob Du den OUTPUT auf
LOW oder auf HIGH setzt, ist ein OUTPUT dasselbe wie GND oder dasselbe
wie eine +5V Stromquelle.

Wenn Du also einen OUTPUT auf HIGH setzt, dann ist es eine 5V Stromquelle.

Wenn Du denselben OUTPUT gleichzeitig mit GND verbunden hast, dann hast
Du den klassischen Kurzschluss zwischen GND und 5V erzeugt.
Jetzt wird der Atmega-Controller zum Grillgerät.

Hast Du diese beiden blauen Drähte erst gezogen, nachdem die Schaltung
nicht mehr funktionierte? Oder schon vorher?

Ja sicher habe ich sie erst gezogen nachdem nichts mehr ging. denn es wird ja nicht mehr geschaltet und um die Pumpen wenigstens die Tage bis zum neuen Arduino zu überbrücken habe ich die Brücken gelegt. Das ich das nicht im Betrieb machen kann das ist mir schon klar. Den die verdrahtung wr schon richtig sonst wären die Pumpen nicht 4 Tage einwandfrei gelaufen. Ich kann es mir auch nicht vorstellen warum der UNO auf einmal streikte, ich habe für die Tempratur, Sonnenauf und Untergang, Unwetter simulation sowie Mondlicht noch einen Mega, da ich noch nicht so firm bin mit dem Programmieren und von einem Bekannten Hilfe bekomme, denn man hätte das ja wahrscheinlich alles zusammen legen können. Aber jetzt bin ich froh das ich es auf den Mega gemacht habe sonst hätte ich im moment auch kein Licht. :slight_smile:

l.G.

Das sind immer so Kleinigkeiten, genau so war es mit den Lüsterklemmen die man auf dem Bild sieht, da waren eine Rote und eine Grüne LED dran und ich habe 2 MilchglasFiguren aus Ägypten da hatte ich die LED, drin installiert. immer wenn die Bumen gewechselt haben war entweder eine Figur von inner Raus Rot oder Grün beleuchtet odervwenn die Pumpen zusammen liefen eben Rot Und Grün beleuchtet. aber ich wusste nicht wie ich das berechnen sollte mit den Widerstnd an der LED. da die Led`s ja mit VCC zusammen waren und über GND geschaltet wurden und eine LED 3,1V und die ander 3,3V hatte aber zussammen 6,4V hatten, was soll man den da mit Widerstand absichern Die niedrigste Volt Zahl oder die gesammte Voltzahl, da wusste ich nicht ob die Rote wenn sie soe Hochomig abgesichert ist überhaupt noch leuchtet.

Welches Bauteil auf dem Uno wurde denn heiß?

Micky

Die Seite wo der 9V Anschluss ist , die war so Heiß das man nicht mit dem Finger drauf kommen durfte.

l.G.

Das hört sich doch nach dem Spannungsregler an. Haste den Uno extern mit Spannung versorgt oder über USB?

Micky

malerlein:
Ja sicher habe ich sie erst gezogen nachdem nichts mehr ging. denn es wird ja nicht mehr geschaltet und um die Pumpen wenigstens die Tage bis zum neuen Arduino zu überbrücken habe ich die Brücken gelegt. Das ich das nicht im Betrieb machen kann das ist mir schon klar. Den die verdrahtung wr schon richtig sonst wären die Pumpen nicht 4 Tage einwandfrei gelaufen.

Wie Du meinst.

malerlein:
ich wusste nicht wie ich das berechnen sollte mit den Widerstnd an der LED

Das ist relativ einfach.

Ohmsches Gesetz: U= R*I oder umgestellt: R= U/I

Für U am Widerstand setzt Du den Anteil der Spannung ein, der am Widerstand abfallen soll.
LEDs haben je nach Farbe eine unterschiedliche Vorwärtsspannung. Die genaue Vorwärtsspannung steht im Datenblatt der LED, Pi-mal-Daumen kann man für Low-Power-LEDs ansetzen:
gelbe LED: UF= 2,1 Volt.
rote LED: UF= 2,1 Volt.
grüne LED: UF= 3 Volt.
weiße LED: UF= 3,4 Volt.

Vernichtet werden am Widerstand muss immer die Differenz zur Betriebsspannung.
Arduinos arbeiten mit 5V, daher muß die zu vernichtende Spannung am Widerstand betragen:
rote LED: 5V - 2,1 V = 2,9V
grüne LED: 5V - 3V = 2V

Die maximale Stromstärke für Low-Power LEDs beträgt meist 20mA, für eine längere Lebensdauer bei geringerer Leuchtstärke, bleibt man meist darunter, sagen wir mal 15 mA.

Damit berechnet sich der korrekte Widerstandswert einer LowPower-LED an 5 V Betriebsspannung zu:
Rrot= 2,9V / 0,015A = 193 Ohm, nächster Wert nach Widerstandsreihe E12 ist 220 Ohm
Rgrün= 2V / 0,015A = 133 Ohm, nächster Wert nach Widerstandsreihe E12 ist 150 Ohm

Ergebnis:
Eine rote Low-Power LED an 5V wird mit 220 Ohm Vorwiderstand betrieben.
Eine grüne Low-Power LED an 5V wird mit 150 Ohm Vorwiderstand betrieben.

Wobei sich natürlich andere Vorwiderstandswerte ergeben, wenn

  • die Betriebsspannung eine andere ist
  • das Datenblatt für die LED eine andere Vorwärtsspannung UF angibt
  • die LED mit anderer Stromstärke betrieben wird
    Der Rechenweg an sich ist aber immer gleich.

Nein ich habe den immer an USB ob am PC oder auch so , da ich alles solche Stecker habe die USB Eingänge haben. Aber der UNO hatte ja auch nicht viel zu tun, er musste ja nur die vier Relays schalten , das dürfte ja nicht so viel ausmachen.

Danke für die Berechnung der Wiederstände, aber wie ist das denn wenn dann meide LED`s an sind da sie ja zusammen hängen sind dann 370 Ohm nicht zuviel bei 5V ????

malerlein:
Danke für die Berechnung der Wiederstände, aber wie ist das denn wenn dann meide LED`s an sind da sie ja zusammen hängen sind dann 370 Ohm nicht zuviel bei 5V ????

Zwei einzeln schaltbare LEDs haben das Schaltbild

           ______   
Pin-x ---|______|---->|------+
0/5V        Rx       LEDx    |
                             |-- GND 0V
          ______             |
Pin-y ---|______|---->|------+
0/5V        Ry       LEDy

(LED und Widerstand dürfen in einer Reihe auch vertauscht sein)

Außer GND an GND hängt da gar nichts zusammen.

Wenn Pin-x auf Low 0V ist, ist LEDx aus
Wenn Pin-x auf High 5V ist, ist LEDx an
Wenn Pin-y auf Low 0V ist, ist LEDy aus
Wenn Pin-y auf High 5V ist, ist LEDy an

Hi,
vieleicht im Moment nicht wirklich hilfreich, aber nochmal zu den Argument
"aber er ist doch 4 Tage problemlos gelaufen":

Aus eigener (leidvoller) Erfahrung:
so'n Arduino ist schon "ziemlich hart im einstecken" aber man kann sowohl programmiermäßig als auch verschaltungsmäßig schon ordentlich Mist bauen und irgendwann wirds dem guten Ardu dann auch "zu blöd" (im Sinne von zu lange zu viel Strom) und er quittiert den Dienst (schlichtweg durch zulange viel zu hohe Erwärmung)

Grüßle Bernd