Ein- Ausgabe beim Arduino

[Franz54]

Die SSR´s habe ich bis jetzt nur für Wechselspannung getestet. Diese Dinger die du da hast muss ich mir auch mal holen. Geht ja auch mit fetten Mosfet´s dafür habe ich mir ein paar besorgt, aber eigentlich stehe ich auch mehr auf solche fertig Geräte, die man schön verbauen kann. Hast du die auch schon mal mit Strömen von annähernd 40 Ampere belastet? Würde mich interessieren, ob die genug Kühlung haben, oder ob man die dann noch auf ein Kühlblech montieren muss, wenn man näher an die Belastungsgrenze kommt.

PS: Ich hatte meine Benachrichtigungen noch falsch eingestellt. Bekam also kein Nachricht wenn du hier was geschrieben hast. Das sollte jetzt funktionieren, hoffe ich.

Servus
Franz

[Der Alte]

Hallo Franz,

Geht ja auch mit fetten Mosfet´s dafür habe ich mir ein paar besorgt, aber eigentlich stehe ich auch mehr auf solche fertig Geräte,

...nur für einen Preis von 6 € kann man sie nicht bauen (von der Arbeit mal ganz abgesehen!)

Hast du die auch schon mal mit Strömen von annähernd 40 Ampere belastet?

Ich verwende die SSRs zum Einschalten einer Last (Akku-Test-Lipo). Bei einer Belastung von 40 Ampere bei 24 Volt läuft ein Akku-Test in diesem Fall ca. 6 Minuten, dann ist der Akku leer und wird abgeschaltet, um eine Tiefentladung zu verhindern. Eine zusätzliche Kühlung ist nicht notwendig. Es gibt aber spezielle Kühlbleche.

Weitere Erfahrungen habe ich noch nicht.

Ingo

[Der Alte]

Steuerung des Programmablaufs:

Das Programm wird in einer Schleife durchlaufen. Deshalb setzte ich durch Interrupts Flags, um den Ablauf zu steuern.

Beispiel: Ampelsteuerung mit Simulation und Menü

- wird der TASTER1 gedrückt, so wechselt die Variable Menue_ein (Flag) TRUE/FALSE und in der Schleife läuft entweder Menü oder Programm

- im Pogramm ändert sich in der Ampelsteuerung nur jede Sekunde etwas (durch newSecondFlag)

- in der Simulation 20 mal in der Sekunde etwas (newZehntelFlag)

Somit stelle ich den TIMER1 beim Mega wie folgt ein:

Code: Alles auswählen

  // Timer Interrupt (Timer 1)  
  
  cli(); // Interrupts aus
  
  // reset
  TCCR1A = 0; // setze TCCR1A register auf 0
  TCCR1B = 0; // setze TCCR1B register auf 0
  TCNT1  = 0; // setze counter auf 0
 
  OCR1A = 780; // Vergleichs Register (Taktfrequenz = 16.000.000 / Vorteiler = 1024)      (20 Hz)

  // setze Vorteiler auf 1024
  TCCR1B |= (1 << CS12) | (1 << CS10);   
  
  TCCR1B |= (1 << WGM12);   // turn on CTC mode
  TIMSK1 |= (1 << OCIE1A);  // enable timer compare interrupt
  
  sei(); // Interrupts ein 

20 mal pro Sekunde wird folgende Funktion aufgerufen:

Code: Alles auswählen

ISR(TIMER1_COMPA_vect) {
   t1++;
   newZehntelFlag = 1;
   if (t1 >= 19) {
    t1 = 0;
    t++;
    ss++;
    newSecondFlag = 1;
    if (t >= t_ende) { t = 0; }

    if (ss >= 59) { 
      ss = 0;
      mm++;           // setze Minute
    }  
    if (mm >= 59) { 
      mm = 0;
      hh++;           // setze Stunde
    }    
    if (hh >= 23) { 
      hh = 0;
      dd++;           // setze Tag
    }
  }
}

