Go Down

Topic: Schrankbeleuchtung - Arduino hängt sich auf (Read 2993 times) previous topic - next topic

Tommy56

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)

combie

#46
Nov 04, 2018, 09:15 pm Last Edit: Nov 04, 2018, 10:01 pm by combie
Quote
Die Schutzdioden bei cmos - Eingängen haben schon ihre Berechtigung, aber die sollten doch wohl auch ausreichend wirken, oder?
Je hochfrequenter die Störung, desto Energie reicher.

FET und Dioden (ihre Sperrschichten) wirken bei hochfrequenten Signalen wie Kondensatoren.
Lassen sie also quasi ungehindert ins innere des µC durch.



Quote
Die Kabel sind ca. 2m lang; das ist sicher schon lang?! Was meinst du mit "niederohmigere"? Dachte - in meiner kindlichen Naivität - dass man für Pull-Down-Widerstände eher hochohmige Widerstände nimmt?! Also so 10k oder so?!?!?!
Wieso Pulldown?
Laut dem Schaltplan und dem Programm, was ich bisher gesehen habe, verwendest du nur die internen Pullup.
Und die sind sehr hochohmig. Keinesfalls ausreichend für 2m Kabel.

Code: [Select]

         +----------------------------------------+---------+ 5V
         |                                        |
        +++                                       |
        | | 10K                            +------+-----+
        | |                                |            |
        +++                                |            |
         |       +------+                  |    µC      |
+--------+-------+      +---------+--------+            |
+  /             +------+         |        |            |
  / Taster        100R           +-+       |            |
 /                          22nF +-+       +-----+------+
+                                 |              |
|                                 |              |
+---------------------------------+--------------+-----------+ 0V


Diese Tiefpassschaltung sollte auch bei 2m langen Leitungen funktionieren.

Der 22nF Kondensator schließt alle Störungen gegen Masse kurz
Der 10K Widerstand sorgt für einen hohen Ruhepegel
Der 100R Widerstand schützt die Tasterkontakte vor hohen Kondesatorentladeströmen.

Mit den Werten kann man spielen.

Übrigens:
Keine Gewähr, dass das Abhilfe schafft.

Gefährlich, was Theorien aus Menschen machen können.
Schlimmer, was Menschen aus Theorien machen.

Doc_Arduino

Hallo,

wir sind doch hoffentlich einig das der Transistor keinen Einfluss auf die Absturzprobleme hat. Und wir sind uns hoffentlich ebenfalls einig das selbst eine Störung am Eingang das Programm nicht außer Tritt bringt. Die Störung ist irgendwann vorbei und die vielleicht zufällig eingeschalteten LEDs schalten sich wieder aus.

Ich würde folgenden Vorschlag unterbreiten, weil ich immer noch wie andere die Spannungsversorgung in Verdacht habe. Nehme jeweils 4 LED Streifen aus dem Strang raus. Dadurch wird das Netzteil entlastet. Auch wenn ich einem China Netzteil was mit 1A angegegeben ist 540mA zutraue. Eine Pulsbelastung ist aber immer so eine Sache. Bei den dünnen Kabeln bin ich mir jetzt nicht so sicher. Ich persönlich würde größere Querschnitte verwenden. Und dann solltest du deine Masseverbindungen überprüfen. Optimal wäre wenn alle Leitungen Sternförmig zusammengeführt sind und sich an der Netzteilmasse treffen. Also nicht von Punkt zu Punkt durchgeschleift. Das könnte auch dem Pololu helfen besser die 5V besser zu regeln. Ein Multimeter kann keine Peaks erfassen.

Was du auch testweise machen kannst ist, den Takt vom µC softwareseitig runtersetzen. Dann ist er gegen Schwankungen der Versorgungsspannung unempfindlicher. Dazu den Clock Prescaler zum Bsp. auf 16 setzen dann läuft er mit 1MHz. Alle millis und delays verlängern sich damit um Faktor 16. Ist für den Test erstmal egal sein, ggf korrigierste das zusätzlich im Sketch.

Und dann schauen wir einmal was der Ball macht.
Tschau
Doc Arduino '\0'

