Go Down

Topic: Zündreihenfolge eines 6 Zylinders simulieren (Read 1 time) previous topic - next topic

Yves83

Moin zusammen,
ich würde gerne für ein Azubi Projekt eine Zündreihenfolge eines 6 Zylinders simulieren.
Der V6 Block ist soweit fertig und in den Zylindern sind Plexiglasscheiben verbaut.
Ziel ist es per Bluetooth verschiedene Modi auszulösen.
Meine Frage wäre nun, was brauche ich für das Projekt an Hardware.
Netzteil mit 5V und 35W haben wir in der Firma liegen.
Gedacht war für jeden Zylinder eins der folgenden LED-Module zu verbauen.Sprich 7 LEDs pro Zylinder.
Nach meiner Recherche lässt sich soetwas mit einem Arduino Board realisieren. Nur der Markt ist voll damit und ich habe zu wenig Ahnung von der Materie. Die Verdrahtung sollte ich hinbekommen, da die Module ja in Reihe verdrahtet werden.
Jetzt bleiben die Fragen nach dem Board und des Scriptes. Könnt ihr mich dabei unterstützen?


Ich habe folgende LED-Module bestellt:
https://www.conrad.de/de/highpower-led-rgbw-210-w-8-lm-120-5-v-thomsen-1575799.html#downloadcenter

Bei Rückfragen immer raus damit....


uwefed

Die Zündreihenfolge hängt von der Kurbelwelle bzw Nockenwelle ab.

Zur Beleuchtung. Ja, mit den Modulen und einem arduino kannst Du das realisieren. Du mußt aber eine Positionsmessung der Nockenwelle vorsehen um die Zündung zu synchronisieren.

Grüße Uwe

noiasca

Bei Rückfragen immer raus damit....

Ist dir klar, dass das verlinkte Modul jede LED einzeln RGB ansteuert du daher pro Zylinder sozusagen mit 7 x 3 Werte - insgesamt also einen Ablauf für 126 Variablen machen wirst müssen?

Wenn ja - alles gut,
wenn nein, sag mal warum nicht ein "einfaches adaptiertes Lauflicht" mit 6 LEDs reicht.

In beiden Fällen kannst einen normalen anfängerfreundlichen Uno nehmen,
Als Bluetooth Empfänger einen HC05.
Evtl. ein Vorwiderstand für das erste LED Modul.






DE: Wie man Fragen postet:
1. was hat man (Sketch und Hardware)
2. was SOLL es machen
3. was macht es: IST (Fehlverhalten, Fehlermeldungen, Serial.Output ...)
4. Eine Frage stellen bzw. erklären was man erwartet

HotSystems

Für den Anfang würde ich dir den Uno empfehlen.

Zum Betreiben der Leds (5050) kannst du die FastLed-Library verwenden.
Diese hat auch Beispiele, mit der du sehr gut testen kannst.
Gruß Dieter

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

agmue

#4
Jul 23, 2018, 10:47 am Last Edit: Jul 23, 2018, 06:34 pm by agmue
Bei Bluetooth denke ich an ESP8266 oder ESP32 oder Adafruit Feather. Die können neben Bluetooth auch noch die paar LEDs bespaßen. Für so ein Azubi-Projekt ist das aber schon wie höhere Mathematik.

Zum Betreiben der Leds (5050) kannst du die FastLed-Library verwenden.
Nach meinem Wissensstand unterstützt die FastLed-Library RGBW noch nicht. Die Bibliothek von Adafruit (Adafruit_NeoPixel) kann es.

25 Aug 2017: "I am in the middle of a complete rewrite of the library to support RGBW" Quelle

Ist dir klar, dass das verlinkte Modul jede LED einzeln RGB ansteuert du daher pro Zylinder sozusagen mit 7 x 3 Werte - insgesamt also einen Ablauf für 126 Variablen machen wirst müssen?
Bei RGBW sind es 7 LED x 4 Farben x 6 Zylinder = 168 Bytes.
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Yves83

