// 2017: to do / Idee Uhrenfunktion, Std. gemäß OZ 1-24, Minuten OZ 1-59 als Herzblinker, z.B. 7:45 als N:Rh, volle Stunden mit 1 und 59, bei h = m Herzblinker links und rechts von h// - DeT-Pause// 15.07. www-Schaltaufruf mittels Port Forwarding// 14.07. Code säubern// 13.07. Bewegungsmelder, Standby neu// 12.07. Modi schaltbar// 11.07. Patchmodus gefixt// 10.07. const Variablenumbennung// 08.07. serieller Input in Unterprogramm, www gekürzt// 07.07. Fernbedienung mit Interrupt// 05.07. Fernbedienung, Serial.begin(115200);// 23.06. Reset nach Standby// 21.06. Weiterleitung i. O.// 18.06. Weiterleitung kaputt? Abgleich mit 08.06., dort funzts// 08.05.2015: Patch Panel fix// 06.05.2015: Patch Panel aktiviert aber irgendwie verschoben// 05.05.2015: Anpassung an Mega 2560 wg. Speicherproblemen beim Uno// 04.05.2015: rudimentäre Dimmfunktion// 03.05.2015: Ausbaustufe = 32, LED #0 gibt es nicht mehr, automatisches Abschalten nach 500 Leerzyklen// 02.05.2015: Aufruf auch von bs-wiki möglich// 01.05.2015: Schalten über HTTP GET// 29.04.2015: Arduino als HTTP-Client

// ----------------------------------------------------------------------// globale Variablen:// KONSTANTEN// Pinning Arduino:// Arduino-Pin 2 mit IR-Sensor verbunden:const byte IR_PIN = 2;// Arduino-Pin 3 als "Dimmer" verbunden mit OE des 74HC595 (dort Pin 13, Output Enable):const byte OUTPUT_ENABLE_PIN = 3;// Arduino-Pin 7 mit Bewegungsmelder verbunden (dort Pin 2, Out):const byte BEWEGUNGSMELDER_PIN = 7;// Arduino-Pin 8 als SHIFT_PIN verbunden mit SH_CP des 74HC595 (dort Pin 11, shift register clock input):const byte SHIFT_PIN = 8;// Arduino-Pin 9 verbunden mit ST_CP des 74HC595 (dort Pin 12, storage register clock input = latch pin):const byte STORE_PIN = 9;// Arduino-Pin 10 verbunden mit DS des 74HC595 (dort Pin 14, serial data input):const byte DATA_PIN = 10;// ----------------------------------------------------------------------// Internet:byte mac[6] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //physical physikalische mac address-Adresse// TO DO: vor Ort anzupassen:byte ip[4] = { 192, 168, 178, 104 }; // ip in lan IP im **lokalen** Netzwerk// Aufruf dann im Browser z. B. über http://192.168.178.104/?z=4// "Arduino an IP 192..., schalte Led Nr. 4 an!"// Falls ein "echter", also **globaler** www-Aufruf ermöglicht werden soll, muss im Router eine Portweiterleitung eingerichtet werden.// Bei meiner Fritzbox 7270 (that's what you need to use in your browserRouter-IP ist 31. ("19.122.16) über Internet:Freigaben:Portfreigabe mit den Einstellungen:// andere Anwendungen, TCP, Port 80, an IP-Adresse 192.168.178.104. Die lokale IP hier im Sketch bleibt unverändert,// allerdings kann dann der Schaltaufruf ebenso mit "http://31.19.122.16/?z=4")erfolgen.byte gateway[4] = { 192, 168, 1, 1 }; // internet access Internetaccess via routerRouterbyte subnet[4] = { 255, 255, 255, 0 }; //subnet maskEthernetServer server(80); //server Server port

 // globale VariablenString URL = "http:// Arduinowww.bs-Pin verbunden mit SH_CP des 74HC595byte shiftPin wiki.de/mediawiki/index.php?title= 8";// Arduino-Pin verbunden mit ST_CP des 74HC595---------------------------------------------------------------------// LED-Wand:byte storePin // Hardware-Info: 12m²-PSE aus 6 Teildisplays, 144/6 = 9;24 LEDs/Teildisplay,// ... jedes Teildisplay angesteuert durch 3x8 Datenleitungen (3 Spalten, 8 Zeilen),// Arduino... pro Spalte ein 8-bit-Pin verbunden mit DS des 74HC595byte dataPin Schieberegister = 10;18 SR insgesamt// Pinning Schieberegister:

