Tastersteuerung Anfrage

[brummbaehr]

Dann steht es aktuell 2:2 Schraubanschluss zu Kabelpeitsche.

Ja, das Moped sollte auch auf den Seitenständer stehend laufen.
Einen 9ten Eingang für den Leerlaufschalter wird schwierig.
Also muss Leerlaufschalter und Seitenständer auf einem Eingang geklemmt werden.
Den Leerlaufschalter dann über eine Diode, so das die Leerlaufkontrollleuchte nicht dauerhaft leuchtet wenn der Seitenständer eingeklappt ist. Diese Diode noch auf die Platine zu platzieren sollte kein Problem sein. Eine zusätzliche Klemme/Kabel mehr... mal schauen. Wobei aber nicht jedes Moped einen Killschalter hat, oder dieser schon direkt an eine CDI/Ignitech angeschlossen ist.

Wenn irgendwie noch Platz auf der Platine ist, würde ich noch 2 Dioden und eine Klemme/Kabel für eine einzelne Bilinkerkontrollleuchte spendieren wollen.

[NyFAZ]

Hallo Jochen,

danke dass Du Dir die Zeit nimmst.

Das mit dem Leerlaufschalter ist in meinen Augen doch leicht gelöst:
Die Neutralleuchte in Reihe mit dem Seitenständer. Seitenständerkontakt unterbricht den Strom der Neutralleuchte.
Ohne Strom am Pin weiß die Elektronik: Nicht starten oder Moped aus. Ist doch in Serie bei vielen Mopeds so(?).

Kann man bei Deinem Layout noch über USB programmieren? Der Platz scheint zum Stecken etwas eng.
Dann könnte man sich den benötigten "Parametersatz" vorher konfigurieren und selber programmieren.
Die Abfrage Schalter/Taster wäre wichtig, da es bei Schaltern nur unpraktisch kurze und lange Tastendrücke gibt (Lichthupe z.B.).
Bei Tastern die Zeit für Komfortfunktionen verlängern (Blinker antasten 3x blinken).

Kabelpeitsche würde ich persönlich bevorzugen, benötige allerdings keine Steuerung mehr. CX als Bastelobjekt ist verkauft.

Lieben Gruß

Roland

[brummbaehr]

USB Anschluss ist eng, aber es geht noch.
Wobei ich das Layout ja noch grundlegend ändern werde.

Von deinem ursprünglichen Sketch ist nicht mehr viel übrig. Ich habe da einiges anders gelöst.
Das mit dem "Parametersatz" wird sicher noch spannend. Ist halt Neuland für mich.
Da werde ich sicher Unterstützung benötigen.

Wobei die Luxus Variante ein Tool wäre, bei dem man die Parameter selektiv anpassen kann und das Ganze dann im Arduino speichert.
Siehe: https://www.caferacer-forum.de/viewtopi ... 40#p348084

[Dacapo]

Hallo Roland!
Hallo Jochen!

Schön das es hier weiter geht.
Roland seine Schaltung funktioniert super.
Hatte sie testweise angeschlossen -
CB400n. Ich werde Sie in meine neuen Projekt verbauen.
Vorfreude ist groß!!!
Aber Projekt ist noch nicht hier...
Beste Grüße
Jens

[tilo14]

Hallo! Ist es möglich den Sketch mal zu testen? Oder ist es noch zu zeitig? Würde es gerne mal auf‘s Steckbrett setzen.
Gruß Tilo

[brummbaehr]

Den Sketch von Roland findest Du irgendwo vorne hier im Fred.

Hier mal mein aktueller Stand.
Alle Eingänge als Taster. Was noch fehlt ist die Sache mit dem Seitenständer.

Code: Alles auswählen

/*
Programmierung auf Arduino Nano, Pins gemäß Anordnung

Pin 01 D13  Ausgang Abblendlicht
Pin 04 A0   Ausgang Fernlicht
Pin 05 A1   Ausgang Bremslicht
Pin 06 A2   Ausgang Anlasser
Pin 07 A3   Eingang Killschalter
Pin 10 A6   Analog-Eingang Vin
Pin 15 Vin  Betriebsspannung Arduino (12V vom Zündschloss)
Pin 20 D2   Eingang Hupe
Pin 21 D3   Eingang Fernlicht
Pin 22 D4   Eingang Blinker Rechts
Pin 23 D5   Eingang Blinker Links
Pin 24 D6   Eingang Bremslichtschalter
Pin 25 D7   Eingang Seitenständer
Pin 26 D8   Eingang Starten
Pin 27 D9   Ausgang Zündung
Pin 28 D10  Ausgang Blinker Rechts
Pin 29 D11  Ausgang Blinker Links
Pin 30 D12  Ausgang Hupe

Wenn Killschalter betätigt mindestens KILLTIME (3s) ausschalten
Fernlicht (Lichthupe) für die Zeit SHORTBEAMTIME (0,4s) einschalten
Abblendlicht einschalten wenn Batteriespannung > BATTERYVOLTAGE oder Fernlichttaster gedrückt
Abblendlicht ausschalten wenn Fernlichttaster > LIGHTOFFPRESSTIME (2s) betätigt
...
*/
#include <Bounce2.h>