Die Variablen sind global deklariert. "newZehntelFlag" wird 20 mal je Sekunde gesetzt, aber ich habe den Namen nicht geändert.

Ingo

[Franz54]

Hast du bitte mal einen Link zu dem Joy-Stick? Ich habe am Bild nur eine Anschlußleiste gesehen mit x und y Anschluß, aber das Ding hat doch 5 Taster.

Grüße
Franz

[Der Alte]

Hallo Franz,

Hast du bitte mal einen Link zu dem Joy-Stick?

Den Joystick bekommst du im gleichen Laden, indem du auch dasTFT bekommst: https://www.marotronics.de/sonstige-Module
Der Preis von heute liegt bei 1,45 €. Das Geschäft ist in Deutschland und liefert sehr schnell.

Ich habe am Bild nur eine Anschlußleiste gesehen mit x und y Anschluß, aber das Ding hat doch 5 Taster.

Der Joystick hat 2 Poties und einen Taster: GND, VCC, SW, MX, MY. Dadurch kann man ihn auch so einfach abfragen - ohne Entprellung!

Siehe auch stickgeber.h

Ingo

[Der Alte]

Kommen wir nun zum "Herz" des Programms: void loop()

Code: Alles auswählen

void loop() 
{ 
    #ifdef CPU-LEER
      leer++;
    #endif

    if (newSecondFlag) { newSecondFlag = 0;
      #ifdef CPU-LEER
        Serial.print( "leer-Durchlaeufe: " ); Serial.println(leer);
        leer = 0;
      #endif 
      if (PROG_ein == 1) { loop_ampel(menue_Nr); }
    }
  
    if (PROG_ein == 0) { Menue(); }
   
    if (newZehntelFlag) { newZehntelFlag = 0; 
      if (PROG_ein == 1) {
         if (SIMU) { loop_simulation(menue_Nr); }
      }
    }
}

Für 1/0 könnte man natürlich auch TRUE/FALSE setzen.

Es werden also drei verschiedene Programmteile gesteuert:
Menue() ohne Zeitsteuerung- loop_ampel(menue_Nr) mit 1 Hz - loop_simulation(menue_Nr) mit 20 Hz

Eine Besonderheit gibt es noch anzumerken: #ifdef CPU-LEER (wird im config.h aktiviert

Solange es noch "leer-Durchlaeufe" gibt hat die CPU noch Zeit alles korrekt abzuarbeiten. Somit mit die Simulationsfrequenz auf 20 Hz erhöht werden. Ich befürchte aber, das es bei 3-spurigem Betrieb nicht mehr reicht.

Ingo

[Der Alte]

Wenn die Programme größer werden ....
verliert man leicht die Übersicht, wenn es um das Finden von Fehlern geht. Deshalb haben meine Programme immer die gleiche Struktur. Beginnend mit dem Hautp-TAB:

Code: Alles auswählen

/***************************************************************************************
// Name:        Ampelsteuerung
// Author:      Ingo 01.05.2018 (Projektbeginn)
***************************************************************************************/

char Name[] = "(CIK) Ampel" ;
char Projekt[] = "01.05.2018"; 
char Vers[] = "Vers.: 3.24  vom:  06.07.2020" ;
char IDE[] =  "IDE 1.8.12 "; 

#include "config.h"

dem config.h - TAB:

Code: Alles auswählen

/***************************************************************************************
// Name:         EINSTELLUNGEN
***************************************************************************************/
// Geber Menue 1
const byte MX1 = A0;
const byte MY1 = A1;
const byte TASTER1 = 20; // Interrupt 1

// Breite der Ampel in Pixel
#define A_BREIT 20

// Breite der Farbahn in Pixel
#define F_BREIT 15

// Ausgabe des SHIFT_OUT Registers
// #define SHIFT_OUT

in der config.h kann ich auch Testroutinen starten, um z.B Ausgaben zu testen. Diese werden, wenn nicht definiert auch nicht compiliert.

und dem setup - TAB:

Code: Alles auswählen