// Ausbaustufe 144 LEDsconst byte Ausbaustufe = 144; // 144byte Anzahl_Legenden_LEDs = 0;byte Legende_anfang = 121;byte Legende_ende = 140;boolean Patchmodus;// Compilerfehler erforderdert Vergrößerung der Arrays um ein Feld, andernfalls Überlauf in andere Variablenboolean led[Ausbaustufe + 1] = {0};unsigned int led_aus[Ausbaustufe + 1];// virtuelles Patchpanel: Zuordnung Ordungszahl/Pin, z. B. Natrium mit OZ 11 an *Pin 3*:byte Pin_von_Element[Ausbaustufe + 1] = { 0, 1, 137 , 2, 9, 97, 105, 113, 121, 129, 138 , 3, 10, 98, 106, 114, 122, 130, 139 , 4, 11, 19, 27, 35, 43, 51, 59, 67, 75, 83, 91, 99, 107, 115, 123, 131, 140 , 5, 12, 20, 28, 36, 44, 52, 60, 68, 76, 84, 92, 100, 108, 116, 124, 132, 141 , 6, 13, 23, 31, 39, 47, 55, 63, 71, 79, 87, 95, 103, 111, 119, 127, 21, 29, 37, 45, 53, 61, 69, 77, 85, 93, 101, 109, 117, 125, 133, 142 , 7, 14, 24 ist die derzeitige Ausbaustufe, am Ende 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120 LEDs, 128, 22, 30, 38, 46, 54, 62, 70, 78, 86, 94, 102, 110, 118, 126, 134, 143, 15, 16, 17, 18, 25, 26, 33, 34, 41, 42, 49, 50, 57, 58, 65, 66, 73, 74, 81, 82, 89, 90, 135, 136, 144 , 8 };// Pinning ohne eine "Led #0"// p1 p2 p3 p4 p5 p6byte Element_an_Pin[Ausbaustufe + 1] = { 0, 1, 3, 11, 19, 37, 55 // //p7 p8 - p9 p10 p11 p12 p13 p14 p15 p16 -p17 p18 p19 p20 p21 p22 p23 p24- , 87, 144, 4, 12, 20, 38, 56, 88, 119, 120, 121, 122, 21, 39, 71, 103, 57, 89 // // p25 p26 p27 p28 p29 p30 p31 p32-p33 p34 p35 p36 p37 p38 p39 p40-p41 p42 p43 p44 p45 p46 p47 p48 , 123, 124, 22, 40, 72, 104, 58, 90, 125, 126, 23, 41, 73, 105, 59, 91, 127, 128, 24, 42, 74, 106, 60, 92 // // p49 p50 p51 p52 p53 p54 p55 p56-p57 p58 p59 p60 p61 p62 p63 p64-p65 p66 p67 p68 p69 p70 p71 p72 , 129, 130, 25, 43, 75, 107, 61, 93, 131, 132, 26, 44, 76, 108, 62, 94, 133, 134, 27, 45, 77, 109, 63, 95 // // p73 p74 p75 p76 p77 p78 p79 p80-p81 p82 p83 p84 p85 p86 p87 p88-p89 p90 p91 p92 p93 p94 p95 p96 , 135, 136, 28, 46, 78, 110, 64, 96, 137, 138, 29, 47, 79, 111, 65, 97, 139, 140, 30, 48, 80, 112, 66, 98 // // p97p98 p99 p100p101p102 p103p104-p105p106p107p108p109p110p111p112-p113p114p115p116p117p118p119p120 , 5, 13, 31, 49, 81, 113, 67, 99, 6, 14, 32, 50, 82, 114, 68, 100, 7, 15, 33, 51, 83, 115, 69, 101 // //p121p122p123p124p125p126p127p128-p129p130p131p132p133p134p135 p136-p137p138p139p140p141p142p143p144 , 8, 16, 34, 52, 84, 116, 70, 102, 9, 17, 35, 53, 85, 117, 141, 142, 2, 10, 18, 36, 54, 86, 118, 143 };// ----------------------------------------------------------------------// Auswahlim laufenden Programm:String Input; // IR, Seriell oder www

byte int Auswahl = 0;// 0 = Legende,// 1 = Wasserstoff, 2 = Helium ...// 131...137 = 1. - 7. Periode// 141...148 = 1. - 8. Hauptgruppe// 160 = Metalle// 170 = Halbmetalle// 180 = Nichtmetalle// 190 = fest// 191 = flüssig// 192 = gasförmig// 193 = radioaktiv// 194 = biatomar// 200 = Bingo// 201 = Programm_x// 202 = Programm_y// 203 = Programm_z // 254 = alles_aus// 255 = alles_an boolean led[145]neue_Auswahl;unsigned int led_aus[145];// virtuelles Patchpanel: Zuordnung Ordungszahl/Pin, z. B. Natrium mit OZ 11 an *Pin 3*:// Pinning - p1 p2*p3* p4 p5 p6 p7 p8-p9 p10 p11 p12 p13 p14 p15 p16 -p17 p18 p19 p20 p21 p22 p23 p24-p25 p26 p27 p28 p29 p30 p31 p32-p33 p34 p35 p36 p37 p38 p39 p40-p41 p42 p43 p44 p45 p46 p47 p48-p49 p50 p51 p52 p53 p54 p55 p56-p57 p58 p59 p60 p61 p62 p63 p64-p65 p66 p67 p68 p69 p70 p71 p72-p73 p74 p75 p76 p77 p78 p79 p80-p81 p82 p83 p84 p85 p86 p87 p88-p89 p90 p91 p92 p93 p94 p95 p96-p97p98 p99 p100p101p102 p103p104-p105p106p107p108p109p110p111p112-p113p114p115p116p117p118p119p120-p121p122p123p124p125p126p127p128-p129p130p131p132p133p134p135p136-p137p138p139p140p141p142p143p144const byte Element_an_Pin[145] boolean Bewegungsstatus = {0, 1, 3, 11, 19, 37, 55, 87, 0, 4, 12, 20, 38, 56, 88, 119, 120, 121, 122, 21, 39, 71, 103, 57, 89, 123, 124, 22, 40, 72, 104, 58, 90, 125, 126, 23, 41, 73, 105, 59, 91, 127, 128, 24, 42, 74, 106, 60, 92, 129, 130, 25, 43, 75, 107, 61, 93, 131, 132, 26, 44, 76, 108, 62, 94, 133, 134, 27, 45, 77, 109, 63, 95, 135, 136, 28, 46, 78, 110, 64, 96, 137, 138, 29, 47, 79, 111, 65, 97, 139, 140, 30, 48, 80, 112, 66, 98, 5, 13, 31, 49, 81, 113, 67, 99, 6, 14, 32, 50, 82, 114, 68, 100, 7, 15, 33, 51, 83, 115, 69, 101, 8, 16, 34, 52, 84, 116, 70, 102, 9, 17, 35, 53, 85, 117, 141, 142, 2, 10, 18, 36, 54, 86, 118, 143}HIGH;// Element_an_Pin[] nach steigender Ordungszahl notieren:// TO DO wg. Speicherproblemen vorerst aus:// byte patch[145];bei Systemstart Bewegung simulieren