Ohhh, da habe ich mich wohl falsch ausgedrückt. Der Motor ist leer geräumt, nix Nockenwelle.
Auf den Motor kommt oben eine Glasplatte drauf und die Zündreihenfolge ist nur für die Optik.

Idee war, wie gesagt pro Zylinder ein Modul zu nehmen.
LED 1-7 ( Modul1-Zylinder1 ) leuchten zusammen für 100ms rot und wieder aus = 1 Zylinder gezündet
LED 8-15 ( Modul2-Zylinder2 ) leuchten zusammen für 100ms rot und wieder aus = 2 Zylinder gezündet
LED 16-23 (Modul 3-Zylinder3 ) leuchten zusammen für 100ms blau und wieder aus = 3 Zylinder stößt aus
u.s.w.

In die Programmierung würde ich mich dann reinfuchsen, geht erstmal um die Hardware um es zu realisieren.
Ein Lauflicht funktioniert nicht, weil die Zylinder ja jeweils zünden und mit dem nächsten Hub ausstoßen.

Ich müsste also auf alle 6 Zylinder per Programmierung frei zugreifen können.
Also hätte ich 6 Blöcke mit jeweils 7 LED machen zusammen 42 LED, wobei 7 LEDs immer gleich angesteuert werden ( Rot und Blau )

noiasca

klar lässt sich das als Lauflicht darstellen, nur halt eben nicht in 1-2-3-4-5-6 sondern in 1-5-3-6-2-4 oder was auch immer das für ein Motor ist.

Bei deiner Anforderung (7x gleichzeitig) würde ich andere Module nehmen und diese 1:1 am Arduino anstecken.

Übrigens, dass man ab simulierten 100RPM nicht mehr viel vom Ablauf sieht ist dir eh auch klar oder?



DE: Wie man Fragen postet:
1. was hat man (Sketch und Hardware)
2. was SOLL es machen
3. was macht es: IST (Fehlverhalten, Fehlermeldungen, Serial.Output ...)
4. Eine Frage stellen bzw. erklären was man erwartet

noiasca

#7
Jul 23, 2018, 12:35 pm Last Edit: Jul 23, 2018, 12:41 pm by noiasca
Wie geschrieben, hab ichs mal als klassisches Lauflicht probiert inkl. Steuerung der Drehzahl über Serial:

Einige werden den Code wiederkennen:
Code: [Select]

// Lauflicht zur Simulation einer Zündreihenfolge eines 6 Zylinders
// http://forum.arduino.cc/index.php?topic=559548.msg0#new
// Ähnlich dem Muster von http://forum.arduino.cc/index.php?topic=518131.0
// und Lauflicht in zwei Richtungen http://forum.arduino.cc/index.php?topic=558863.0
// Beigesteuert von noiasca.
// Version 2018-07-23


/* ***************************
    Configuration/Konfiguraton
 * ************************* */

//                                5432109876543210           // das Muster, einfach als Bitfolge in einem 2-Byte dann kann man es einfach in der IDE "hinmalen"
//                                                           // hier wollen wir 1,5,3,6,2,4
const uint16_t     pattern[] = {0b0000000000000001,          // 1 Led
                                0b0000000000010000,          // 5
                                0b0000000000000100,          // 3
                                0b0000000000100000,          // 6
                                0b0000000000000010,          // 2
                                0b0000000000001000           // 4
                               };

//const uint8_t ledPin[] = {13, 12, 2, 11, 3, 10, 4, 9, 5, 8, 6, 7}; // maximal 16 Pins - vorsicht der erster PIN ist Index 0 - und das ist im Bit-Muster/Pattern die letzte Stelle!!!
const uint8_t ledPin[] = {8, 9, 10, 11, 12, 13};                     // Aktuelle Umsetzung - auf meinem Board

const uint8_t turnsPerStroke = 2;                         // 4 Takter brauchen zwei Umdrehungen für eine Zündung, bei 2 Takter kann man das auf 1 Stellen
const uint16_t rpmMax = 9000;
const uint8_t steps = 100;                                // um wie viel soll die RPM verändert werden

#define DEBUG_UART 1                                      // Debugausgaben auf Serieller Schnittstelle falls man keine LEDs hat: 0 nein / 1 ja

