Dreh die Spannung mal höher auf 14-15V irgendwann sollte das Licht dann einschalten.
Anpassen kann man das ja unter.
Code: Alles auswählen
#define BATTERYVOLTAGE 13.0 // Mindestspannung der Batterie zum Abblendlicht einschaltenDas mit der Lichthupe sollte so nicht sein. Bei meinen Tests mit LED's ist mir das nicht aufgefallen.
Soweit ich das auf die schnelle erkenne, passt die Reihenfolge im Sketch nicht.
Hier mal ein geänderter Sketch. Wobei ich das nicht getestet habe!
Code: Alles auswählen
/*
* Sketch zu HW-Version 6 2019.12.18
Programmierung auf Arduino Nano, Pins gemäß Anordnung
Vin Betriebsspannung Arduino (12V vom Zündschloss)
D2 Eingang Blinker Links
D3 Eingang Blinker Rechts
D4 Eingang Fernlicht
D5 Eingang Hupe
D6 Eingang Starten
D7 Eingang Seitenständer
D8 Eingang Bremslichtschalter
D9 Eingang Killschalter
D10 Ausgang Blinker Links
D11 Ausgang Zündung
D12
D13
A0 Ausgang Bremslicht
A1 Ausgang Blinker Rechts
A2 Ausgang Hupe
A3 Ausgang Fernlicht
A4 Ausgang Anlasser
A5 Ausgang Abblendlicht
A6 Analog-Eingang Vin
A7
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 2 // digitaler Eingang linker Taster
#define BUTTONRIGHT 3 // digitaler Eingang rechter Taster
#define BUTTONLIGHT 4 // digitaler Eingang Fernlichttaster
#define BUTTONWARN 5 // digitaler Eingang Hupentaster
#define BUTTONSTART 6 // digitaler Eingang Motor an
#define BUTTONSIDESTAND 7 // digitaler Eingang Seitenständer/Neutral
#define BUTTONBRAKE 8 // digitaler Eingang Bremse
#define BUTTONKILL 9 // digitaler Eingang Killschalter
#define BATTERY A6 // analoger Eingang Batterie
#define BLINKPINRIGHT A1 // digitaler Ausgang rechter Blinker
#define BLINKPINLEFT 10 // digitaler Ausgang linker Blinker
#define LIGHTPIN A3 // digitaler Ausgang Fernlicht
#define WARNPIN A2 // digitaler Ausgang Hupe
#define STARTPIN A4 // digitaler Ausgang Anlasser
#define ABLIGHTPIN A5 // digitaler Ausgang Abblendlicht
#define BRAKELIGHTPIN A0 // digitaler Ausgang Bremslicht
#define IGNITIONPIN 11 // digitaler Ausgang Zündung
#define LONGKEYPRESSTIME 250 // Zeit ab der ein Tastendruck "lang" ist
#define BLINKDELAY 700 // Blinkintervall
#define BLINKCOUNT 3 // Anzahl der Blinkimpulse bei kurzem Tastendruck
#define SHORTBEAMTIME 500 // 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
#define Switch 0 // 0 --> Tastersteuerung, 1 --> Schalter
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(blinkstate);
//********** 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 int 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();
if (!Switch) // ********* Tastersteuerung ***********
{
//********* 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/2)
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
}
else // ********* Schaltersteuerung *********
{
if (!blinkstate)
startBlinkMillis=millis();
//********* Blinker links *************
if (!Bleft.read()) // Blinker links
blinkstate |= 0b10; // Blinker Links setzen
else
blinkstate &= 0b01; // Blinker Links ausschalten
//********** Blinker rechts ***********
if (!Bright.read()) // Blinker rechts
blinkstate |= 0b01; // Blinker Rechts setzen
else
blinkstate &= 0b10; // Blinker Rechts ausschalten
}
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 (!Switch) // ********* Tastersteuerung ***********
{
//********** 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=true; // Flag für kurzen Tastendruck setzen
}
// Wenn Tastendruck Fernlicht länger ist, Flag für kurzen Tastendruck löschen
if (!Blight.read() && millis()-startBeamMillis>LONGKEYPRESSTIME && Fernlicht==true)
shortBeamPress=false;
// 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;
}
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);
}
}
else // ********* Schaltersteuerung *********
{
if (!Blight.read()) //Fernlichtschalter betätigt
{
Fernlicht=true;
Lichtan=true; // Abblendlicht aktivieren wenn Fernlichtschalter betätigt um bei stehenden Motor das Abblendlicht einschalten zu können
}
else
Fernlicht=false;
if (Starter!=true) // Licht nur einschalten, wenn NICHT Starttaster betätigt
{
digitalWrite(ABLIGHTPIN,!Fernlicht && Lichtan);
digitalWrite(LIGHTPIN,Fernlicht);
}
}
}
//***** 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;
}
}
Trotzdem Danke