unsigned int t_gesamt_in_sek = millis() / 1000;// TO DO: über Poti einstellenund von Pin einlesen oder über Auswahl (180)byte Eieruhr const unsigned int LED_Eieruhr_normal = 2030; // Vorgabe der Einschaltdauer einer LED in Sekundenunsigned int LED_Eieruhr = LED_Eieruhr_normal; // gewählte Einschaltdauer einer LED in Sekundenunsigned int Standby_Timer = 180; // Zeit in Sekunden bis zum Standbyconst byte Standardhelligkeit = 127;byte Helligkeit = Standardhelligkeit; // beliebiger Wert für Dimmerbyte Wunschhelligkeit = Standardhelligkeit; // durch Menüauswahl bestimmtbyte last_Element = 0;int zyklus = 0; // loop-Zyklenunsigned int last_call = Laufzeit_in_sek();int serial_a = 0;int serial_nr = 0;// ----------------------------------------------------------------------// Debuggingboolean Debug_Modus = 1; // mit Zusatzinfos über seriellen Monitor, kann über 208 umgeschaltet werdenint bremse = 0; // 1 ... 60000 Standardwert für Entschleunigung in ms zwischen einigen Befehlen zwecks Debugging// ----------------------------------------------------------------------// IR - Fernbedienung// Arduino IR Remote Sniffer// Portions © Andrew Ippoliti - acipo.com// const byte IR_PIN = 2;// volatile damit es auch in INT funktioniertvolatile boolean bounced = 0;const byte CODE_LEN = 40;volatile unsigned long durations[CODE_LEN];int letzte_IR_Auswahl;int IR_Auswahl;boolean mehrstellig;

Serial.begin(9600115200); // Kontrollausgabe über seriellen Monitor Serial.flush(); // löscht den Inhalt des seriellen Puffers // CHECK Fenster: es kommt Müll, wenn nicht 'kein Zeilenende' eingestellt ist! // Ausgabe-Pins: 3, 8, 9, 10: pinMode(OUTPUT_ENABLE_PIN, OUTPUT); // Pin Dimmer analogWrite(OUTPUT_ENABLE_PIN, 255); // entspricht 5 abfragen Volt an OE und damit LEDs aus pinMode(analogSTORE_PIN, EMKOUTPUT) für Zufallszahl; randomSeedpinMode(analogReadSHIFT_PIN, OUTPUT); pinMode(5)DATA_PIN, OUTPUT); // Eingabe-Pins 8,9: 2,10 auf Ausgabe7: pinMode(storePinBEWEGUNGSMELDER_PIN, OUTPUTINPUT); // IR-Fernbedienung pinMode(shiftPinIR_PIN, OUTPUTINPUT); pinModeattachInterrupt(dataPin0, OUTPUTdecodeIR, FALLING); //FALLING for when the Digitalpin 2 goes from high to low. Serial.println("PSE"); Serial.println("--------------------------------");

Serial.print("server is at Server ist an IP ");

Anzahl_Legenden_LEDs = 1 + Legende_ende - Legende_anfang; Serial.print("Anzahl Legenden-LEDs: "); Serial.println(Anzahl_Legenden_LEDs); resetPinsSerial.println(); // TO DO: löschen: // alle Pins auf LOWElement_an_Pin[] nach steigender Ordungszahl notieren:

// TO DO wg. Speicherproblemen vorerst aus: // for (byte z = 01; z < 144+ 1; z++) {

// // // // Ordnungszahl

// delay(1000); // Serial.print("Pin OZ ");

// Serial.print(" - OZ Pin "); // Serial.println(Element_an_Pin[z]); // Serial.print("Patch = "); // Serial.println(patchPin_von_Element[z]);

// delay(10000); // *********************** // LED Nr. 0 (Legende) immer an, ist gleichzeitig Kontrollleuchte für aktives Board: Led_an(0, 1); delay(1000);  // für Testphase LEDs LED von Element = 7 im setup Setup einschalten, später in loop: // Element = 7; // blau