/* ***************************
    Globals / Variablen für den Sketch
 * ************************* */

uint32_t lastMillis = 0;                                  // wann wurde das letzte mal ein Update der LEDs gemacht
uint16_t totalNoPattern = 0;                              // soviele Pattern gehen zwar nie auf einen UNO, aber mehr als uint8_t könnten es schon werden. man könnte ein paar Byte sparen wenn man ein fixes precompiler #define oder ein const macht.
uint8_t  actualPattern = 0;                               // welches Muster soll aktuell ausgegeben werden
uint8_t  totalNoPins = 0;                                 // Anzahl der Leds wird einmal zur Laufzeit ermittelt
uint16_t myInterval = 300;                                // Hinweis: falls weniger als 254ms gewünscht sind, kann man auch auf uint8_t umstellen
uint16_t rpm = 600;


/* ***************************
    Setup
 * ************************* */

void setup() {
  Serial.begin(115200);
#if DEBUG_UART
  Serial.println(F("\nLED Lauflicht in 2 Richtungen"));
#endif

  totalNoPattern = sizeof(pattern) / sizeof(pattern[0]);   // Ermittlung wie viele Pattern definiert wurden, ich mach das zur Laufzeit, weil ich mir das abzählen sparen wollte.
  totalNoPins = sizeof(ledPin) / sizeof(ledPin[0]);        // Ermittlung wie viele Pins definiert wurden um die Konfiguration zu vereinfachen

  for (uint8_t i = 1; i < totalNoPins; i++) {
    pinMode(ledPin[i], OUTPUT);
  }
}

/* ***************************
    Main - Loop
 * ************************* */

void loop() {
  myInterval = 60000UL / rpm / totalNoPins / turnsPerStroke;        // calculate an Intervall for that motor
  if (millis() - lastMillis >= myInterval)
  {
    actualPattern++;
    if (actualPattern >= totalNoPattern) actualPattern = 0;
    for (uint8_t i = 0; i < totalNoPins; i++)                      // von der Vorgabe her reichen die 10 - werden alle 16 Leds benötigt müsste man auch im setup() mehr initialisieren
    {
      if (pattern[actualPattern] & (1 << i)) {
#if DEBUG_UART
        Serial.print(F("X"));
#endif
        digitalWrite(ledPin[i], HIGH);
      }
      else {
#if DEBUG_UART
        Serial.print(F(" "));
#endif
        digitalWrite(ledPin[i], LOW);
      }
    }
#if DEBUG_UART
    Serial.print(F(" - "));
    Serial.print(actualPattern);
    Serial.print(F(" @"));
    Serial.print(rpm);
    Serial.print(F(" myInterval="));
    Serial.println(myInterval);
#endif
    lastMillis = millis();
  }
  // Fetch Serial data
  checkSerial();
  // do what ever you want to do unblocked here
}

//check, read and process data from serial interface
void checkSerial()
{
  if (Serial.available())
  {
    byte inByte = Serial.read();
    switch (inByte)
    {
      case '+':
        if (rpm <= rpmMax + steps)
          if (rpm < steps)
            rpm += steps / 10;
          else
            rpm += steps;
        break;
      case '-':
        if (rpm >= steps / 10)
          if (rpm <= steps)
            rpm -= steps / 10;
          else
            rpm -= steps;
#if DEBUG_UART
        if (rpm == 0) Serial.println(F("motor stopped (knapp vor dem OT sonst würde nicht eine LED leuchten ;-)"));
#endif
        break;   
      case '4':
        rpm = 400;
        break;
      case '6':
        rpm = 600;
    }
  }
}


Der Code müsste bis 16 Zylinder funktionieren, und ist für konventionell verdrahtete LEDs. Das auf Stripes zu ändern kann man immer noch machen, sobald genug Verständnis da ist.

Generell glaube ich, dass ein reines Einschalten von LEDs in dieser Sache nicht förderlich ist. Da bekommt man Augenkrebs.
Noch ein Beweisfoto (Meine Videos mag dieses Forum nicht):
DE: Wie man Fragen postet:
1. was hat man (Sketch und Hardware)
2. was SOLL es machen
3. was macht es: IST (Fehlverhalten, Fehlermeldungen, Serial.Output ...)
4. Eine Frage stellen bzw. erklären was man erwartet