#define BUTTONLEFT  5 // digitaler Eingang linker Taster
#define BUTTONRIGHT 4 // digitaler Eingang rechter Taster
#define BUTTONLIGHT 3 // digitaler Eingang Fernlichttaster
#define BUTTONWARN 2 // digitaler Eingang Hupentaster
#define BUTTONSTART 8 // digitaler Eingang Motor an
#define BUTTONBRAKE 6 // digitaler Eingang Bremse
#define BUTTONSIDESTAND 7 // digitaler Eingang Seitenständer/Neutral
#define BUTTONKILL A3 // digitaler Eingang Killschalter
#define BATTERY A6 // analoger Eingang Batterie

#define BLINKPINRIGHT 10 // digitaler Ausgang rechter Blinker
#define BLINKPINLEFT 11 // digitaler Ausgang linker Blinker
#define LIGHTPIN A0 // digitaler Ausgang Fernlicht
#define WARNPIN 12 // digitaler Ausgang Hupe
#define STARTPIN A2 // digitaler Ausgang Anlasser
#define ABLIGHTPIN 13 // digitaler Ausgang Abblendlicht
#define BRAKELIGHTPIN A1 // digitaler Ausgang Bremslicht
#define IGNITIONPIN 9 // digitaler Ausgang Zündung

#define DEBOUNCETIME 10 // Zeit zum Entprellen in Millisekunden
#define LONGKEYPRESSTIME 250 // Zeit ab der ein Tastendruck "lang" ist
#define BLINKDELAY 500 // Blinkintervall
#define BLINKCOUNT 3 // Anzahl der Blinkimpulse bei kurzem Tastendruck
#define SHORTBEAMTIME 400 // Zeitdauer der Lichthupe in ms
#define KILLTIME 3000 // Mindest Zeitdauer Zündung ausschalten bei Killschalterbetätigung in ms
#define BATTERYVOLTAGE 13.0 // Mindestspannung der Batterie zum Abblandlicht einschalten
#define LIGHTOFFPRESSTIME 2000 // Zeitdauer Tastendruck um Licht aus zu schalten


Bounce Bleft = Bounce();
Bounce Bright = Bounce();
Bounce Blight = Bounce();
Bounce Bwarn = Bounce();
Bounce Bstart = Bounce();
Bounce Bbrake = Bounce();
Bounce Bsidestand = Bounce();
Bounce Bkill = Bounce();

byte Fernlicht=false;
byte Starter=false;
byte Lichtan=false;
byte Lichtaus=false;
float Voltage=0;



void setup()
{
//Serial.begin(9600); 

// Eingänge
Bleft.attach(BUTTONLEFT, INPUT_PULLUP);
Bleft.interval(20);
Bright.attach(BUTTONRIGHT, INPUT_PULLUP);
Bright.interval(20);
Blight.attach(BUTTONLIGHT, INPUT_PULLUP);
Blight.interval(20);
Bwarn.attach(BUTTONWARN, INPUT_PULLUP);
Bwarn.interval(100);
Bstart.attach(BUTTONSTART, INPUT_PULLUP);
Bstart.interval(100);
Bsidestand.attach(BUTTONSIDESTAND, INPUT_PULLUP);
Bsidestand.interval(100);
Bbrake.attach(BUTTONBRAKE, INPUT_PULLUP);
Bbrake.interval(10);
Bkill.attach(BUTTONKILL, INPUT_PULLUP);
Bkill.interval(100);
pinMode(BATTERY, INPUT); //Analoger Eingang

// Ausgänge
pinMode(BLINKPINLEFT, OUTPUT);
pinMode(BLINKPINRIGHT, OUTPUT);
pinMode(LIGHTPIN, OUTPUT);
pinMode(WARNPIN, OUTPUT);
pinMode(STARTPIN, OUTPUT);
pinMode(BRAKELIGHTPIN, OUTPUT);
pinMode(ABLIGHTPIN, OUTPUT);
pinMode(IGNITIONPIN, OUTPUT);
}

void loop()
{
Zuendung();
Blinker();
readbattery();
Licht();
Starten();
//Serial.println(blinkPhase);

//********** Hupe ***********
Bwarn.update();
digitalWrite(WARNPIN,!Bwarn.read());  //Hupentaster wird betätigt

// **** Bremslicht einschalten ****
Bbrake.update();
digitalWrite(BRAKELIGHTPIN,!Bbrake.read());
}