Messschieber auslesen: http://forum.arduino.cc/index.php?topic=273445
EA-DOGM Display - Demos: http://forum.arduino.cc/index.php?topic=378279

combie

Quote
Und wir sind uns hoffentlich ebenfalls einig das selbst eine Störung am Eingang das Programm nicht außer Tritt bringt. Die Störung ist irgendwann vorbei und die vielleicht zufällig eingeschalteten LEDs schalten sich wieder aus
Nein.
In dem Punkt bin ich nicht mir dir einer Meinung!
Gefährlich, was Theorien aus Menschen machen können.
Schlimmer, was Menschen aus Theorien machen.

karatebietz

Hey folks,

erstmal Danke wieder für die Antworten!

Ich würde es nach dem alten Motto machen: "Versuch macht kluch" und stumpf eins nach dem andern ausprobieren.

Werd einfach mal ein paar LEDs abklemmen,dann nen Pull-Up zwischen schieben, dann die Transistoren tauschen und ggf. auch die Netzversorgung überarbeiten.
(in der Reihenfolge ist es für mich vermutlich am leuchtesten).

Bin leider die Woche wieder dienstlich unterwegs, aber die Teile muss ich ohnehin erstmal noch bestellen.

Ich halte euch natürlich auf dem Laufenden!

Cheers,
Christian

gregorss

Ich halte euch natürlich auf dem Laufenden!
Ich habe Dir mal vorschussmäßig einen Karmapunkt gegeben. Das verpflichtet :-)

Gruß

Gregor
Nicht lange fackeln, lass' Backen wackeln! (Seeed)

HotSystems

#51
Nov 14, 2018, 11:58 am Last Edit: Nov 14, 2018, 11:59 am by HotSystems
Jetzt würde mich mal interessieren, wie weit es hier mit den Untersuchungen des Problems ist.

Sollte sich das Problem nicht lösen lassen, versuch es doch mal mit IR-Bewegungsmeldern (PIR).

P.S.
Der Uno mit dem Sketch läuft immer noch ohne einen Absturz.
Nur so als Info für den TO.
Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

karatebietz

Hey folks,

ich wollte noch eine etwas belastbarere Statistik aufbauen, aber wenn es jetzt schon Nachfragen gibt, dann zumindest schon mal einen Zwischenstand:

