//-------------Lichtanlage; Programm für den Bulli T2 und andere RC Fahrzeuge
//
// Werte Ausgelegt für Multiplex Flex und Arduino Pro Mini At-Mega 328 (5V, 16 MHz)
// Funktionen:
// -----------
// * Empfängereingang für Kanal 1 Lenkung, Zur Blinklichtabschaltungsüberwachung.
// * Empfängereingang für Kanal 2 Gas, für Bremslicht und Rückfahrscheinwerfer Betätigung
// * Empfängereingang für Kanal 4 Beleuchtungen, Zum Betätigen von Standlicht, Fahrlicht, Blinklicht, Warnblinklicht,
// Rundumlicht und Arbeitsscheinwerfern.
// * Blinklicht rechts - links mit Fahrhebel Kanal 4 nach rechts und links ein- und ausschaltbar. Tippfunktion unter 1 Sek. Dauer.
// * Blinklicht Seite bei eingeschaltetem Blinklicht wechselbar. Tippfunktion unter 1 Sek. Dauer.
// * Blinklicht nur durch Blinkerhebel oder Lenkungsrückstellung (wie beim original PKW) ausschaltbar.
// * Warnblinkanlage schaltet keine Blinkereinstellung ab. Der Blinkerstatus wird beim Einschalten
// der Warnblinkanlage gespeichert, und nach dem Ausschalten wiederhergestellt.
// * Warnblinkanlage mit Fahrhebel Kanal 4 mehr als 1,0 Sekunden nach links halten jeder Zeit einschaltbar.
// * Warnblinkanlage ausschalten durch erneutes 1,0 Sekunden langes Betätigen des Fahrhebels Kanal 4 nach links.
// * Standlicht als Kombination in einer LED mit dem Fahrlicht oder als eigene LED mit dem Rücklicht anschließbar.
// * Stand- und Rücklicht mit Fahrhebel Kanal 4 mehr als 1,0 Sekunden nach rechts halten jeder Zeit einschaltbar.
// * Fahr- und Rücklicht mit Fahrhebel Kanal 4 mehr als 2,0 Sekunden nach rechts halten jeder Zeit einschaltbar.
// * Fahrlicht ausschalten durch erneutes 1,0 oder 2,0 Sekunden langes Betätigen des Fahrhebels Kanal 4 nach rechts. Standlicht wird eingeschaltet.
// * Stand- und Rücklicht ausschalten durch erneutes 1,0 Sekunden langes Betätigen des Fahrhebels Kanal 4 nach rechts.
// * Realistischer Rückfahrscheinwerfer. Der Rückfahrscheinwerfer geht an sobald der Gas Hebel (Kanal 2) auf Rückwärtsfahrt gezogen wird.
// * Der Rückfahrscheinwerfer geht erst dann wieder aus, wenn der Gashebel in Stellung Vorwärtsfahrt bewegt wird,
// oder mehr als 7 Sekunden in Neutralstellung steht.
// * Bremslicht sowohl als separate LED für das Bremslicht als auch mit einer LED in Kombination mit dem Rücklicht anschließbar.
// * Alle Bremslichtfunktionen funktionieren sowohl bei Vor- als auch bei Rückwärtsfahrt.
// Das Bremslicht wird eingeschaltet, wenn innerhalb einer festgelegten kurzen Zeit ein bestimmter Wert an Gas schnell zurückgenommen wird.
// (Ruckartiges Gas weg nehmen)
// Langsames Gas weg nehmen betätigt dagegen kein Bremslicht.
// Zittern mit dem Gashebel in einer Fahrstellung oder kurze Impulsschwankungen die zu Bremslichtfunktionen führen werden unterdrückt.
// Führt ruckartiges Gas weg nehmen zu einer Bremslichtfunktion bleibt das Bremslicht mindestens 200 Millisekunden an,
// um zu einem sichtbaren Effekt zu führen.
// Erreicht der Gashebel die Neutralstellung wird immer das Bremslicht eingeschaltet. Es sei denn, man nimmt extrem langsam das Gas weg
// (Ausrollfunktion). Wenn der Gashebel 5 Sekunden in Neutralstellung steht, wird das Bremslicht wieder abgeschaltet.
// Wird Der Gasknüppel aus der Neutralstellung in eine Fahrtstellung gebracht wird das Bremslicht sofort wieder ausgeschaltet.
// * Arbeitsscheinwerfer durch mit Fahrhebel Kanal 4 mehr als 3 Sekunden nach rechts halten jeder Zeit einschaltbar.
// * Arbeitsscheinwerfer durch mit Fahrhebel Kanal 4 mehr als 3 Sekunden nach rechts halten jeder Zeit ausschaltbar.
// * Rundumlicht oder andere Funktion mit Fahrhebel Kanal 4 mehr als 2 Sekunden nach links halten jeder Zeit einschaltbar.
// * Rundumlicht oder andere Funktion ausschalten durch erneutes 2 Sekunden langes Betätigen des Fahrhebels Kanal 4 nach links.
// * Automatisches Einschalten von Rundumlicht und Arbeitsscheinwerfer durch andere Modellfunktionen. Schalteingang -5 Volt.
//---------------------------------------------------------------------------------------------------------------------------------
// Betriebs- und Anschlusshinweise
//---------------------------------------------------------------------------------------------------------------------------------
// * Die Lichtplatine wird mit 5 Volt Versorgungsspannung betrieben und der Minuspol muss mit dem Minuspol des Akkus verbunden sein!
// * der maximale Ausgangsstrom je Ausgang beträgt 40 mA !!!!
// * Scheinwerfer-LED werden in Reihe geschaltet und müssen mit passenden Vorwiderständen Zur Akkuspannung versehen werden.
// * Standlicht-LED vorne werden in Reihe geschaltet und müssen mit passenden Vorwiderständen Zur Akkuspannung versehen werden.
// * Alle Licht-LED brauchen den passenden Vorwiderstand für 20 mA (volle Helligkeit)
// Die Helligkeit von Stand- und Rücklicht werden über PWM-Signal gesteuert.
// * Die Blinklicht-LED können durch höhere Widerstandswerte in der Helligkeit angepasst werden.
// * Die Blinklicht-LED sollten vordere und hintere in Reihe geschaltet werden. So ergibt sich je Blinkerseite ein Strom von 20 mA.
// Und so ist es möglich auch noch einen Anhänger mit Blinklichtstrom zu versorgen.
// * Die kombinierten Rück- und Bremslichter werden ebenfalls in Reihe geschaltet.
// * Separate Rücklichter (in Reihe geschaltet) lassen sich mit dem Standlichtausgang zusammenschalten.
// Allerdings steht dann kein Ausgang mehr für Anhängerrücklicht zur Verfügung.
// Soll ein Anhänger angeschlossen werden, ist es sinnvoll sowohl Anhänger als auch Zugfahrzeug mit kombiniertem Rück- und Bremslicht zu versehen.
//---------------------------------------------------------------------------------------------------------------------------------
// Anschluss Belegungen
//---------------------------------------------------------------------------------------------------------------------------------
// * Pin 2 Eingang wo das Empfängersignal eingelesen wird! Für RC-Kanal 2 Interrupt (Gas)
// * Pin 3 Eingang wo das Empfängersignal eingelesen wird! Für RC-Kanal 4 Interrupt (Licht)
// * Pin 4 Ausgang für Rückfahrscheinwerfer (max.40 mA)
// * Pin 5 Ausgang für Bremslicht und Rücklicht mit PWM (max.40 mA)
// * Pin 6 Ausgang für Fahrlicht (max.40 mA)
// * Pin 7 Eingang für externe RKL-Einschaltung (max.40 mA)
// * Pin 8 Eingang Lenkkanal-Impulse (pulseIn)
// * Pin 9 Ausgang für Licht (max.40 mA)
// * Pin 10 Ausgang Blinker links (max.40 mA)
// * Pin 11 Ausgang Blinker rechts (max.40 mA)
// * Pin 12 Ausgang Rundumkennleuchte bei Bedarf oder andere Funktion (max.40 mA)
// * Pin 13 Ausgang für Arbeitsscheinwerfer (max.40 mA) und Arduino-interne LED
//---------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------
// Variablen für den Interrupt bei Gasknüppelbetätigung
//---------------------------------------------------------------------------------------------------------------------------------
//---------------------------- Die letzten 8 Werte werden gespeichert um einen Mittelwert zu bilden
volatile uint16_t EmpfaengerKanal2Wert[8] = {1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500};
volatile uint16_t EmpfaengerKanal2WertSum = 12000; // Die Summe der letzten 8 Werte
volatile uint8_t EmpfaengerKanal2WertIndex = 0; // Der Index des nächsten auszutauschenden Wertes
volatile uint32_t LetzterEmpfaengerWert = micros(); // Letzter Zeitpunkt des Signalwechsels
volatile uint16_t AktuellerEmpfaengerWert = 1500; // Der aktuell als letztes ermittelte Wert
volatile uint8_t LetzterInterruptStatus = PIND; // Interruptstatus des Port D
//------------------------------------------------------------------------------------------------------------------------------------
volatile int RcInValue; // Eingelesener Wert der immer aus dem RAM kommt (w.g. volatile)
volatile int ReceivedLightValues[8] = {1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500}; // Array mit 8 Werten für die gemessenen Werte
volatile int Summe = 12000; // Summe aus dem Array 8x1500, als Anfangswert
volatile int Mittelwert_K4 = 1500; // Mittelwert aus der Summe für RC-Kanal 4
volatile int Zeiger = 0; // Zeiger für das Array, fängt mit 0 an
volatile uint32_t LastLightChange = micros();
//
// Die Interrupt Routine wird bei jedem Signalwechsel zwischen HIGH und LOW aufgerufen
// Die Routine berücksichtigt die HIGH Level und errechnet aus den letzten 8 HIGH Level Werten einen Mittelwert
// Dies glättet mögliche Ausreißer und beseitigt kleinere Schwankungen.
//
//-------------- Pinbelegung - Constante Variablen Deklaration ----------------------------------------
//
const byte pw = 2; // das ist Interrupt 0 aber Pin 2 wo das Empfängersignal eingelesen wird! Für RC-Kanal 2 (Gas)
const byte PIN_RC = 3; // das ist Interrupt 1 aber Pin 3 wo das Empfängersignal eingelesen wird! Für RC-Kanal 4 (Licht)
const byte rfsch = 4; // Pin für Rückfahrscheinwerfer
const byte brakelight = 5; // Pin für Bremslicht und Rücklicht mit PWM
const byte headlight = 6; // Pin für Fahrlicht
const byte light = 9; // Pin für Licht
const byte lenk_in = 8; // Eingang Lenkkanal-Impulse
const byte RKL_in = 7; // Eingang für externe RKL-Einschaltung
const byte bl = 10; // Pin Blinker links
const byte br = 11; // Pin Blinker rechts
const byte rkl = 12; // Pin RKL bei Bedarf oder andere Funktion
const byte al = 13; // interne LED und Ausgang für Arbeitsscheinwerfer
//
//------------- Einstellbare Werte - Constante Variablen Deklaration ---------------------------------------
const byte light_pwm = 240; // PWM-Wert für Standlicht (hier einstellbar)
const byte Aus = 0; // Zustand Aus auf 0 setzen
const byte gastoleranz = 20; // Toleranz für die Knüppelbewegung, bis Bremslichtvorgang eingeleitet wird. (milliseconds)(hier einstellbar)
const byte brakecounter_max = 3; // Maximaler Inhalt des Fehlerzählers. (X mal) (hier einstellbar)
const long brakelighttime = 5000; // Zeit wie lange das Bremslicht nach Fahrzeugstillstand noch leuchtet. (milliseconds) (hier einstellbar)
const long brakelighttime_min = 200; // Zeit wie lange das Bremslicht bei Betätigung mindestens leuchtet. (milliseconds) (hier einstellbar)
const long rfsch_ontime = 7000; // Zeit wie lange der Rückfahrscheinwerfer nach Fahrzeugstillstand noch leuchtet. (milliseconds) (hier einstellbar)
const long Zeit_1 = 1000; // Überwachte kurze Zeit für Knüppeleinschlag in Millisekunden (hier einstellbar)
const long Zeit_2 = 2000; // Überwachte lange Zeit für Knüppeleinschlag in Millisekunden (hier einstellbar)
const long Zeit_3 = 3000; // Überwachte lange Zeit für Knüppeleinschlag in Millisekunden (hier einstellbar)
const long retourbeginn = 1600; // Knüppelbewegungsweg Kanal 2 ab wann Rückfahrscheinwerfer eingeschaltet wird. (hier einstellbar)
//
//-------------- Byte Variablen Deklaration -----------------------------------
byte vb = 75; // Variable für gemappte Impulse Wert = Mittelstellung Blinker
byte vw = 75; // Variable für gemappte Impulse Wert = Mittelstellung Warnblinker
byte re_li = 0; // Flag Blinker rechts(Wert 01)_links(Wert 10)Warnblinker(Wert 11)
byte ledState = LOW; // Blinker Startstatus auf aus setzen
byte bron = 0; // Blinker rechts ein (Wert 1 bei an - 0 bei aus)
byte brof = 0; // Blinker rechts aus (Wert 1 bei an - 0 bei aus)
byte brofok = 0; // Blinker rechts aus (Wert 1 bestätigt - 0 bei unbestätigt)
byte blon = 0; // Blinker links ein (Wert 1 bei an - 0 bei aus)
byte blof = 0; // Blinker links aus (Wert 1 bei an - 0 bei aus)
byte blofok = 0; // Blinker links aus (Wert 1 bestätigt - 0 bei unbestätigt)
byte wbon = 0; // Warnblinker ein
byte rklon = 0; // RKL ein (Rundum-KennLeuchte)
byte rklof = 0; // RKL aus (Rundum-KennLeuchte)
byte alon = 0; // Arbeitscheinwerfer ein
byte alof = 0; // Arbeitscheinwerfer aus
byte headlight_on = 0; // Scheinwerfer ein
byte headlight_of = 0; // Scheinwerfer aus
byte light_on = 0; // Standlicht / Rücklicht ein
byte light_of = 0; // Standlicht / Rücklicht aus
byte reliSave = 00; // Speicher für Blinklicht Status
byte schalterRechts = 0; // Flag für Blinkerhebelstellung nach rechts
byte schalterLinks = 0; // Flag für Blinkerhebelstellung nach links
byte sentido = 0; // betätigte Richtung für linken Kreuzknüppel. 1=rechts; 2=links; 3=vorne; 4=hinten
byte rfsch_on = 0; // Rückfahrscheinwerfer (Wert 1 bei an - 0 bei aus)
byte vwf = 0; // Flag für Vorwärtsfahrt
byte brakelight_on = 0; // Flag steht auf "1" wenn Bremslicht leuchtet.
//
//-------------- int Variablen deklaration ----------------------------------------------------------------------------------
int akt_richtung = 0; // Flag für aktuelle Knüppelrichtung: 0 Stand; 1 = Vorwärts; 2 = Rückwärts
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Der Wert von "akt_richtung" bezieht sich nicht auf die Fahrtrichtung, //
// sondern die Richtung der Knüppelbewegung. //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int mem_duration = 0; // Speicher für Empfängerwert Gas
int brakecounter = 0; // Zähler zur Überwachung der Bremsimpulse
int brakelightdaueraus = 0; // Flag ob Bremslicht nach mehr als 5 Sec. Stillstand aus bleiben soll . "1" = ja.
int RKLE = HIGH; // Flag RKL-Eingangszustand
//
//-----------------long Variablen Deklaration -------------------------------------------------------------------------------
long time = 0;
//---------------- unsigned long Variablen Deklaration ---------------------------------------------------------------------
unsigned long aktTime = 0; // reset Speicher für aktuelle Zeit
unsigned long countMillis = 0; // reset Zeitzähler
unsigned long int interval = 700; // Zeit für langes halten des Steuerknüppels nach rechts oder links (hier einstellbar)
unsigned long int blinterval = 600; // Blinkintervall (hier einstellbar)
unsigned long currentMillis = 0; // aktuell gültige Zeit
unsigned long currentbrakeMillis = 0; // aktuell gültige Zeit
unsigned long currentrfschMillis = 0; // aktuell gültige Zeit
unsigned long previousbrakeMillis = 0; // will store last time
unsigned long previousrfschMillis = 0; // will store last time
unsigned long previousMillis = 0; // zuletzt gespeicherte Zeit
unsigned long lenk; // Lenkeinschlagauswertung vom Empfänger
unsigned long dw; // zur Zeit nicht benutzt Pulse in Kanal 4 Futaba Warnlicht - RKL
unsigned long timeStart = 0; // Zeit bei Beginn einer Knüppelbewegung
unsigned long timeStop = 0; // Zeit bei Ende einer Knüppelbewegung
unsigned long timeBegin = 0; // Zeitbeginn in der Zeitkontrolle
unsigned long duration; // Variabele für den vom Interrupt eingelesenen Impuls des Empfängers
//
//
void setup()
{
PCICR |= (1 << PCIE2); // Interrupt Port D aktivieren
PCMSK2 |= (1 << PCINT18); // Interrupts für Pins 2 aktivieren
sei();
attachInterrupt( 1, LightPositionInterrupt, CHANGE);
//---------------------------------------------------------------------------------------------------------------
pinMode(pw, INPUT); // Pin 2 Input für Interrupt RC-Empfängersignal Kanal 2 (Gas)
digitalWrite(pw, HIGH); // hier wird der interne Pull-up Widerstand an Pin 2 eingeschaltet
pinMode(PIN_RC, INPUT); // Pin 3 Input für Interrupt RC-Empfängersignal Kanal 4 (Licht)
digitalWrite(PIN_RC, HIGH); // hier wird der interne Pull-up Widerstand an Pin 3 eingeschaltet
pinMode(rfsch, OUTPUT); // Pin 4 Output für Rückfahrscheinwerfer
pinMode(brakelight, OUTPUT); // Pin 5 Output für Bremslicht
pinMode(headlight, OUTPUT); // Pin 6 Output für Fahrlicht
pinMode(light, OUTPUT); // Pin 9 Output für Standlicht
pinMode(lenk_in, INPUT); // Pin 8 zur Zeit unbenutzt
digitalWrite(lenk_in, HIGH); // hier wird der interne Pull-up Widerstand an Pin 8 eingeschaltet
pinMode(RKL_in, INPUT); // Pin 7 externer Einschalteingang für die Rundumkennleuchte
digitalWrite(RKL_in, HIGH); // hier wird der interne Pull-up Widerstand an Pin 7 eingeschaltet
pinMode(bl, OUTPUT); // Pin 10 Output für Blinklicht links
pinMode(br, OUTPUT); // Pin 11 Output für Blinklicht rechts
pinMode(rkl, OUTPUT); // Pin 12 Output für Rundumkennleuchten
pinMode (al, OUTPUT); // Pin 13 Output für interne LED und Arbeitsscheinwerfer
//---------------------------------------------------------------------------------------------------------------
// Serial.begin(57600); // Einschaltung des seriellen Monitors Zur Programmkontrolle
delay(1500); // Wartezeit auf Empfänger Initialisierung
digitalWrite(light, LOW); // Standlicht im Setup einschalten
digitalWrite(headlight, LOW); // Scheinwerfer im Setup einschalten
digitalWrite(al, LOW); // interne LED ausschalten (aktiv HIGH)
digitalWrite(rkl, LOW); // Rundumkennleuchte im Setup einschalten
digitalWrite(br, LOW); // Blinklicht rechts im Setup einschalten
digitalWrite(bl, LOW); // Blinklicht links im Setup einschalten
digitalWrite(rfsch, LOW); // Rückfahrscheinwerfer im Setup einschalten
digitalWrite(brakelight, LOW); // Bremsleuchten im Setup einschalten
delay(1000); // Eine Sekunde Wartezeit im Setup zur Lampenkontrolle
digitalWrite(light, HIGH); // Standlicht nach dem Setup ausschalten
digitalWrite(headlight, HIGH); // Scheinwerfer nach dem Setup ausschalten
digitalWrite(br, HIGH); // Blinklicht rechts nach dem Setup ausschalten
digitalWrite(bl, HIGH); // Blinklicht links nach dem Setup ausschalten
digitalWrite(rfsch, HIGH); // Rückfahrscheinwerfer nach dem Setup ausschalten
digitalWrite(brakelight, HIGH); // Bremsleuchten nach dem Setup ausschalten
digitalWrite(rkl, HIGH); // Rundumkennleuchte nach dem Setup ausschalten
}
//---------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------
// Interrupt
//---------------------------------------------------------------------------------------------------------------
ISR(PCINT2_vect)
{
uint8_t PinStatus = PIND; // Aktuellen Status der Interrupts lesen
uint8_t PinSignalWechsel = PinStatus ^ LetzterInterruptStatus; // Mit vorherigem Wert verknüpfen
// // Das Ergebnis ist eine Bitliste der ausgelösten Interrupts
if (PinSignalWechsel & (1 << PCINT18)) // Ist das Bit für Pin 2 gesetzt?
Interuppt_Kanal2(); // Ja -> Interrupt auswerten
LetzterInterruptStatus = PinStatus; // Alte Bitmaske merken
}
//---------------------------------------------------------------------------------------------------------------
// Interrupt Ende
//---------------------------------------------------------------------------------------------------------------
void loop() // Programmschleife
{
//---------------------------------------------------------------------------------------------------------------
rkltest(); // Prüfen ob RKL von extern eingeschaltet ist + eventuell RKL und Arbeitsscheinwerfer einschalten
//---------------------------------------------------------------------------------------------------------------
getlenkung(); // Knüppelstellung für Lenkung (Blinker aus) auslesen
//---------------------------------------------------------------------------------------------------------------
Blinkcontrol(); // Programmteil für die Feststellung ob Blinker abgeschaltet werden darf
//---------------------------------------------------------------------------------------------------------------
blinken(blinterval, re_li); // Im Flag re_li festgelegte Blinker Blinken lasen falls erforderlich
//---------------------------------------------------------------------------------------------------------------
lampen_schalten(); // Lampen schalten mit Übergabe von Lampentyp
//---------------------------------------------------------------------------------------------------------------
loop2(); // Programmteil zur Brems- und Rückfahrlichtsteuerung
//---------------------------------------------------------------------------------------------------------------
} // Ende der gesamten Programmschleife
//---------------------------------------------------------------------------------------------------------------
)