//***** Batteriespannung *****
void readbattery()
{
  int sensorValue = analogRead(BATTERY);
  float voltage = sensorValue * (5.0 / 120.0);
  if (voltage > BATTERYVOLTAGE && !Lichtaus)
  Lichtan = true; // Abblendlicht einschalten wenn Batterie über 13V --> Motor läuft
  //Serial.println(voltage);
}

//***** Blinker *****
void Blinker()
{
static byte blinkstate=0; // Blinkstatus in den untersten 2 Bits
static unsigned long startBlinkMillis=0; // Zeitpunkt beim Setzen des Blinkers
static byte shortButtonPress=false; // Wird true sobald ein kurzer Tastendruck erkannt wurde
static byte longBeamPress=false; // Wird true sobald ein langer Tastendruck erkannt wurde
static boolean blinkPhase=false;
static boolean currentOn=false;

Bleft.update();
Bright.update();
  
//********* Blinker links *************  
if (Bleft.fell())        //Blinker links wurde soeben gedrückt
{
  startBlinkMillis=millis();
  if (blinkstate==0b00) // Wenn Blinkstatus "AUS"
  blinkstate=0b10; // Blinker Links setzen
  else
  blinkstate=0b00; // Blinker ausschalten
  shortButtonPress=false; // Flag für kurzen Tastendruck löschen
}

//********** Blinker rechts ***********
if (Bright.fell())      //Blinker rechts wurde soeben gedrückt
{
  startBlinkMillis=millis();
  if (blinkstate==0b00) // Wenn Blinkstatus "AUS"
  blinkstate=0b01; // Blinker Rechts setzen
  else
  blinkstate=0b00; // Blinker ausschalten
  shortButtonPress=false; // Flag für kurzen Tastendruck löschen
}
// Sonderfall Warnblinker wenn Links/Rechts zeitgleich gedrückt
if (!Bleft.read() && !Bright.read())
if ((millis()- startBlinkMillis) > LIGHTOFFPRESSTIME)
blinkstate=0b11;

// Sonderfall kurzer Tastendruck beim Links- oder Rechtsblinken
if ((Bright.read() && millis()-startBlinkMillis<LONGKEYPRESSTIME && blinkstate==0b01) || (Bleft.read() && millis()-startBlinkMillis<LONGKEYPRESSTIME && blinkstate==0b10))
shortButtonPress=true;

// Prüfen, ob nach Einschalten mit kurzem Buttondruck die Blinkdauer abgelaufen ist
if (shortButtonPress && (millis()-startBlinkMillis)>=(BLINKCOUNT*2-1)*BLINKDELAY && (blinkstate==0b01 || blinkstate==0b10))
blinkstate=0b00; // falls ja, Blinken hier automatisch beenden

if (((millis()-startBlinkMillis)/BLINKDELAY)%2==0)
blinkPhase=true;
else
blinkPhase=false;

// Soll der linke Blinker gerade an sein?
currentOn=bitRead(blinkstate,1) && blinkPhase;
if (digitalRead(BLINKPINLEFT)!=currentOn)
digitalWrite(BLINKPINLEFT,currentOn);

// Soll der rechte Blinker gerade an sein?
currentOn=bitRead(blinkstate,0) && blinkPhase;
if (digitalRead(BLINKPINRIGHT)!=currentOn)
digitalWrite( BLINKPINRIGHT,currentOn);

}

