Diskussion:Arduino: Unterschied zwischen den Versionen
Dg (Diskussion | Beiträge) |
Dg (Diskussion | Beiträge) |
||
Zeile 6: | Zeile 6: | ||
// ********************************************************************** | // ********************************************************************** | ||
// letzte Änderungen: | // letzte Änderungen: | ||
− | // | + | // 06.05.2015: Patch Panel aktiviert TO DO: aber irgendwie verschoben |
+ | // 05.05.2015: Anpassung an Mega 2560 wg. Speicherproblemen beim Uno | ||
// 04.05.2015: rudimentäre Dimmfunktion | // 04.05.2015: rudimentäre Dimmfunktion | ||
// 03.05.2015: Ausbaustufe = 32, LED #0 gibt es nicht mehr, automatisches Abschalten nach 500 Leerzyklen | // 03.05.2015: Ausbaustufe = 32, LED #0 gibt es nicht mehr, automatisches Abschalten nach 500 Leerzyklen | ||
Zeile 50: | Zeile 51: | ||
// ... pro Spalte ein 8-bit-Schieberegister = 18 SR insgesamt | // ... pro Spalte ein 8-bit-Schieberegister = 18 SR insgesamt | ||
byte Ausbaustufe = 32; | byte Ausbaustufe = 32; | ||
− | + | // TO DO: vorerst ohne Patchen | |
+ | boolean patchmodus = 0; | ||
// Auswahl | // Auswahl | ||
// Ordnungszahl definiert Element 1...118 | // Ordnungszahl definiert Element 1...118 | ||
Zeile 74: | Zeile 76: | ||
// 255 = alles_an | // 255 = alles_an | ||
− | boolean led[ | + | boolean led[144]; |
− | unsigned int led_aus[ | + | unsigned int led_aus[144]; |
// virtuelles Patchpanel: Zuordnung Ordungszahl/Pin, z. B. Natrium mit OZ 11 an *Pin 3*: | // virtuelles Patchpanel: Zuordnung Ordungszahl/Pin, z. B. Natrium mit OZ 11 an *Pin 3*: | ||
− | + | byte Element_an_Pin[144] = { | |
// Pinning ohne eine "Led #0" | // Pinning ohne eine "Led #0" | ||
− | // | + | //p1p2*p3*p4 p5 p6 p7 p8 - p9 p10 p11 p12 p13 p14 p15 p16 -p17 p18 p19 p20 p21 p22 p23 p24- |
− | + | 1, 3, 11, 19, 37, 55, 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 | // 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 | , 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 | // 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 | , 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 | // 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 | , 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 | // 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 | , 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 | //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 | , 8, 16, 34, 52, 84, 116, 70, 102, 9, 17, 35, 53, 85, 117, 141, 142, 2, 10, 18, 36, 54, 86, 118, 143 | ||
Zeile 94: | Zeile 101: | ||
// Element_an_Pin[] nach steigender Ordungszahl notieren: | // Element_an_Pin[] nach steigender Ordungszahl notieren: | ||
// TO DO wg. Speicherproblemen vorerst aus: | // TO DO wg. Speicherproblemen vorerst aus: | ||
− | + | byte patch[144]; | |
byte Anzahl_angeschaltete_LEDs = 0; | byte Anzahl_angeschaltete_LEDs = 0; | ||
Zeile 102: | Zeile 109: | ||
int zyklus = 0; // loop-Zyklen | int zyklus = 0; // loop-Zyklen | ||
// Debugging | // Debugging | ||
− | int bremse = | + | int bremse = 1; // 1 ... 60000 Standardwert für Entschleunigung in ms zwischen einigen Befehlen zwecks Debugging |
// ********************************************************************** | // ********************************************************************** | ||
void setup() { | void setup() { | ||
− | Dimmer( | + | Dimmer(127); // halbe Helligkeit = halbe Stromstärke |
Serial.begin(9600); // Kontrollausgabe über seriellen Monitor | Serial.begin(9600); // Kontrollausgabe über seriellen Monitor | ||
// Pin 5 abfragen (analog, EMK) für Zufallszahl | // Pin 5 abfragen (analog, EMK) für Zufallszahl | ||
− | randomSeed(analogRead(5)); | + | // randomSeed(analogRead(5)); |
// Pins 3, 8,9,10 auf Ausgabe | // Pins 3, 8,9,10 auf Ausgabe | ||
pinMode(outputEnablePin, OUTPUT); // Dimmer | pinMode(outputEnablePin, OUTPUT); // Dimmer | ||
Zeile 123: | Zeile 130: | ||
// Switchen, Element_an_Pin[] nach steigender Ordungszahl merken: | // Switchen, Element_an_Pin[] nach steigender Ordungszahl merken: | ||
// TO DO wg. Speicherproblemen vorerst aus: | // TO DO wg. Speicherproblemen vorerst aus: | ||
− | + | for (byte z = 1; z < 144 + 1; z++) { | |
− | + | patch[Element_an_Pin[z]] = z; | |
− | + | // // // Ordnungszahl | |
− | + | } | |
// *********************** | // *********************** | ||
// Kontrolle | // Kontrolle | ||
Zeile 147: | Zeile 154: | ||
// } | // } | ||
// } | // } | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
// für Testphase LEDs im setup einschalten, später in loop: | // für Testphase LEDs im setup einschalten, später in loop: | ||
// Element = 7; // blau | // Element = 7; // blau | ||
Zeile 234: | Zeile 234: | ||
} | } | ||
// ********************************************************************** | // ********************************************************************** | ||
− | // ############### | + | // ############### Funktionen nach ABC ############################## |
// ********************************************************************** | // ********************************************************************** | ||
void Auswahl_alles_an() { | void Auswahl_alles_an() { | ||
Zeile 293: | Zeile 293: | ||
void Auswahl_Metalle() { | void Auswahl_Metalle() { | ||
for (byte z = 1; z < Ausbaustufe + 1; z++) { | 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)) { | + | 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); | Led_an(z, 1); | ||
} | } | ||
Zeile 301: | Zeile 303: | ||
void Auswahl_Halbmetalle() { | void Auswahl_Halbmetalle() { | ||
for (byte z = 1; z < Ausbaustufe + 1; z++) { | 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)) { | + | if ((z == 5) || (z == 14) || (z == 32) || (z == 33) || (z == 34) || (z == 51) || (z == 52) || (z == 85) |
+ | || (z == 135)) { | ||
Led_an(z, 1); | Led_an(z, 1); | ||
} | } | ||
Zeile 309: | Zeile 312: | ||
void Auswahl_Nichtmetalle() { | void Auswahl_Nichtmetalle() { | ||
for (byte z = 1; z < Ausbaustufe + 1; z++) { | 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)) { | + | 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); | Led_an(z, 1); | ||
} | } | ||
Zeile 317: | Zeile 321: | ||
void Auswahl_fest() { | void Auswahl_fest() { | ||
for (byte z = 1; z < Ausbaustufe + 1; z++) { | 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))) { | + | 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); | Led_an(z, 1); | ||
} | } | ||
Zeile 333: | Zeile 338: | ||
void Auswahl_gas() { | void Auswahl_gas() { | ||
for (byte z = 1; z < Ausbaustufe; z++) { | 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)) { | + | 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); | Led_an(z, 1); | ||
} | } | ||
Zeile 360: | Zeile 366: | ||
void Auswahl_Programm_x() { // 201 | void Auswahl_Programm_x() { // 201 | ||
// z. Zt. Dimmer-Test | // z. Zt. Dimmer-Test | ||
− | for ( | + | // delay(5000); |
+ | for (int b = 0; b <= 255; b = b + 15) | ||
{ | { | ||
Dimmer(b); | Dimmer(b); | ||
Led_an(1, 1); | Led_an(1, 1); | ||
− | delay( | + | delay(3000); |
} | } | ||
Led_an(1, 0); | Led_an(1, 0); | ||
Zeile 385: | Zeile 392: | ||
} | } | ||
// ********************************************************************** | // ********************************************************************** | ||
− | void Dimmer(byte | + | void Dimmer(byte Helligkeit) // 0 to 255 |
// Funktion merkt sich Helligkeitswert für LEDs, ausbaubedingt z. Zt. nur am 1. Schieberister | // Funktion merkt sich Helligkeitswert für LEDs, ausbaubedingt z. Zt. nur am 1. Schieberister | ||
// 0 = dunkel, weil 0% Einschaltdauer, 255 = volle Leistung, weil 100% ED | // 0 = dunkel, weil 0% Einschaltdauer, 255 = volle Leistung, weil 100% ED | ||
{ | { | ||
− | analogWrite(outputEnablePin, 255 - | + | analogWrite(outputEnablePin, 255 - Helligkeit); |
} | } | ||
// ********************************************************************** | // ********************************************************************** | ||
Zeile 414: | Zeile 421: | ||
// TO DO: switch Element/LED, z. B. bei Element 11 (Natrium) die 3. Led schalten | // TO DO: switch Element/LED, z. B. bei Element 11 (Natrium) die 3. Led schalten | ||
// patch it: | // patch it: | ||
− | + | if (patchmodus) { | |
+ | Element = patch[Element]; | ||
+ | } | ||
zyklus = 0; // Schlafmodus beenden | zyklus = 0; // Schlafmodus beenden | ||
Laufzeit_hhmmss(); | Laufzeit_hhmmss(); | ||
Zeile 552: | Zeile 561: | ||
client.println("<HEAD>"); | client.println("<HEAD>"); | ||
// charset=utf-8 | // charset=utf-8 | ||
− | + | // TO DO: Weiterleitung vorerst aus, bei QR-Code zurücksetzen auf "if (Auswahl != 222) {" | |
+ | if (Auswahl != 222) { | ||
// Weiterleitung an Elementseite auf bs-wiki: | // Weiterleitung an Elementseite auf bs-wiki: | ||
client.print("<meta http-equiv=\"refresh\"content=\"0; URL="); | client.print("<meta http-equiv=\"refresh\"content=\"0; URL="); | ||
Zeile 565: | Zeile 575: | ||
client.println("</HEAD>"); | client.println("</HEAD>"); | ||
client.println("<BODY>"); | client.println("<BODY>"); | ||
− | + | client.println("<p class='monospace'>"); | |
− | + | client.println("<H1>Periodensystem der Elemente</H1>"); | |
− | + | client.println("<hr />"); | |
− | + | client.println("<br />"); | |
// client.println("<H2>Led auswählen</H2>"); | // client.println("<H2>Led auswählen</H2>"); | ||
// client.println("<br />"); | // client.println("<br />"); |
Version vom 7. Mai 2015, 00:22 Uhr
// ********************************************************************** // interaktives Periodensystem der Elemente // schaltet gewünschte LED an // Detlef Giesler // BBS Winsen (Luhe) // ********************************************************************** // letzte Änderungen: // 06.05.2015: Patch Panel aktiviert TO DO: 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 // 28.04.2015: Abfrage der seriellen Schnittstelle // ********************************************************************** // TO DOs: // for-Schleife: Bedingung "Laufindex < Ausbaustufe" ersetzen durch "L. < A. +1", sonst fehlt der letzte Wert // Startwert i.d.R. 1, 0 soll unbenutzt bleiben // // **********************************************************************
- include <SPI.h>
- include <Ethernet.h>
// globale Variablen: 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") // Aufruf dann z. B. über http://192.168.178.104/?z=4 // "Arduino an IP 192..., schalte Led Nr. 4 an!" // Aufruf dann z. B. über http://192.168.178.104/?z=222 // "Arduino an IP 192..., zeige Auswahl an!" 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; String URL = "http://www.bs-wiki.de/mediawiki/index.php?title=";
// Pinning Arduino & Schieberegister: // Arduino-Pin 3 als "Dimmer" verbunden mit OE des 74HC595 (dort Pin 13, Output Enable) byte outputEnablePin = 3; // Arduino-Pin 8 als shiftPin verbunden mit SH_CP des 74HC595 (dort Pin 11, shift register clock input) byte shiftPin = 8; // Arduino-Pin 9 verbunden mit ST_CP des 74HC595 (dort Pin 12, storage register clock input = latch pin) byte storePin = 9; // Arduino-Pin 10 verbunden mit DS des 74HC595 (dort Pin 14, serial data input) byte dataPin = 10;
// Elemente und LEDs: // 32 ist die derzeitige Ausbaustufe, am Ende 144 LEDs // Hardware-Info: 12m²-PSE aus 6 Teildisplays, 144/6 = 24 LEDs/Teildisplay, // ... jedes Teildisplay angesteuert durch 3x8 Datenleitungen (3 Spalten, 8 Zeilen), // ... pro Spalte ein 8-bit-Schieberegister = 18 SR insgesamt byte Ausbaustufe = 32; // TO DO: vorerst ohne Patchen boolean patchmodus = 0; // Auswahl // Ordnungszahl definiert Element 1...118 byte Auswahl = 0; // 0 = existiert nicht // 1 = Wasserstoff, 2 = Helium ... // 131...137 = 1. - 7. Periode // 141...148 = 1. - 8. Hauptgruppe // 160 = Metalle // 161 = Halbmetalle // 162 = Nichtmetalle // 190 = fest // 191 = flüssig // 192 = gasförmig // 193 = radioaktiv // 194 = biatomar // 200 = Bingo // 201 = Programm_x // 202 = Programm_y // 203 = Programm_z // 222 = Browserfenster umschalten auf Arduino-Auswahlmenü // 254 = alles_aus // 255 = alles_an
boolean led[144]; unsigned int led_aus[144]; // virtuelles Patchpanel: Zuordnung Ordungszahl/Pin, z. B. Natrium mit OZ 11 an *Pin 3*: byte Element_an_Pin[144] = {
// Pinning ohne eine "Led #0" //p1p2*p3*p4 p5 p6 p7 p8 - p9 p10 p11 p12 p13 p14 p15 p16 -p17 p18 p19 p20 p21 p22 p23 p24- 1, 3, 11, 19, 37, 55, 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
}; // Element_an_Pin[] nach steigender Ordungszahl notieren: // TO DO wg. Speicherproblemen vorerst aus: byte patch[144];
byte Anzahl_angeschaltete_LEDs = 0; unsigned int t_gesamt_in_sek = millis() / 1000; // TO DO: über Poti einstellen und von Pin einlesen oder über Webinterface byte Eieruhr = 20; // Vorgabe der Einschaltdauer einer LED in Sekunden int zyklus = 0; // loop-Zyklen // Debugging int bremse = 1; // 1 ... 60000 Standardwert für Entschleunigung in ms zwischen einigen Befehlen zwecks Debugging // ********************************************************************** void setup() {
Dimmer(127); // halbe Helligkeit = halbe Stromstärke Serial.begin(9600); // Kontrollausgabe über seriellen Monitor // Pin 5 abfragen (analog, EMK) für Zufallszahl // randomSeed(analogRead(5)); // Pins 3, 8,9,10 auf Ausgabe pinMode(outputEnablePin, OUTPUT); // Dimmer 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 = 1; z < 144 + 1; 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]); // } // } // für Testphase LEDs im setup einschalten, später in loop: // Element = 7; // blau
Led_an(7, 1); delay(bremse); Serial.println("alle_Elemente_an"); Auswahl_alles_an(); Serial.println("alle_Elemente sind an"); delay(bremse); Serial.println("alle_Elemente_aus"); Auswahl_alles_aus(); Serial.println("alle_Elemente sind aus"); delay(bremse); Legende_an(); Serial.println("jetzt startet die loop-Schleife ......"); Serial.println("--------------------------------------"); delay(bremse);
} // ********************************************************************** void loop () {
zyklus = zyklus + 1; Serial.print(zyklus); Serial.println(". Loop"); // vergesse die bisherige Auswahl, LED nicht erneut anschalten: Auswahl = 0; // horche an der seriellen Schnittstelle und am Ethernet-Shield // erfrage Element; nach Ordnungszahl o. ä. auswählen: // z.B. Nr. 1 - Wasserstoff: www(); while (Serial.available() > 0) { Serial.println("Ich bin www-taub!"); byte a = 0; { Auswahl = Auswahl * 10; a = Serial.read() - '0'; Auswahl = Auswahl + a; delay(1); } Serial.write(Auswahl); } delay(bremse); switch (Auswahl) { case 1 ... 118: Led_an(Auswahl, 1); break; case 131 ... 139: Auswahl_Periode(); break; // = 1. - 7. Periode, Lanthanoide, A. case 141 ... 148: Auswahl_Hauptgruppe(); break; // = 1. - 8. Hauptgruppe case 160: Auswahl_Metalle(); break; case 161: Auswahl_Halbmetalle(); break; case 162: 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 222: www(); break; case 254: Auswahl_alles_aus(); break; case 255: Auswahl_alles_an(); break; default: // unbelegte Zahlen sind unsinnig und werden genullt: Serial.print("KOMISCHE Auswahl: "); Serial.println(Auswahl); Auswahl = 0; delay(bremse); } // TO DO: wenn Legende mit mehreren LED hinterleuchtet wird, diese Anzahl statt der "1" einsetzen: if (Anzahl_angeschaltete_LEDs > 1) { Treppenlicht(); } if (zyklus > 500) { // 999 // 1000-mal is nichts passiert, daher: Auswahl_alles_aus(); //TO DO: ggf. Sleep-Modus mit Bewegungsmelder zum Reaktivieren } Serial.println("------------------------------------"); delay(bremse);
} // ********************************************************************** // ############### Funktionen nach ABC ############################## // ********************************************************************** void Auswahl_alles_an() {
for (byte z = 1; z < Ausbaustufe + 1; z++) { Led_an(z, 1); }
} // ********************************************************************** void Auswahl_alles_aus() {
// schaltet alle LEDs außer die für die Legende aus for (byte z = 1; z < Ausbaustufe + 1; z++) { Led_an(z, 0); } Legende_an();
} // ********************************************************************** void Auswahl_biatomar() {
Serial.println("Auswahl_biatomar"); for (byte z = 1; z < Ausbaustufe + 1; z++) { if ((z == 1) || (z == 7) || (z == 8) || (z == 9) || (z == 17) || (z == 35) || (z == 53) || (z == 138) ) { Led_an(z, 1); } }
} // ********************************************************************** void Auswahl_Bingo() {
Serial.println("Elemente-Bingo"); byte zufall = random(1, Ausbaustufe); // setzt 'zufall' mit einer Zufallszahl // zwischen 1 und Ausbaustufe gleich Serial.print("Zufalls-Element: "); Serial.println(zufall); Led_an(zufall, 1); delay(bremse);
} // ********************************************************************** void Auswahl_Hauptgruppe() {
switch (Auswahl) { case 141: // 1. Hauptgruppe Led_an(1, 1); Led_an(3, 1); Led_an(11, 1); Led_an(19, 1); Led_an(37, 1); Led_an(55, 1); Led_an(87, 1); break; case 142: // 2. Hauptgruppe Led_an(4, 1); Led_an(12, 1); Led_an(20, 1); Led_an(38, 1); Led_an(56, 1); Led_an(88, 1); break; case 143: // 3. Hauptgruppe Led_an(5, 1); Led_an(13, 1); Led_an(31, 1); Led_an(49, 1); Led_an(81, 1); Led_an(113, 1); break; case 144: // 4. Hauptgruppe Led_an(6, 1); Led_an(14, 1); Led_an(32, 1); Led_an(50, 1); Led_an(82, 1); Led_an(114, 1); break; case 145: // 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 146: // 6. Hauptgruppe Led_an(8, 1); Led_an(16, 1); Led_an(34, 1); Led_an(52, 1); Led_an(84, 1); Led_an(116, 1); break; case 147: // 7. Hauptgruppe Led_an(9, 1); Led_an(17, 1); Led_an(35, 1); Led_an(53, 1); Led_an(85, 1); Led_an(117, 1); break; case 148: // 7. 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_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)) { Led_an(z, 1); } }
} // ********************************************************************** void Auswahl_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)) { Led_an(z, 1); } }
} // ********************************************************************** void Auswahl_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)) { Led_an(z, 1); } }
} // ********************************************************************** void Auswahl_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))) { Led_an(z, 1); } }
} // ********************************************************************** void Auswahl_liquid() {
for (byte z = 1; z < Ausbaustufe + 1; 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_Periode() {
byte anfang; byte ende; switch (Auswahl) { case 131: anfang = 1; ende = 2; break; // 1. Periode: 1-H, 2-He case 132: anfang = 3; ende = 10; break; case 133: anfang = 11; ende = 18; break; case 134: anfang = 19; ende = 36; break; case 135: anfang = 37; ende = 54; break; case 136: anfang = 55; ende = 86; break; case 137: anfang = 87; ende = 118; break; // 7. Periode: Fr-Uuo case 138: anfang = 57; ende = 71; break; // Lanthanoide case 139: anfang = 89; ende = 103; break; // Actinoide } for (byte z = anfang; z < ende + 1; z++) { Led_an(z, 1); }
} // ********************************************************************** void Auswahl_Programm_x() { // 201
// z. Zt. Dimmer-Test // delay(5000); for (int b = 0; b <= 255; b = b + 15) { Dimmer(b); Led_an(1, 1); delay(3000); } Led_an(1, 0);
} // ********************************************************************** void Auswahl_Programm_y() {
} // ********************************************************************** void Auswahl_Programm_z() {
} // ********************************************************************** void Auswahl_radioaktiv() {
for (byte z = 1; z < Ausbaustufe + 1; z++) { if ((z == 43) || (z == 61) || ((z >= 84) && (z <= 118)) || (z == 134) || (z == 136)) { Led_an(z, 1); } }
} // ********************************************************************** void Dimmer(byte Helligkeit) // 0 to 255 // Funktion merkt sich Helligkeitswert für LEDs, ausbaubedingt z. Zt. nur am 1. Schieberister // 0 = dunkel, weil 0% Einschaltdauer, 255 = volle Leistung, weil 100% ED {
analogWrite(outputEnablePin, 255 - Helligkeit);
} // ********************************************************************** 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) {
// Funktion schaltet eine durch (Element) bestimmte LEDs an oder aus, // plant einen Ausschaltpunkt (led_aus[Element]) und merkt sich die Anzahl_angeschaltete_LEDs. // TO DO: switch Element/LED, z. B. bei Element 11 (Natrium) die 3. Led schalten // patch it: if (patchmodus) { Element = patch[Element]; } zyklus = 0; // Schlafmodus beenden Laufzeit_hhmmss(); Serial.print(Element); Serial.print(". LED wird geschaltet von "); Serial.print(led[Element]); Serial.print(" -> "); Serial.println(an); // TO DO: wenn Ausbaustufe 144 erreicht, diese LEDs immer anlassen: // solange Ausbaustufe 144 noch nicht erreicht, ersatzweise Led #9: // for (byte z = 121; z < 139; z++) { // if ((Element > 0) && (Element < Ausbaustufe + 1) && ((Element < 9) || (Element > 9))) { // 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 = 1; z < Ausbaustufe + 1; z++) { if (led[z]) { 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] = t_gesamt_in_sek + Eieruhr; // vormerken: LED nach (Eieruhr) Sek. wieder ausschalten } resetPins(); // digitalWrite(storePin, LOW); for (byte i = 1; i < Ausbaustufe + 1; 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 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(bremse); // Serial.print(Element); // Serial.print(". LED ist "); // Serial.println(an); Serial.println("--------------------"); delay(bremse);
} // ********************************************************************** void Legende_an() {
// TO DO: solange Ausbaustufe 144 noch nicht erreicht, ersatzweise Led #9: Led_an(9, 1); // wenn Ausbaustufe 144 erreicht, diese LEDs immer anlassen: // for (byte z = 121; z < 139; z++) { // Led_an(z, 1); // }
} // ********************************************************************** 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 + 1; z++) { if (led[z]) { Serial.print("t_gesamt_in_sek: "); Serial.println(t_gesamt_in_sek); Serial.print("led_aus[z]): "); Serial.println(led_aus[z]); // max. Einschaltzeit überschritten? if (t_gesamt_in_sek > led_aus[z]) { Led_an(z, 0); } } } delay(bremse); Legende_an(); Serial.println();
} // ********************************************************************** void www() {
// Create a client connection Serial.print("Ich höre www ..."); EthernetClient client = server.available(); if (client) { while (client.connected()) { if (client.available()) { Serial.println("++++++++++"); 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 debugging // normalerweise kommt von Browser: "GET /z=[pos] HTTP/1.1" int pos = 1 + readString.indexOf('z='); // komischerweise kommt von Handy: "GET /z%3D[pos] HTTP/1.1", daher: if (pos == 0) { pos = 1 + readString.indexOf('z%3D'); } Serial.println(pos); String zahl = readString.substring(pos); Serial.print("Zahl-String:"); Serial.println(zahl); Auswahl = zahl.toInt(); zahl = String(Auswahl); Serial.print("Auswahl:"); Serial.println(Auswahl); // delay(60000); client.println("HTTP/1.1 200 OK"); //send new page client.println("Content-Type: text/html"); client.println(); client.println("<HTML>"); client.println("<HEAD>"); // charset=utf-8 // TO DO: Weiterleitung vorerst aus, bei QR-Code zurücksetzen auf "if (Auswahl != 222) {" if (Auswahl != 222) { // Weiterleitung an Elementseite auf bs-wiki: client.print("<meta http-equiv=\"refresh\"content=\"0; URL="); client.print(URL); client.print(zahl); client.println("\">"); } else { // 222: Browserfenster umschalten auf Arduino-Auswahlmenü client.println("<style>p{font:16px/1.5em;}.monospace{font-family: monospace;}</style>"); client.println("<TITLE>Periodensystem der Elemente</TITLE>"); client.println("</HEAD>"); client.println("<BODY>");client.println("
"); client.println("
Periodensystem der Elemente
"); client.println("");
client.println("// client.println("
");
Led auswählen
");// client.println("// client.println(""); // client.println("
"); // for (int z = 1; z < 256; z++) { // client.print("<a href=\"/?z="); // client.print(z); // client.print("\"\">[ "); // client.print(z); // client.println(" ]</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>
");
Created by Detlef Giesler. Visit <a href='http://www.bs-wiki.de'>bs-wiki.de</a> 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 = ""; } } } }
}