// ********************************************************************** // interaktives Periodensystem der Elemente // schaltet gewünschte LED an // Detlef Giesler // BBS Winsen (Luhe) // 29.04.2015 // ********************************************************************** // letzte Änderungen: // 29.04.2015: Arduino als HTTP-Client // 28.04.2015: Abfrage der seriellen Schnittstelle // **********************************************************************
- include <SPI.h>
- include <Ethernet.h>
byte mac[6] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //physical mac address byte ip[4] = { 192, 168, 178, 104 }; // ip in lan (that's what you need to use in your browser. ("192.168.178.104") byte gateway[4] = { 192, 168, 1, 1 }; // internet access via router byte subnet[4] = { 255, 255, 255, 0 }; //subnet mask EthernetServer server(80); //server port String readString;
// globale Variablen: // Arduino-Pin verbunden mit SH_CP des 74HC595 byte shiftPin = 8; // Arduino-Pin verbunden mit ST_CP des 74HC595 byte storePin = 9; // Arduino-Pin verbunden mit DS des 74HC595 byte dataPin = 10;
// Elemente und LEDs: // 24 ist die derzeitige Ausbaustufe, am Ende 120 LEDs byte Ausbaustufe = 24;
// Auswahl // Ordnungszahl definiert Element 1...118 byte 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]; 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-p137p138p139p140p141p142p143p144 const byte Element_an_Pin[145] = {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}; // Element_an_Pin[] nach steigender Ordungszahl notieren: // TO DO wg. Speicherproblemen vorerst aus: // byte patch[145];
byte Anzahl_angeschaltete_LEDs = 0; unsigned int t_gesamt_in_sek = millis() / 1000; // TO DO: über Poti einstellen byte Eieruhr = 20; // Vorgabe der Einschaltdauer einer LED in Sekunden
// ********************************************************************** void setup() {
Serial.begin(9600); // Kontrollausgabe über seriellen Monitor
// Pin 5 abfragen (analog, EMK) für Zufallszahl
randomSeed(analogRead(5));
// Pins 8,9,10 auf Ausgabe
pinMode(storePin, OUTPUT);
pinMode(shiftPin, OUTPUT);
pinMode(dataPin, OUTPUT);
// start the Ethernet connection and the server:
Ethernet.begin(mac, ip, gateway, subnet);
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
resetPins(); // alle Pins auf LOW
// Switchen, Element_an_Pin[] nach steigender Ordungszahl merken:
// TO DO wg. Speicherproblemen vorerst aus:
// for (byte z = 0; z < 144; z++) {
// patch[Element_an_Pin[z]] = z;
// // Ordnungszahl
// }
// ***********************
// Kontrolle
// for (byte spalte = 1; spalte < 19; spalte++) {
// Serial.println();
// Serial.print(spalte);
// Serial.println(". Spalte = #IC");
// Serial.println("------------------");
// for (byte zeile = 1; zeile < 9; zeile++) {
// Serial.print(zeile);
// Serial.println(". Zeile");
// byte z = zeile + 8 * (spalte - 1);
// delay(1000);
// Serial.print("Pin ");
// Serial.print(z);
// Serial.print(" - OZ ");
// Serial.println(Element_an_Pin[z]);
// Serial.print("Patch = ");
// Serial.println(patch[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 im setup einschalten, später in loop:
// Element = 7; // blau
Led_an(7, 1);
delay(1000);
Serial.println("alle_Elemente_an");
Auswahl_alles_an();
Serial.println("alle_Elemente sind an");
delay(3000);
Serial.println("alle_Elemente_aus");
Auswahl_alles_aus();
Serial.println("alle_Elemente sind aus");
delay(1000);
// Serial.println("alle_Elemente Bingo");
// Auswahl_Bingo();
Serial.println("jetzt startet die loop-Schleife ......");
Serial.println("--------------------------------------");
delay(3000);
} // ********************************************************************** void loop () {
Serial.println("loop");
Auswahl = 0;
// horche an der seriellen Schnittstelle und
// erfrage Element; später mal durch Webserver nach Ordnungszahl o. ä. auswählen:
// z.B. Nr. 1 - Wasserstoff:
// while (Serial.available() == 0)
// {
//
// }
www();
while (Serial.available() > 0)
{
byte a = 0;
{
Auswahl = Auswahl * 10;
a = Serial.read() - '0';
Auswahl = Auswahl + a;
delay(1);
}
Serial.write(Auswahl);
}
delay(100);
switch (Auswahl) {
case 160: Auswahl_Metalle(); break;
case 170: Auswahl_Halbmetalle(); break;
case 180: Auswahl_Nichtmetalle(); break;
case 190: Auswahl_fest(); break;
case 191: Auswahl_liquid(); break;
case 192: Auswahl_gas(); break;
case 193: Auswahl_radioaktiv(); break;
case 194: Auswahl_biatomar(); break;
case 200: Auswahl_Bingo(); break;
case 201: Auswahl_Programm_x(); break;
case 202: Auswahl_Programm_y(); break;
case 203: Auswahl_Programm_z(); break;
case 254: Auswahl_alles_aus(); break;
case 255: Auswahl_alles_an(); break;
case 131: Auswahl_Periode(1, 2); break;
default:
Led_an(Auswahl, 1);
}
// vergesse die bisherige Auswahl, also nicht erneut schalten:
// Auswahl = 0;
// for (int z = 1; z < Ausbaustufe; z++) {
// delay(1000);
// Led_an(z, 1);
// delay(100);
// // Led_an(z, 0);
if (Anzahl_angeschaltete_LEDs > 1) {
Treppenlicht();
}
Serial.println("--------------------");
delay(1000);
} // ********************************************************************** // ############### Unterprogramme nach ABC ############################## // ********************************************************************** void Auswahl_Metalle() {
for (byte z = 1; z < Ausbaustufe; 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)) {
Led_an(z, 1);
}
}
} // ********************************************************************** void Auswahl_Halbmetalle() {
for (byte z = 1; z < Ausbaustufe; z++) {
if ((z == 5) || (z == 14) || (z == 32) || (z == 33) || (z == 34) || (z == 51) || (z == 52) || (z == 85) || (z == 135)) {
Led_an(z, 1);
}
}
} // ********************************************************************** void Auswahl_Nichtmetalle() {
for (byte z = 1; z < Ausbaustufe; 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)) {
Led_an(z, 1);
}
}
} // ********************************************************************** void Auswahl_fest() {
for (byte z = 1; z < Ausbaustufe; 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))) {
Led_an(z, 1);
}
}
} // ********************************************************************** void Auswahl_liquid() {
for (byte z = 1; z < Ausbaustufe; z++) {
if ((z == 35) || (z == 80)) {
Led_an(z, 1);
}
}
} // ********************************************************************** void Auswahl_gas() {
for (byte z = 1; z < Ausbaustufe; z++) {
if ((z == 1) || (z == 2) || (z == 7) || (z == 8) || (z == 9) || (z == 10) || (z == 17) || (z == 18) || (z == 36) || (z == 54) || (z == 86)) {
Led_an(z, 1);
}
}
} // ********************************************************************** void Auswahl_radioaktiv() {
for (byte z = 1; z < Ausbaustufe; z++) {
if ((z == 43) || (z == 61) || ((z >= 84) && (z <= 118)) || (z == 134) || (z == 136)) {
Led_an(z, 1);
}
}
} // ********************************************************************** void Auswahl_biatomar() {
for (byte z = 1; z < Ausbaustufe; z++) {
if ((z == 1) || (z == 7) || (z == 8) || (z == 9) || (z == 17) || (z == 35) || (z == 53) || (z == 138) ) {
Led_an(z, 1);
}
}
} // ********************************************************************** void Auswahl_Programm_x() {
} // ********************************************************************** void Auswahl_Programm_y() {
} // ********************************************************************** void Auswahl_Programm_z() {
}
// ********************************************************************** void Auswahl_Periode(byte anfang, byte ende) {
for (byte z = anfang; z < ende; z++) {
Led_an(z, 1);
}
} // ********************************************************************** void Auswahl_alles_an() {
for (byte z = 1; z < Ausbaustufe; z++) {
Led_an(z, 1);
}
} // ********************************************************************** void Auswahl_alles_aus() {
for (byte z = 1; z < Ausbaustufe; z++) {
Led_an(z, 0);
}
} // ********************************************************************** void Auswahl_Bingo() {
// TO DO: evtl. nur 1x ohne die Schleife
for (byte z = 1; z < Ausbaustufe; z++) {
byte zufall = random(1, Ausbaustufe);
// setzt 'zufall' mit einer Zufallszahl
// zwischen 1 und Ausbaustufe gleich
Serial.println(zufall);
Led_an(zufall, 1);
delay(500);
}
} // ********************************************************************** void www() {
// Create a client connection
EthernetClient client = server.available();
if (client) {
while (client.connected()) {
if (client.available()) {
char c = client.read();
//read char by char HTTP request
if (readString.length() < 100) {
//store characters to string
readString += c;
}
//if HTTP request has ended
if (c == '\n') {
Serial.println(readString); //print to serial monitor for debuging
int pos = 1 + readString.indexOf('z=');
Serial.println(pos);
String zahl = readString.substring(pos);
Serial.print("Zahl-String:");
Serial.println(zahl);
Auswahl = zahl.toInt();
Serial.println(Auswahl);
// delay(1000);
client.println("HTTP/1.1 200 OK"); //send new page
client.println("Content-Type: text/html");
client.println();
client.println("<HTML>");
client.println("<HEAD>");
client.println("<TITLE>Periodensystem der Elemente</TITLE>");
client.println("</HEAD>");
client.println("<BODY>");
client.println("Periodensystem der Elemente
");
client.println("
");
client.println("Led auswählen
"); client.println("
");
client.println("<a href=\"/?z=4\"\">[ 4 ]</a>");
client.println("-");
client.println("<a href=\"/?z=7\"\">[ 7 ]</a>
");
client.println("
");
client.println("
");
client.println("<a href=\"/?z=255\"\">[alle an]</a>");
client.println("-");
client.println("<a href=\"/?z=254\"\">[alle aus]</a>
");
client.println("Created by Detlef Giesler. Visit http://www.bs-wiki.de for more info!
"); client.println("
");
client.println("</BODY>");
client.println("</HTML>");
delay(1);
//stopping client
client.stop();
//controls the Arduino if you press the buttons
Serial.write(Auswahl);
//clearing string for next read
readString = "";
}
}
}
}
} // ********************************************************************** void Laufzeit_hhmmss() {
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.
// nullt bei ?? ms
byte t_gesamt_in_h = millis() / 3600000;
byte t_gesamt_in_m = millis() / 60000 - t_gesamt_in_h * 60;
byte t_gesamt_in_s = millis() / 1000 - t_gesamt_in_m * 60;
Serial.print("Laufzeit hh:mm:ss = ");
Serial.print(t_gesamt_in_h);
Serial.print(":");
Serial.print(t_gesamt_in_m);
Serial.print(":");
Serial.print(t_gesamt_in_s);
Serial.println();
} // ********************************************************************** void Led_an(byte Element, boolean an) {
// to do: switch Element/LED, z. B. bei Element 11 (Natrium) die 3. Led schalten
// patch it:
// Element=patch[Element];
Laufzeit_hhmmss();
Serial.print(Element);
Serial.print(". LED wird geschaltet von ");
Serial.print(led[Element]);
Serial.print(" -> ");
Serial.println(an);
// 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[Element]) {
Anzahl_angeschaltete_LEDs = Anzahl_angeschaltete_LEDs + an * 2 - 1; // Anz. = Anz. -1 oder +1
}
led[Element] = an;
Serial.print(Anzahl_angeschaltete_LEDs);
Serial.print(" LEDs sind an: ");
for (byte z = 0; z < Ausbaustufe; z++) {
if (led[z]) {
Serial.print(z);
Serial.print("-");
}
}
Serial.println("");
// 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] = t_gesamt_in_sek;
led_aus[Element] = t_gesamt_in_sek + Eieruhr; // vormerken: LED nach (Eieruhr) Sek. wieder ausschalten
}
resetPins();
digitalWrite(storePin, LOW);
for (byte i = 0; i < Ausbaustufe; i++) {
// Aktion passiert bei Wechsel von LOW auf HIGH
digitalWrite(shiftPin, LOW);
// Jetzt den Wert der aktuellen Stelle ans Datenpin DS anlegen
digitalWrite(dataPin, led[i]);
// ALIAS digitalWrite(dataPin, led[patch[i]]);
// Dann ShiftPin SHCP von LOW auf HIGH, damit wird der Wert
// am Datenpin ins Register geschoben.
digitalWrite(shiftPin, HIGH);
}
// Wenn alle 8 Stellen im Register sind, jetzt das StorePin STCP
// von LOW auf HIGH, damit wird Registerinhalt an Ausgabepins
// kopiert und der Zustand an den LEDs sichtbar
//analogWrite(storePin, 254);
// neues Muster einschalten:
digitalWrite(storePin, HIGH);
delay(100);
// Serial.print(Element);
// Serial.print(". LED ist ");
// Serial.println(an);
Serial.println("--------------------");
delay(10);
} // ********************************************************************** void resetPins() {
// Zuerst immer alle 3 Pins auf LOW digitalWrite(storePin, LOW); digitalWrite(shiftPin, LOW); digitalWrite(dataPin, LOW);
} // ********************************************************************** void Treppenlicht() {
Serial.println("Treppenlicht");
// schaltet die LED nach (Eieruhr) Sek. wieder aus
Laufzeit_hhmmss();
for (byte z = 1; z < Ausbaustufe; z++) {
if (led[z]) {
// max. Einschaltzeit überschritten?
if (t_gesamt_in_sek > led_aus[z]) {
Led_an(z, 0);
}
}
}
delay(10);
Serial.println();
}