//***** Licht *****
void Licht()
{
 Blight.update();
static byte shortBeamPress=false; // Wird true sobald ein kurzer Tastendruck erkannt wurde
static unsigned long startBeamMillis=0; // Zeitpunkt beim Tasten des Fernlichts
  
if (Starter!=true)
{
  if (Fernlicht==true)
  {
    digitalWrite(ABLIGHTPIN, shortBeamPress); // Bei Lichthupe bleibt das Abblendlicht eingeschaltet
    Lichtan = true; // Bei Zündung an, aber Motor AUS (Batteriespannung <13V) das Licht einschalten wenn Fernlichttaster betätigt
  }
  if (Fernlicht!=true)
  digitalWrite(ABLIGHTPIN, Lichtan && !Lichtaus);

  if ((digitalRead(LIGHTPIN)!=HIGH) && (Fernlicht==true))
  digitalWrite(LIGHTPIN,HIGH);

  if ((digitalRead(LIGHTPIN)==HIGH) && (Fernlicht==false))
  digitalWrite(LIGHTPIN,LOW);
}

//********** Fernlicht ***********
if (Blight.fell())        //Fernlichttaster wurde soeben gedrückt
  {
    if (Fernlicht)            //Wenn Fernlichtflag aktiv, wieder ausschalten
    Fernlicht=false;
    else
      {
      Fernlicht=!Lichtaus;      //Wenn Fernlichtflag nicht aktiv, dann Fernlicht einschalten wenn Licht nicht ausgeschaltet ist
      }
    startBeamMillis=millis();
    shortBeamPress=false; // Flag für kurzen Tastendruck löschen
  }
  
// Sonderfall kurzer Tastendruck Fernlicht
if (Blight.read() && millis()-startBeamMillis<LONGKEYPRESSTIME && Fernlicht==true)
   shortBeamPress=true;

// Sonderfall langer Tastendruck Fernlicht --> Licht ausschalten
if (!Blight.read() && millis()-startBeamMillis>LIGHTOFFPRESSTIME )
  {
    Lichtaus=true;
    Fernlicht=false;
  }

// Licht wieder einschalten wenn Fernlichtschalter wieder betätigt
if (Lichtaus==true && Blight.fell())
   Lichtaus=false;

// Lichthupe 
if (shortBeamPress && millis()-startBeamMillis>SHORTBEAMTIME && Fernlicht==true)
  {
   Fernlicht=false;
   shortBeamPress=false;
  }
}

//***** Zündung *****
void Zuendung()
{
  unsigned long startKillMillis = KILLTIME; //Zeitpunkt beim Tasten des Killschalters
  Bsidestand.update();
  Bkill.update();
// **** Killschalter ****
if (!Bkill.read())              // Killschalter in Stellung OFF
  {                    
    if (digitalRead(IGNITIONPIN))
       startKillMillis = millis();
    digitalWrite(IGNITIONPIN,LOW);            //Zündung ausschalten
  }
if (Bkill.read())               //Killschalter wieder in Stellung ON
  {                     
    if (millis()-startKillMillis >= KILLTIME) //Zündung mindestens für KILLTIME ausgeschaltet?
       digitalWrite(IGNITIONPIN,HIGH);        //Zündung wieder einschalten
  }
  
// **** Seitenständer ****
if (!Bsidestand.read())      // Seitenständer ausgeklappt
//digitalWrite(IGNITIONPIN,LOW); //Zündung ausschalten
;
if (Bsidestand.read())      // Seitenständer eingeklappt
//digitalWrite(IGNITIONPIN,HIGH); //Zündung einschalten
;
}

// **** Anlasserrelais ****
void Starten()
{
  Bstart.update();
  if (!Bstart.read())      //Starttaster betätigt
     if (digitalRead(IGNITIONPIN))      //Nur wenn Zündung auch eingeschaltet
      {
        digitalWrite(ABLIGHTPIN, LOW);  //Abblendlicht ausschalten
        digitalWrite(LIGHTPIN, LOW);    //Fernlicht ausschalten
        digitalWrite(STARTPIN,HIGH);    //Anlasser einschalten
        Starter=true;
      }
// Anlasserrelais ausschalten, unabhängig der anderen Zustände
if (Bstart.read()) 
  {
  digitalWrite(STARTPIN,LOW);
  Starter=false;
  }
}

[tilo14]

Danke, den alten kenn ich. Wollte den neuen mal probieren. Gut das du die Beschreibung ordentlich integriert hast.
Gruß Tilo

[NyFAZ]

Hallo Jochen,

dafür ein eigenständiges Programm zu schreiben kann ich übernehmen. Das von Dir verlinkte habe ich bestimmt schon wieder gelöscht. Das geht dann leider nur auf Windows, ich kann nicht Plattformübergreifend.

Über deinen Sketch fliege ich mal rüber wenn Zeit ist. Seitenständer braucht’s ja nur ne Abfrage auf einen boolschen Wert.
Bei Spannung am Pin Seitenständer den Wert auf True und gut.

LG Roland

[Knolli]

Hallo,

Ich finde fas hier sehr interessant und spannend.
Aber von dem was ihr hier schreibt verstehe ich nix.
Bin halt Metaller und kein Stromer.
Aber ich werde auf alle Fälle eine Steuerung kaufen wenn ihr so weit seit.
Respekt was ihr auf die Beine stellt.
Ich habe bei mir die Joost Box verbaut.

Gruß Michael

[brummbaehr]

Habe das Layaut mal neu gemacht.

Aktueller Stand wäre dann die (Taster)Eingänge über Schraubbare Printklemmen.
Die Ausgänge über Kabelpeitsche. Also eine Mischung aus beden.
Die Größe ist aktuell 55mm x 85mm


Was haltet ihr davon?
Hat jemand Vorschläge für ein passendes Gehäuse?
So in etwa