HotSystems

.....
Nach meinem Wissensstand unterstützt die FastLed-Library RGBW noch nicht. Die Bibliothek von Adafruit (Adafruit_NeoPixel) kann es.
Ahh....ok. Das war mir nicht bekannt.
Danke für die Richtigstellung.
Gruß Dieter

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

agmue

#9
Jul 23, 2018, 12:46 pm Last Edit: Jul 23, 2018, 06:35 pm by agmue
Außer den LEDs, einem EIN/AUS-Schalter und dem Netzteil brauchst Du Dich nur für einen Arduino mit separatem Bluetoothmodul oder einer Platine mit Bluetooth drauf (ESP8266 oder ESP32), die per Arduino-IDE programmiert werden kann, zu entscheiden.

Persönlich wäre mir ein Potentiometer für die Geschwindigkeit und ein Schalter für die verschiedenen Modi sympatischer. Einfacher wäre es ebenfalls :)

Ahh....ok. Das war mir nicht bekannt.
Danke für die Richtigstellung.
Bitte gerne :)
Ich habe so ein Teil und bin daher über diese Problematik gestolpert.
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

noiasca

#10
Jul 23, 2018, 01:07 pm Last Edit: Jul 23, 2018, 01:18 pm by noiasca
Die Krönung des Ganzen wäre wenn man die einzelne Zündung als Ultra-Slowmotion Ablauf simuliert.

Also das Aufleuchten eines kleinen Punktes als Funke von der Zündkerze und dann das verzögerte Ausbreiten der Flamme im Brennraum.

so wie es im ersten Abschnitt dieses Videos gezeigt wird:
https://www.youtube.com/watch?v=jdW1t8r8qYc

oder hier ab ca 4:30
https://www.youtube.com/watch?v=rURHVLM9nxs

Dann machen RGB(W) LEDs Sinn, sonst reicht obiges Blink-Gezappel auch ;-)
Aber das wäre dann kein Anfängerprojekt mehr.
DE: Wie man Fragen postet:
1. was hat man (Sketch und Hardware)
2. was SOLL es machen
3. was macht es: IST (Fehlverhalten, Fehlermeldungen, Serial.Output ...)
4. Eine Frage stellen bzw. erklären was man erwartet

uwefed

Die in der Anzeige genannten SK6812 sind eigentlich RGB; das Bild zeigt aber andere LED.
Wer weiß dann was die LEDs wirklich machen.
Grüße Uwe

TriB

oder einer Platine mit Bluetooth drauf (ESP8266 oder ESP32)
Der ESP8266 verfügt nur über ein WiFi Modul und nicht über Bluetooth. der ESP32 beinhaltet beides.

Da das HC-06 Bluetooth Modul allein fast genauso viel kostet, wie der ESP32, würde ich zu letzterem tendieren.

Als erstes, bau Dir mit einem LED Modul einen Testaufbau auf und bringe die LED zum leuchten/blinken.
Dann erst verbau alle 6 Module und probiere den Sketch von noiasca aus.
Wenn das alles funktioniert, kannst Du beginnen Deine Anpassungen (Farbwünsche, Bluetooth-Ansteuerung, usw.) zu integrieren.

volvodani

Mal so am Rande wenn man nicht unbedingt Adafruit-Lib nutzten muss kann man >hier< fündig werden.
Die SK6812 sind 4"Farb"-LED also RGB und dazu noch ein Weiß entweder warm oder kalt.
Wie oben erwähnt wäre der ESP32 der interessanteste da Bluetooth incl ist, ich kann aber nicht sagen ob der ESP von der Lib unterstützt wird.
Gruß
DerDani

 
"Komm wir essen Opa!" - Satzzeichen retten Leben!

uwefed

Dani, wo hast Du ein Datenblatt gefunden, das den Controller/LED  RGBW spezifiziert. Ich finde nur GRB LED.
Grüße Uwe

Go Up