Auf der Dienstreise bin ich mit meinem Chef ins Gespräch gekommen (bzgl. Elektronik auch vom Fach und Arduinobastler) und hatte von ihm noch den Hinweis bekommen, das ganze mit einem kleinen delay von 50-100ms zu entlasten. Hierdurch reagiert das ganze System wohl nicht mehr so empfindlich auf Störungen etc. ("good programming practice", waren seine Worte hier... - naja, er hat ja zum Glück meinen Code nicht gesehen, sonst würde er wohl die Hände über'm Kopf zusammenschalgen  :o )
Auch wenn das Licht dann nicht in der ersten Millisekunde angeht (ist bei mir ja aber auch nicht zwingend erforderlich)

Da es bei mir persönlich gerade einiges zu regeln gibt und auch beruflich ziemlich ausgelastet bin, hab ich erstmal nur das delay in die loop eingebaut und noch keine Hardwareänderungen vorgenommen (da sehe ich grade einfach kein Land :smiley-confuse: ).

Und was soll ich sagen: Seit immerhin nun 4 Tagen läuft das Ding.

Also: delay(75) in die Hauptschleife gepackt und dafür den Counter für millis beim fading etwas reduziert ("fadingPeriod").

Das ist nun zwar alles bissl von hinten durch die Brust ins Auge (der Code könnte so sicher auch wieder deutlich entschlackt werden), aber funktioniert erstmal. Schalte die Tage viell. auch den 2. Schaltkreis wieder frei, falls ich dazu komme.

Sobald ich wieder etwas Luft sehe, mache ich mich gerne an die genannten Vorschläge noch ran - interessiert mich ja auch, was da nun das Übel war!
(Sollte es wieder krachen, melde ich mich natürlich auch)


Code: [Select]



//-----------------------------------------------------
//Schaltkreise 1 und 2 sind identisch und unterscheiden sich nur durch Zahl 1 bzw. 2
//-----------------------------------------------------

#define Transistor1 3 //Transistor für Schaltkreis 1 an PIN 3 angeschlossen (=PWM-Pin)
#define Transistor2 5
#define Schalter1 10   //Schalter für Schaltkreis 1 an Pin 10
#define Schalter2 8


boolean SwitchWasClosed1 = true;    //registriere, ob Schalter schon länger offen ist
boolean SwitchWasClosed2 = true;

unsigned long startMillis1; //Startzeit für neue Periode
unsigned long startMillis2;
unsigned long startFadeDownMillis1; //Startzeit für Fadingeffekt (Nur bei Licht-Aus)
unsigned long startFadeDownMillis2;

byte brightness1 = 0; //Anfangshelligkeit
byte brightness2 = 0;


//Diese Parameter sind für beide Schaltkreise gleich und bleiben konstant

const unsigned long fadingPeriod = 5; //Verzögerungszeit für Fading - je groesser, desto langsamer
const unsigned long maxPeriod = 720000; //Maximale Leuchtdauer (in ms) -> 12 min
byte maxBrightness = 250; // maximale Helligkeit (255=max)




void setup() {
  // put your setup code here, to run once:

  pinMode(Transistor1, OUTPUT);
  pinMode(Transistor2, OUTPUT);
  pinMode(Schalter1, INPUT_PULLUP);
  pinMode(Schalter2, INPUT_PULLUP);
  startMillis1 = millis(); //initial Startzeit;
  startMillis2 = millis();
  startFadeDownMillis1 = millis();   //initiale Startzeit für downfading (damit es überhaupt losgeht)
  startFadeDownMillis2 = millis();
  pinMode(LED_BUILTIN, OUTPUT);
}




void loop() {
  // put your main code here, to run repeatedly:

  digitalWrite (LED_BUILTIN, ((int)millis() & 0x200) != 0 ); // blinkt mit 1,024 Hz - zum Debugging: Läuft Arduino noch?
  schalter1();    //Durchführung/Überwachung von Schalter 1
  //  schalter2();    //Durchführung/Überwachung von Schalter 2

  delay(75);   //Verzögerung, um "Verschlucken" zu verhindern (Anregung von Tim)
}


//___________________________Schalter 1___________________________


void schalter1() {
  if (digitalRead(Schalter1) == LOW)  //Zusatz if-Bedingung wird benötigt um Timer neu zu setzen + Zustand zwischen fading an und fading aus zu unterscheiden (sonst Licht-An-Licht-Aus-Loop)
  {
    if (brightness1 > 5) //wenn Licht vorher an war, fading Licht aus (sonst tue nichts)
    {
      fadeDown1();
    }

    if (brightness1 <= 5) //Wenn Licht dunkel genug, schalte ganz aus und setze Variablen auf default zurück
    {
      SwitchWasClosed1 = true; // Schalter war zu --> "fading an" Schleife wird als nächstes durchlaufen
      digitalWrite(Transistor1, LOW);  //Setze Transistor auf definierten Wert "0" zurück
      brightness1 = 0; //setze Anfangsbrightness wieder auf 0
    }
  }

  else //Wenn Schalter geschlossen wird, mache Licht an
  {
    //if (brightness1 <= maxBrightness and SwitchWasClosed1 == true and millis() - startMillis1 >= fadingPeriod) //wenn erfüllt: noch keine mximale Helligkeit + Schalter gerade geöffnet worden + Zeit für nächsten Fading-Schritt
    if (brightness1 <= maxBrightness && SwitchWasClosed1 == true && millis() - startMillis1 >= fadingPeriod) //wenn erfüllt: noch keine mximale Helligkeit + Schalter gerade geöffnet worden + Zeit für nächsten Fading-Schritt
    {
      analogWrite(Transistor1, brightness1); //setze Helligkeit
      brightness1++; //erhöhe Helligkeit (bis Maximum erreicht ist)
      startMillis1 = millis();  //setze aktuelle Zeit als neue Startzeit (um Fading zu erzielen)
    }


    if (millis() - startMillis1 >= maxPeriod) //wenn die maximale Wartezeit vorüber ist (Tür ist zu lange offen geblieben), wieder Licht aus (mit fading)
    {
      SwitchWasClosed1 = false;  //Sage, dass Schalter offen stehen geblieben ist -> lasse Licht aus (sonst loop im fading)

      fadeDown1();

      if (brightness1 <= 5) //Wenn minimale Helligkeit erreicht, muss Transistor auf LOW gezogen werden, sonst glimmen die LED weiter
      {
        digitalWrite(Transistor1, LOW);
      }

    }
  }


}


void fadeDown1() //Funktion zum Ausdimmen der LED an Schalter 1
{
  if (millis() - startFadeDownMillis1 >= fadingPeriod and brightness1 > 5)
  {
    analogWrite(Transistor1, brightness1); //setze Helligkeit
    brightness1--; //erhöhe Helligkeit bis Maximum erreicht
    startFadeDownMillis1 = millis();  //setze aktuelle Zeit als neue Startzeit fuer Downfading

  }
}

/*

  //___________________________Schalter 2___________________________


  void schalter2() {
  if (digitalRead(Schalter2) == LOW)  //Zusatz if-Bedingung wird benötigt um Timer neu zu setzen + Zustand zwischen fading an und fading aus zu unterscheiden (sonst Licht-An-Licht-Aus-Loop)
  {
    if (brightness2 > 5) //wenn Licht vorher an war, fading (sonst tue nichts)
    {
      fadeDown2();
    }

    if (brightness2 <= 5) //Wenn Licht dunkel, schalte ganz aus und setze Variablen auf default zurück
    {
      SwitchWasClosed2 = true; // Schalter war zu --> "fading an" Schleife wird als nächstes durchlaufen
      digitalWrite(Transistor2, LOW);  //Setze Transistor auf definierten Wert "0" zurück
      brightness2 = 0; //setze Anfangsbrightness wieder auf 0
    }
  }

  else //Wenn Schalter geöffnet wird, mache Licht an
  {
    if (brightness2 <= maxBrightness and SwitchWasClosed2 == true and millis() - startMillis2 >= fadingPeriod) //wenn erfüllt: noch keine mximale Helligkeit + Schalter grade geöffnet worden + Zeit für nächsten Fading-Schritt
    {
      analogWrite(Transistor2, brightness2); //setze Helligkeit
      brightness2++; //erhöhe Helligkeit bis Maximum erreicht
      startMillis2 = millis();  //setze aktuelle Zeit als neue Startzeit
    }


    if (millis() - startMillis2 >= maxPeriod) //wenn die maximale Wartezeit vorüber ist, wieder Licht aus (mit fading)
    {
      SwitchWasClosed2 = false;  //Sage, dass Schalter offen stehen geblieben ist -> lasse Licht aus (sonst loop im fading)

      fadeDown2();

      if (brightness2 <= 5) //Wenn minimale Helligkeit erreicht, muss Transistor auf LOW gezogen werden, sonst glimmen die LED weiter
      {
        digitalWrite(Transistor2, LOW);
      }

    }
  }


  }


  void fadeDown2() //Funktion zum Ausdimmen der LED
  {
  if (millis() - startFadeDownMillis2 >= fadingPeriod and brightness2 > 5)
  {
    analogWrite(Transistor2, brightness2); //setze Helligkeit
    brightness2--; //erhöhe Helligkeit bis Maximum erreicht
    startFadeDownMillis2 = millis();  //setze aktuelle Zeit als neue Startzeit fuer Downfading

  }
  }
*/




Beste Grüße erstmal in die Runde und noch mal Danke für die ganzen Anregungen (die ich hoffentlich auch bald noch umsetzen kann)!!!!!!

Cheers,
Christian

HotSystems

Damit wird das Problem ähnlich der Schaltung von combie "gelöst".
Optimal wäre in deinem Fall aber die Hardwarelösung.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

Go Up