delayPatchmodus_umschalten(1000); Serial.println("alle_Elemente_an"); Auswahl_alles_an(); Serial.println("alle_Elemente sind an"); delay(3000); Serial.println("alle_Elemente_aus"); // kann über 207 umgeschaltet werden Auswahl_alles_ausdebugging(); Serial.println("alle_Elemente sind aus"); delay(1000); // Serial.println("alle_Elemente Bingo"); // Auswahl_Bingo();kann über 208 umgeschaltet werden Serial.println("Setup fertig, jetzt startet die loopLoop-Schleife ......"); Serial.println("----------------------------------------------------"); delay(3000);

zyklus = zyklus + 1; // Serial.print(zyklus); // Serial.println("loop. Loop"); Auswahl = 0; // horche an IR-FB (Interrupt), der seriellen Schnittstelle undüber Ethernet-Shield an www // erfrage Element; später mal durch Webserver nach Ordnungszahl o. ä. auswählen: // z.B. Nr. OZ 1 - Wasserstoff: serielle_Schnittstelle_abfragen(); www_abfragen(); Bewegungsmelder_abfragen(); if (neue_Auswahl) { Auswahl_auswerten(); } if (Anzahl_angeschaltete_LEDs > Anzahl_Legenden_LEDs) { Treppenlicht(); } // while if (Serial.availablezyklus > 9999) { // 999 // // 1000-mal is nichts passiert, daher: // reset() == 0); // { Serial.println("-----ALLE LEDS AUS -------------------------------"); // delay(3000);

www}// **********************************************************************// ############### Funktionen nach ABC ##############################// **********************************************************************void Auswahl_auswerten(){ Bewegungsstatus = HIGH; while (Serial.available() > zyklus = 0); // Schlafmodus beenden {neue_Auswahl = 0; byte a last_call = 0Laufzeit_in_sek(); if (Debug_Modus) { Serial.print("neue Auswahl = Auswahl * 10von "); a = Serial.readprintln(Input) - '0'; Auswahl = Serial.println(Auswahl + a; delay(1); } Serial.writeprintln(Auswahl);

case 170161: Auswahl_Halbmetalle(); break; case 162: Auswahl_Nichtmetalle(); break; case 180: Auswahl_NichtmetalleLED_Eieruhr_switchen(); break; // auf 180 Sekunden oder LED_Eieruhr_normal

case 131default: // unbelegte Zahlen sind unsinnig und werden genullt: Serial.println("keine neue Auswahl"); } // vergesse die bisherige Auswahl, LED nicht erneut anschalten: Auswahl_Periode Auswahl = 0;}// **********************************************************************void Auswahl_alles_an() { // 255 Serial.println("alle_Elemente_an"); for (byte z = 1; z < Ausbaustufe + 1; z++) { Led_an(z, 1); } Serial.println("alle_Elemente sind an");}// **********************************************************************void Auswahl_alles_aus() { Helligkeit = 0; Dimmer(); // schaltet alle LEDs außer die für die Legende aus Serial.println("alle_Elemente_aus"); for (byte z = 1; z < Ausbaustufe + 1; z++) { Led_an(z, 20); } Serial.println("alle_Elemente sind aus"); Legende_an(); Helligkeit = Standardhelligkeit; Dimmer();}// **********************************************************************void Auswahl_biatomar() { Serial.println("Auswahl_biatomar"); break for (byte z = 1; z < Ausbaustufe + 1;z++) { default:if ((z == 1) || (z == 7) || (z == 8) || (z == 9) || (z == 17) || (z == 35) || (z == 53) || (z == 138) ) { Led_an(Auswahlz, 1); }

}// **********************************************************************void Auswahl_Bingo() { Serial.println("Elemente-Bingo"); byte zufall = random(1, Ausbaustufe); // vergesse die bisherige Auswahl, also nicht erneut schaltensetzt 'zufall' mit einer Zufallszahl // zwischen 1 und Ausbaustufe gleich Serial.print("Zufalls-Element:"); Serial.println(zufall); Led_an(zufall, 1);}// **********************************************************************void Auswahl_Hauptgruppe() { byte Hauptgruppe = Auswahl = 0- 140; Serial.print(Hauptgruppe); Serial.println(". Hauptgruppe"); switch (Hauptgruppe) { case 1: // for 1. Hauptgruppe Led_an(1, 1); Led_an(3, 1); Led_an(11, 1); Led_an(int z = 19, 1); Led_an(37, 1); z < AusbaustufeLed_an(55, 1); z++Led_an(87, 1) {; break; case 2: // delay2. Hauptgruppe Led_an(10004, 1); Led_an(12, 1); Led_an(20, 1); Led_an(38, 1); Led_an(56, 1); Led_an(88, 1); break; case 3: // 3. Hauptgruppe Led_an(5, 1); Led_an(13, 1); Led_an(31, 1); Led_an(49, 1); Led_an(81, 1); Led_an(z113, 1); break; case 4: // delay4. Hauptgruppe Led_an(1006, 1); Led_an(14, 1); Led_an(32, 1); Led_an(50, 1); Led_an(82, 1); Led_an(114, 1); break; case 5: // 5. Hauptgruppe Led_an(7, 1); Led_an(15, 1); Led_an(33, 1); Led_an(51, 1); Led_an(83, 1); Led_an(115, 1); break; case 6: // 6. Hauptgruppe Led_an(8, 1); Led_an(16, 1); Led_an(34, 1); Led_an(z52, 01); Led_an(84, 1); Led_an(116, 1); break; if case 7: // 7. Hauptgruppe Led_an(9, 1); Led_an(17, 1); Led_an(35, 1); Led_an(53, 1); Led_an(Anzahl_angeschaltete_LEDs > 85, 1) {; Led_an(117, 1); break; Treppenlichtcase 8: // 8. Hauptgruppe Led_an(2, 1); Led_an(10, 1); Led_an(18, 1); Led_an(36, 1); Led_an(54, 1); Led_an(86, 1); Led_an(118, 1); break;