void SERIAL_setup()
{
  Serial.begin(9600);
  Serial.print(Name); Serial.print(" - "); Serial.print(Vers); 
  Serial.print(" - "); Serial.println(IDE);
  Serial.print("Projekt-Start "); Serial.println(Projekt);
  Serial.print("     compiliert: "); Serial.print(__DATE__); Serial.print(" "); Serial.println(__TIME__); 
  #ifdef __STDC__
  Serial.println("     Standard-C-Compiler\n");
  #else
  Serial.println("     Kein Standard-C-Compiler\n");
  #endif
  
  Serial.println();
}

void SD_setup()
{
  if (!SD.begin(chipSelect)) {
    Serial.println("SDcard initialisiert...");  
    Serial.println("SD Card failed, oder nicht vorhanden!");
    sd_card = false;   
  }
  else{
    Serial.println(" ");  
    Serial.println("SDcard initialisiert...");  
    sd_card = true; 
  }  
}

Je nach Projekt kommen kommen weitere TABs hinzu, in denen ich schon vorhandene Module hineinkopiere. Damit habe ich in kurzer Zeit ein Grundgerüst erstellt, das bei einer Fehlersuche hilfreich ist.

Beim Start werden immer die wichtigen Programmdetails über den seriellen Monitor ausgeben - so weiß ich immer, wann entstanden, welche Version, welche IDE.

Ingo

[Der Alte]

Das im Anfang erwähnte TFT-Display haben wir schon fast 20mal verbaut - manche Projekte werden von VereinskollegenInen nachgefragt. Der Blick im Aufbau zeigt, dass das Display mehr für den festen Einbau gedacht ist und weniger zum Experimentieren.

Die Herstellung eines Gerätes muss deshalb auch möglichst schnell mit wenig Aufwand möglich sein. Deshalb gibt es auch ein Standardgehäuse mit wenigen Modifizierungen in der Größe, aber beliebigen Aussparungen und Bohrungen. Verwendung von Mega oder Due - auch wenn ein Uno reicht. Da ich aber 16 bit Zeichensätze verwende (Umlaute, Sonderzeichen... ist ein Muss!) - und irgentwo muss der Zeichensatz ja gespeichert werden, sind 30 K oder mehr Programmspeicher schnell weg.

- Fräsen des Gehäuses mit allen Aussparungen und Bohrungen (ca. 15 min) (ca. 4 €)
- Montage des Megas auf 4 Distanzstücken (ca. 5 min) (ca. 12 € Mega)
- an Kabelbau 8 Winkelstecker anlöten (ca. 5 min) ( ca. 2 €)
- Joystick montieren und justieren, optional 3 Taster (ca. 10 min) (ca. 2 € Joystick)
- Kabel und Display aufstecken, ggf. Mega nachjustieren (ca. 5 min) (13 € Display)
- restliche Gehäuseteile zusammenstecken (kein Kleben, keine Schrauben) (ca. 5 min)

nach 45 Minuten kann programmiert werden - Gesamtkosten ca. 33 €

[Admin]

Ich sehe gerade, dass ich hier einige Beiträge gar nicht gesehen habe, weil ich das Forum immer mit der komplett Ansicht aufgerufen habe. Jetzt öffne ich es mit der Funktion "ungelesene Beiträge" und schon tauchen da noch nie gesehene Beiträge auf.

Franz

[e69-fan]

Hallo Ingo,

ich bin soeben auf Deinen Beitrag gestoßen:

... Mein Ampelprojekt für eine Modellbahn war zunächst für einen Nano konzipiert. Da gibts nicht viele Ausgänge. Es mussten aber 12 Ampeln (= 36 LEDs) gesteuert werden.

Für mein DC_Car System benötige ich für eine T-Kreuzung mit anschließenden Bahnübergang noch eine "Ampelanlage". Für meine Planung hätte ich noch eine Bitte:

Könntest Du Deinen Sketch hier im Forum als Projekt vorstellen?

Vielen Dank