void Auswahl_Helligkeit() { // ############### Unterprogramme nach ABC ############################## 210 ... 215 Wunschhelligkeit = 5 + 50 * (Auswahl - 210); // 210 -> 5, 211 -> 55, ... 215 -> 255 Helligkeit = Wunschhelligkeit; Dimmer();}

void Auswahl_Metalle() { // 160 Serial.println("Metalle"); for (byte z = 1; z < Ausbaustufe+ 1; z++) { if ((z == 3) || (z == 4) || (z == 11) || (z == 12) || (z == 13) || ((z >= 19) && (z <= 31)) || ((z >= 37) && (z <= 50)) || ((z >= 55) && (z <= 84)) || ((z >= 87) && (z <= 118)) || (z == 133)) {

Serial.println("Halbmetalle"); for (byte z = 1; z < Ausbaustufe+ 1; z++) { if ((z == 5) || (z == 14) || (z == 32) || (z == 33) || (z == 34) || (z == 51) || (z == 52) || (z == 85) || (z == 135)) {

Serial.println("Nichtmetalle"); for (byte z = 1; z < Ausbaustufe+ 1; z++) { if ((z == 1) || (z == 2) || ((z >= 6) && (z <= 10)) || ((z >= 15) && (z <= 18)) || ((z >= 35) && (z <= 36)) || ((z >= 53) && (z <= 54)) || (z == 86) || (z == 137)) {

Serial.println("190 = fest"); for (byte z = 1; z < Ausbaustufe+ 1; z++) { if (((z >= 3) && (z <= 6)) || ((z >= 11) && (z <= 16)) || ((z >= 19) && (z <= 34)) || ((z >= 37) && (z <= 53)) || ((z >= 55) && (z <= 85)) || ((z >= 87) && (z <= 118))) {

Serial.println("191 = flüssig"); for (byte z = 1; z < Ausbaustufe+ 1; z++) {

if ((z == 1) || (z == 2) || (z == 7) || (z == 8) || (z == 9) || (z == 10) || (z == 17) || (z == 18) || (z == 36) || (z == 54) || (z == 86)) {

Serial.println("radioaktiv"); for (byte z = 1; z < Ausbaustufe+ 1; z++) {

void Auswahl_biatomarBewegungsmelder_abfragen() { for (byte z = 1; z < Ausbaustufe; z++) {// Falls längere Zeit keine Auswahl getroffen wurde oder keine Bewegung messbar war, // wird der Bewegungsmelder abgefragt. // Bei Bewegung bleiben die LEDs an. if ((z == 1(Laufzeit_in_sek() || > (z == 7last_call + Standby_Timer)) || (z Bewegungsstatus == 8LOW) || )) { Bewegungsstatus = digitalRead(z == 9BEWEGUNGSMELDER_PIN) || ; if ((z Bewegungsstatus == 17LOW) || && (z neue_Auswahl == 350) || (z == 53) || (z { Helligkeit =0; last_call = 138) ) 0; // wenn Helligkeit auf 0 gesetzt wurde } else { Led_anlast_call = Laufzeit_in_sek(z, 1); Helligkeit = Wunschhelligkeit;

void Auswahl_Programm_xdebugging() { // 208 Debug_Modus = -(Debug_Modus - 1); Serial.print("Debugging ist "); if (Debug_Modus) { Serial.print("ein"); } else { Serial.print("aus"); } Serial.println("geschaltet. Umschalten: 208");}// **********************************************************************void Dimmer() // 0 to 255// Funktion merkt sich Helligkeitswert für LEDs, ausbaubedingt nur Einheitswert für alle Schieberegister// 0 = dunkel, weil 0% Einschaltdauer, 255 = volle Leistung, weil 100% ED{ analogWrite(OUTPUT_ENABLE_PIN, 255 - Helligkeit);}// **********************************************************************void LED_Eieruhr_switchen() { // switchen auf 180 oder 30 Sekunden Serial.print("LED-Eieruhr switchen von "); Serial.print(LED_Eieruhr); Serial.print(" auf "); switch (LED_Eieruhr) { case LED_Eieruhr_normal: LED_Eieruhr = 180; break; // LEDs 3 Minuten anlassen case 180: LED_Eieruhr = LED_Eieruhr_normal; break; // LEDs 30s anlassen } Serial.print(LED_Eieruhr); Serial.print(" Sekunden");

void Auswahl_Programm_yunsigned int Laufzeit_in_sek() { unsigned int t_gesamt_in_sek = millis() / 1000; // millis() gibt den Wert in Millisekunden als 'unsigned int' Datentyp zurück, berechnet seitdem das Arduino // Board das aktuelle Programm gestartet hat. return t_gesamt_in_sek;

void Auswahl_Programm_zLed_an(byte Element, boolean an) { // Funktion schaltet durch (Element) bestimmte Pins (= LEDs) an oder aus, // plant einen Ausschaltpunkt (led_aus[Element]) und merkt sich die Anzahl_angeschaltete_LEDs. // 'Element' ist die OZ, 'an' der Schaltzustand 0/1 // 'pin' ist der tatsächliche Anschlusspunkt der LED-Matrix, z. B. bei Element 22 (Titan, logisch) // die 27. Led (physikalisch) schalten. Zuordnung Pin/Element: byte Pin = Element; // Probebetrieb ohne Patchmodus: OZ 22 = Pin 22 if (Patchmodus) { // Normalfall: OZ 22 = Pin 27 Pin = Pin_von_Element[Element]; } // mitzählen, wieviel LEDs insgesamt an sind: // nur ausführen, wenn (an -> aus) oder (aus -> an), nicht bei (bleibt an) oder (bleibt aus) if (an != led[Pin]) { Anzahl_angeschaltete_LEDs = Anzahl_angeschaltete_LEDs + an * 2 - 1; // Anz. = Anz. -1 oder +1 } led[Pin] = an; // for (byte z = 1; z < Ausbaustufe + 1; z++) { // if (led[z]) { //// Serial.print("p_"); //// Serial.print(z); //// Serial.print("-"); // } // } // // nur für Fehlerabfrage // if (Anzahl_angeschaltete_LEDs > Ausbaustufe) { // Serial.println("F E H L E R : zuviele LEDs geschaltet!"); // delay(bremse); // } // spart Speicher: unsigned long led_Start zu byte einkürzen: if (an) { led_aus[Element] = Laufzeit_in_sek() + LED_Eieruhr; // vormerken: LED nach (LED_Eieruhr) Sek. wieder ausschalten last_Element = Element; // welches Element wurde zuletzt angeschaltet? if (Debug_Modus) { Serial.print("LED von Element "); Serial.print(Element); Serial.print(" -> Pin "); Serial.print(Pin); Serial.println(" ist an."); Serial.println("--------------------"); } } resetPins(); // Schieberegister // serielles Einlesen, alle LEDs werden neu geschaltet for (byte i = 1; i < Ausbaustufe + 1; i++) { // Aktion passiert bei Wechsel von LOW auf HIGH digitalWrite(SHIFT_PIN, LOW); // Jetzt den Wert der aktuellen Stelle ans Datenpin DS anlegen digitalWrite(DATA_PIN, led[i]); // Dann SHIFT_PIN SHCP von LOW auf HIGH, damit wird der Wert // am Datenpin ins Register geschoben. digitalWrite(SHIFT_PIN, HIGH); } // Wenn alle Stellen im Register sind, jetzt das STORE_PIN STCP // von LOW auf HIGH, damit wird Registerinhalt an Ausgabepins // kopiert und der Zustand an den LEDs sichtbar // neues Muster einschalten: digitalWrite(STORE_PIN, HIGH);

void Auswahl_PeriodeLegende_an(byte anfang, byte ende) { // diese LEDs immer anlassen: // TO DO: bei Sondergruppe die anderen ausblenden, z. B. Metalle an, // dann Halb- u. Nichtmetalle aus for (byte z = anfangLegende_anfang; z < endeLegende_ende + 1; z++) {

void Auswahl_alles_anPatchmodus_umschalten() {// 207 Patchmodus = -(Patchmodus - 1); reset(); Serial.print("Patchmodus ist "); if (Patchmodus) { Serial.print("ein"); } else { Serial.print("aus"); } Serial.println("geschaltet. Umschalten: 207");}// **********************************************************************void reset() { // 209 Serial.println("********* Reset *********"); resetPins(); Helligkeit = 0; Dimmer(); LED_Eieruhr = LED_Eieruhr_normal; for (byte z i = 1; z i < Ausbaustufe+ 1; zi++) { led[i] = 0; Led_an(zi, 10);

void Auswahl_alles_ausresetPins() { for // Zuerst immer alle 3 Pins auf LOW digitalWrite(STORE_PIN, LOW); digitalWrite(SHIFT_PIN, LOW); digitalWrite(DATA_PIN, LOW);}// **********************************************************************void serielle_Schnittstelle_abfragen() { if (Serial.available()) { Serial.println("Ich bin www-taub!"); serial_a = 0; serial_nr = 0; while (Serial.available(byte z ) > 0) { serial_nr = 1serial_nr * 10; z < Ausbaustufe serial_a = Serial.read() - '0'; z+// ASCII-Textversatz für 0 entfernen serial_nr = serial_nr +serial_a; delay(5) {; // delay in between reads for stability } neue_Auswahl = 1; Led_anAuswahl = int(z, 0serial_nr); Input = "serieller Schnittstelle";

void Auswahl_BingoTreppenlicht() { // TO DO: evtlschaltet eine LED nach [LED_Eieruhr] Sek. wieder aus if (Debug_Modus) { Serial.println("Treppenlicht"); Serial.print("Laufzeit in s = "); Serial.println(Laufzeit_in_sek()); Serial.print(Anzahl_angeschaltete_LEDs); Serial.print(" LEDs sind an, davon "); Serial.print(Anzahl_Legenden_LEDs); Serial.println(" Legenden-LEDs"); Serial. nur 1x ohne die Schleifeprintln(); } for (byte z = 1; z < Ausbaustufe+ 1; z++) { byte zufall Element = randomz; if (1, AusbaustufePatchmodus){ // Normalfall: OZ 22 = Pin 27 Element = Element_an_Pin[z]; } if (led[z]) { // setzt 'zufall' mit einer Zufallszahlfalls an: max. Einschaltzeit überschritten? if (Laufzeit_in_sek() > led_aus[Element]) { // zwischen 1 und Ausbaustufe gleichLegenden-LEDs immer an lassen, sonst Ausschalten: Serial.println if (zufallElement < Legende_anfang || Element > Legende_ende); { Led_an(zufallElement, 10); // Ausschalten } } delay(500);}

void wwwwww_abfragen() {

if (readString.length() < 10050) {

Serial.println(readString); //print to serial monitor for debugingdebugging // normalerweise kommt von Browser: "GET /z=[pos] HTTP/1.1" String stringOne = readString; int pos = 1 2 + readStringstringOne.indexOf('z=');

// delay(1000)Input = "www";

client.println("<HEAD>"zahl); client.println("<TITLE>Periodensystem der Elemente</TITLEBR>"); client.printlnif ("</HEAD>"Auswahl == 0);{ client.println("<BODY>Auswahl unklar, Aufruf im Browser durch "); client.println("<H1>Periodensystem der Elemente<[IP]/H1>"); client?z=[Auswahl], z. B.println("<hr a href='http:/>"); client.println("<br />"); client192.println("<H2>Led auswählen</H2>"); client168.println("<br />"); client178.println("<a href=\"104/?z=4\"\"1'>[ 4 ]<http://a>"); client192.168.println("-"); client178.println("<a href=\"104/?z=7\"\">[ 7 ]1</a><br />"); client.println("<br /BR>"); client.println("<br />");} client.println("<a href=\"/?z=255\"\">[alle an]</a>"); clientCreated by Detlef Giesler.println("-"); client.println("Visit <a href=\"/?z=254\"\">[alle aus]</a><br />"); client.println("<p>Created by Detlef Giesler. Visit 'http://www.bs-wiki.de for more info!</p>"); clientmediawiki/index.println("<br php/222'>"); clientbs-wiki.println("de</BODYa>for more info!");

void Laufzeit_hhmmssdecodeIR() { t_gesamt_in_sek = millisif (bounced) / 1000{ return; // millis() gibt den Wert in Millisekunden als 'unsigned int' Datentyp zurück, berechnet seitdem das Arduino} // Board das aktuelle Programm gestartet hat.bounced = 1; // nullt bei ?? msstop all interrupts byte t_gesamt_in_h = millisnoInterrupts() / 3600000; byte t_gesamt_in_m = millis() / 60000 - t_gesamt_in_h * 60i; byte t_gesamt_in_s = millis() / 1000 - t_gesamt_in_m * 60; Serial.print(/for each "Laufzeit hh:mm:ss = bit");in the code Serial.printfor (t_gesamt_in_h)i = 0; Serial.print(":")i < CODE_LEN; Serial.print(t_gesamt_in_mi += 1);{ Serial.print //store the duration of the pulse (":"microseconds); Serial.print durations[i] = pulseIn(t_gesamt_in_sIR_PIN, HIGH, 20000); Serial.println();}// 100000 timeout // **********************************************************************void Led_anpulseIn(byte Elementpin, value, boolean antimeout) {liest einen Puls (HIGH oder LOW) auf einem Pin aus. // to do: switch Element/LEDZum Beispiel, wenn value gleich HIGH ist, z. B. bei Element 11 wartet pulseIn(Natrium) bis der Pin auf HIGH geht, startet die 3. Led schaltenZeit, // patch it:dann wird gewartet, bis der Pin auf LOW ist und die Zeit wird gestoppt. // Element=patch[Element]; Laufzeit_hhmmss(); SerialZurückgegeben wird die Länge des Puls in Mikrosekunden.print(Element); Serial.print(". LED Nach einer bestimmten Zeit wird geschaltet von "); Serial.print(led[Element]); Serial.print(" -> "); Serial.println(an); // mitzählen0 zurückgegeben, wieviel LEDs insgesamt an sind: // nur ausführen, wenn (an -> aus) oder (aus -> an), nicht bei (bleibt an) oder (bleibt aus) if (an != led[Element]) { Anzahl_angeschaltete_LEDs = Anzahl_angeschaltete_LEDs + an * 2 - 1; // Anz. = Anzkein Pulse kommt. -1 oder +1

led[Element] = an;//enable interrupts Serial.printinterrupts(Anzahl_angeschaltete_LEDs); Serial.printif (" LEDs sind anbounced) { bounced = 0; boolean sauberes_signal = 1; // optimistisch sein // 8 Adress-Bits + 8 invertierte Adress-Bits + 8 Kommando-Bits + 8 invertierte Kommando-Bits // erwartungsgemäß 8 Nullen: ") byte a_code = B00000000; for (byte z i = 01; z i < Ausbaustufe9; z+i += 1) { if switch (leddurations[zi]) { case 100 ... 840: bitSet(a_code, i - 1); break; // 560µs Pause ist 0-Bit default: sauberes_signal = 0; return; } } // Serial.printprintln(za_code);  // erwartungsgemäß 8 Einsen: byte a_i_code = B00000000; for (i = 9; i < 17; i += 1) { Serialswitch (durations[i]) { case 1400 ...print2100: bitSet("a_i_code, i -"9);break; // 1690µs Pause ist 1-Bit default: sauberes_signal = 0; return; }

} // Serial.println(""a_i_code); // nur für Fehlerabfrage if (Anzahl_angeschaltete_LEDs > Ausbaustufe) { delay(30000); } // spart Speicher: unsigned long led_Start zu byte einkürzen if (an) { // led_Startzeit[Element] code = t_gesamt_in_sekB00000000; led_aus[Element] = t_gesamt_in_sek + Eieruhr; // vormerken: LED nach (Eieruhr) Sek. wieder ausschalten } resetPins(); digitalWrite(storePin, LOW); for (byte i = 017; i < Ausbaustufe25; i++= 1) { // Aktion passiert bei Wechsel von LOW auf HIGH Serial.print(i); digitalWrite // Serial.print(shiftPin, LOW" - "); // Jetzt den Wert der aktuellen Stelle ans Datenpin DS anlegen digitalWrite Serial.println(dataPin, leddurations[i]); // ALIAS digitalWrite Serial.println((dataPin, led[patchunsigned long)durations[i]]); // Dann ShiftPin SHCP von LOW auf HIGH, damit wird der Wert delay(3000); switch (durations[i]) { // am Datenpin ins Register geschoben case 100 ...840: bit = 0; break; // 560µs Pause ist 0-Bit digitalWrite case 1400 ... 2100: bitSet(shiftPincode, HIGHi - 17); } break; // Wenn alle 8 Stellen im Register sind, jetzt das StorePin STCP1690µs Pause ist 1-Bit // von LOW auf HIGH, damit wird Registerinhalt an Ausgabepins // kopiert und der Zustand an den LEDs sichtbar }

} if (Debug_Modus) { Serial.print("IR-Code: "); Serial.println(code); } //analogWrite Serial.print(storePin, 254" = "); // neues Muster einschalten byte i_code = B00000000; for (i = 25; i < 33; i += 1) { switch (durations[i]) { case 100 ... 840: digitalWritebitSet(storePini_code, HIGHi - 25);break; // 560µs Pause ist 0-Bit } } delay if (100i_code != code){ sauberes_signal = 0; return; } // Serial.printprintln(Elementi_code); // Serial.print(". LED ist sauberes_signal = "); // Serial.println(ansauberes_signal); Serial.println switch ("code) { case 22: IR_Auswahl = 0; break; case 12: IR_Auswahl = 1; break; case 24: IR_Auswahl = 2; break; case 94: IR_Auswahl = 3; break; case 8: IR_Auswahl = 4; break; case 28: IR_Auswahl = 5; break; case 90: IR_Auswahl = 6; break; case 66: IR_Auswahl = 7; break; case 82: IR_Auswahl = 8; break; case 74: IR_Auswahl = 9; break; case 7: IR_Auswahl = 210; break; // Vol-- case 9: IR_Auswahl = 213; break; // [EQ] -> mittlere Helligkeit case 21: IR_Auswahl = 215; break; // Vol++ case 69: IR_Auswahl = 254; break; // CH-alles aus case 70: IR_Auswahl = 200; break; // CH Zufallszahl ----------------")> Bingo case 71: IR_Auswahl = 255; delay(10) break;// CH+ alles an} case 64 : // **********************************************************************nextvoid resetPins switch (last_Element) { // Zuerst immer alle 3 Pins auf LOWElemente, Hauptgruppen, Perioden ... digitalWrite case 1 ... 118: IR_Auswahl = min(storePin118, LOWlast_Element + 1); break; digitalWrite case 131 ... 194: IR_Auswahl = min(shiftPin194, LOWlast_Element + 1); break; digitalWrite } break; case 68 : // prev IR_Auswahl = max(dataPin1, LOWlast_Element - 1);} break; case 25 : // **********************************************************************100+ als Init für mehrstellige Zahl mehrstellig = 1;void Treppenlicht() { IR_Auswahl = 0; Serial.println("Treppenlicht") break; case 13 : // schaltet die LED 200+ als Quit nach (Eieruhr) Sek. wieder ausmehrstelliger Zahl mehrstellig = 0; IR_Auswahl = letzte_IR_Auswahl; letzte_IR_Auswahl = 0; Laufzeit_hhmmss() break; for (byte z case 67: IR_Auswahl = 1202; z < Ausbaustufe break; z++) {// Play/Pause -> Programm_y } if (led[z]mehrstellig) { // max. Einschaltzeit überschritten? if (t_gesamt_in_sek > led_aus[z]IR_Auswahl < 10) { Led_an(z, 0)letzte_IR_Auswahl = letzte_IR_Auswahl * 10 + IR_Auswahl;

delayif (mehrstellig == 0) { if (Debug_Modus) { Serial.print("IR-Auswahl: "); Serial.println(10Auswahl); Serial.println(); } Auswahl = IR_Auswahl; neue_Auswahl = 1; Input = "Fernbedienung"; } // last_Element = Auswahl; // delay(3000); /* 0: 22 100+: 25 200+: 13 1: 12 2: 24 3: 94 4: 8 5: 28 6: 90 7: 66 8: 82 9: 74 CH-: 69 CH: 70 CH+: 71 prev: 68 next: 64 Play: 67 Vol-: 7 Vol+: 21 eq: 9 */