Arduino UNO V3 Programmcode

Hier findest Du alle Programmcodes begleitend zum Buch

 

 

Das Buch kannst Du be ePubli erwerben:

https://www.epubli.de/preview/130629

 

Da die Vorschau auf ePubli nicht besonders gut funktioniert – sorry, mit LowCarb oder wie diese Vegetarier heissen, damit hab ich nix zu tun – hier ein Auszug:

 

Arduino1_Auszug

 

Programm-Downloads (abtippen is nich)

Arduino

 

Für Insider (Passwortgeschützt)

Buch

 

Videos:

 

 

 

 

Das Highlight, die perfekte Uhr (vergiss das perfekt gleich wieder, sie hat in 100 Jahren ca. 2 Sekunden Abweichung)

/*
7-Segment LED Anzeige Rot
—A—
| |
F B
| |
—G—
| |
E C
| |
—D—

*/
//———————————————————- Deklarationen —————————————————————-
//Definiere Ausgänge
#define A 6
#define B 5
#define C 4
#define D 3
#define E 2
#define F 1
#define G 0
#define DP 7 // Dezimalpunk
#define common_cathode 0
#define common_anode 1
bool segMode = common_cathode; // Negative oder positive Darstellung (LCD oder LED), je nach Anzeige-Typ (common_cathode oder common_anode)
int seg[] {A,B,C,D,E,F,G,DP}; // Segment-Pins 6 – 0
byte chars = 35; // Anzahl Zeichen für nachfolgendes Array Chars

byte Chars[35][9] {
{‚0‘,1,1,1,1,1,1,0,0}, //0
{‚1‘,0,1,1,0,0,0,0,0}, //1
{‚2‘,1,1,0,1,1,0,1,0}, //2
{‚3‘,1,1,1,1,0,0,1,0}, //3
{‚4‘,0,1,1,0,0,1,1,0}, //4
{‚5‘,1,0,1,1,0,1,1,0}, //5
{‚6‘,1,0,1,1,1,1,1,0}, //6
{‚7‘,1,1,1,0,0,0,0,0}, //7
{‚8‘,1,1,1,1,1,1,1,0}, //8
{‚9‘,1,1,1,1,0,1,1,0}, //9
{‚a‘,1,1,1,0,1,1,1,0},//A/10
{‚b‘,0,0,1,1,1,1,1,0},//b/11
{‚c‘,1,0,0,1,1,1,0,0},//C/12
{‚d‘,0,1,1,1,1,0,1,0},//d/13
{‚e‘,1,0,0,1,1,1,1,0},//E/14
{‚f‘,1,0,0,0,1,1,1,0},//F/15
{‚g‘,1,0,1,1,1,1,0,0},//G/16
{‚h‘,0,1,1,0,1,1,1,0},//H/17
{‚i‘,0,0,0,0,1,1,0,0},//I/18
{‚j‘,0,1,1,1,1,0,0,0},//J/19
{‚l‘,0,0,0,1,1,1,0,0},//L/20
{‚n‘,0,0,1,0,1,0,1,0},//n/21
{‚o‘,0,0,1,1,1,0,1,0},//o/22
{‚p‘,1,1,0,0,1,1,1,0},//P/23
{‚q‘,1,1,1,0,0,1,1,0},//q/24
{‚r‘,0,0,0,0,1,0,1,0},//r/25
{‚s‘,1,0,1,1,0,1,1,0},//S/26 looks like number 5
{‚t‘,0,0,0,1,1,1,1,0},//t/27
{‚u‘,0,1,1,1,1,1,0,0},//U/28
{‚y‘,0,1,1,1,0,1,1,0},//y/29
{‚-‚,0,0,0,0,0,0,1,0},//-/30
{‚.‘,0,0,0,0,0,0,0,1},//./31
{‚]‘,1,1,1,1,0,0,0,0},//]/32
{‚[‚,1,0,0,1,1,1,0,0},//[/33
{‚_‘,0,0,0,1,0,0,0,0},//_/34
};

unsigned long time_in_milliseconds = 0; //Zeitvariable in Millis
unsigned long time_correction_millis = 0; //Korrekturvariable, da Arduino UNO ungefähr nach 50 Tagen die millis() auf 0 zurückstellt
unsigned int plus_hours = 0; // Zeiteinstellung auf aktuelle Uhrzeit
unsigned int plus_minutes = 0; // Zeiteinstellung auf aktuelle Uhrzeit Korrektur-Minuten
unsigned int plus_seconds = 0; // Zeiteinstellung auf aktuelle Uhrzeit Korrektur-Sekunden
unsigned int plus_milliseconds = 0; // Zeiteinstellung auf aktuelle Uhrzeit Korrektur-Millisekunden
unsigned int hours = 0; // Stunden für Zeit
unsigned int minutes = 0; // Minuten für Zeit
unsigned int seconds = 0; // Sekunden für Zeit
unsigned int milliseconds = 0; // Millisekunden z.B. für Stop-Uhr
char timestamp = „23:59:59:999“; // Zusammengestellter Zeitstempel
int x; // Funktionsaufruf für globale Zeiteinstellung
//const int key[] = {8,9,10,11,12,13}; //Stelle 0 ist ganz rechts
int count = 0;
long stay_on = 0;
unsigned long time_reset_key = 0;
int seg_pin[] = {8,9,10,11,12,13}; //Block-Nr, bestehend aus 2 Ziffern (7-Segment-Anzeigen)
//int ziff_nr[] = {12,13}; //Ziffer-Nummer 1 = vordere, 2 = hintere
int key_analog_pin = A0;
int analog_value; //Übergabevatiable
int display_mode; //Wählt aus, was angezeigt wird:
//0 = Uhr, 1 = Korrektur Stunden, 2 = Korrektur Minuten, 3 = Korrektur Sekunden,
//4 = Temparatur 5 = Licht und andere (ausgabe 0 – 1024
//—————————————————— Ende Deklarationen —————————————————-

//——————————————————– Initialisiere ——————————————————-
void setup() {
// Pins als OUTPUT definieren
pinMode(seg[0],OUTPUT);
pinMode(seg[1],OUTPUT);
pinMode(seg[2],OUTPUT);
pinMode(seg[3],OUTPUT);
pinMode(seg[4],OUTPUT);
pinMode(seg[5],OUTPUT);
pinMode(seg[6],OUTPUT);
pinMode(seg[7],OUTPUT);
pinMode(seg_pin[0],OUTPUT);
pinMode(seg_pin[1],OUTPUT);
pinMode(seg_pin[2],OUTPUT);
pinMode(seg_pin[3],OUTPUT);
pinMode(seg_pin[4],OUTPUT);
pinMode(seg_pin[5],OUTPUT);

}
//—————————————————— Ende Inistialisierung ————————————————

//—————————————————— Hauptprogramm ————————————————

void loop() {

x = get_time(‚all‘); // Fülle alle globalen Variablen ab
x = get_analog_value(); //hole den analogen Wert
if (display_mode == 0) {
Print_Two_Digits(hours, „hours“, false);
Print_Two_Digits(minutes, „minutes“, false);
Print_Two_Digits(seconds, „seconds“, false);
}

if (display_mode == 4) {
x = scale_temperatur();
x = print_to_display(x);
}
if (display_mode == 5) {
x = print_to_display(analog_value); //gebe den Wert des Analogen eingangs zurück
//x = print_to_display(123456); //Test-String, falls Du Probleme haben solltest
}

if (display_mode == 1) {
x = Print_Two_Digits(plus_hours, „hours“, false);
}

if (display_mode == 2) {
x = Print_Two_Digits(plus_minutes, „minutes“, false);
}

if (display_mode == 3) {
x = Print_Two_Digits(plus_seconds, „seconds“, false);
}

//Prüfe auf Key-Status
x = change_analog_key_status();

}
//—————————————————— Ende Hauptprogramm ————————————————

//———————————————————- Funktionen ——————————————————
void setState(bool mode){ //Stelle Zeichen dar im Modus mode, also positiv oder negativ
for(int i = 0;i<=6;i++)
{
digitalWrite(seg[i],mode);
}
}

 

void Print(int num) // Ausgabe auf die 7-Segment Anzeige
{
setState(segMode);//Segment ausschalten

if(num > chars || num < 0 )// Falls die Nummer bzw. das Zeichen nicht definiert ist…
{
for(int i = 0;i <= 6;i++)
{
digitalWrite(seg[i],HIGH);
delay(100);
digitalWrite(seg[i],LOW);
}
for(int i = 0;i <= 2;i++)
{
delay(10);
setState(HIGH);
delay(10);
setState(LOW);
}
}else // sonst, falls Zeichen bzw. Nummer definiert, dann ausgeben
{
if(segMode == 0){ //…entsprechend segMode ausgeben (positiv oder negativ)
for(int i = 0;i<8;i++){
digitalWrite(seg[i],Chars[num][i+1]);
}

//Kontrast oder How-To-Works
x = kontrast(num);

//Clear
for(int i = 0;i<8;i++){
digitalWrite(seg[i],LOW);
}
}
else{
//setState(HIGH);
for(int i = 0;i<8;i++){
digitalWrite(seg[i],!Chars[num][i+1]);
digitalWrite(seg[i],HIGH);
}
}
}
}

int kontrast(int num){
//Gleichmässiges Anzeigen der Zahlen, 7 und 1 sind nur wenige LEDs eingeschaltet
if (num == 1 || num == 7){
delay(1);
return;
}
delay(3);

}

int Print_Two_Digits(int two_digits_wert, char modus[], boolean one_segment){
// modus = „nothing“ –> keine Anzeige des Modus
// modu = „hours“, „minutes“, „seconds“ zeigt vor der Anzeige an, welcher Wert ausgegeben wird
int digit_links = 0;
int digit_rechts = 0;
int modus_char = 30;
int seg_pin_out = 0; //Der Pin für die Ausgabe

//Zeige Modus an, falls übergeben //h anzeigen
if (modus == „hours“) {
modus_char = 17;
seg_pin_out = seg_pin[4]; //Ertes Segment aktivieren
}
if (modus == „minutes“) { //Anzeige n, da m nicht angezeigt werden kann
modus_char = 21;
seg_pin_out = seg_pin[2];
}
if (modus == „seconds“) { //s anzeigen
modus_char = 26;
seg_pin_out = seg_pin[0];
}

//Teile Anzeige auf 2 Digits auf
if (two_digits_wert >= 10) {
digit_links = two_digits_wert / 10;
digit_rechts = two_digits_wert – digit_links * 10;
} else {
digit_rechts = two_digits_wert;
}

x = clear_all_seg();

//Gebe auf einer 7-Segment-Anzeige zwei Zahlen aus
if (one_segment == true) { //Nur anzeigen, falls nur auf einer Digit angezeigt wird
Print(modus_char);
delay(500);
}
digitalWrite(seg_pin_out + 1,HIGH);
Print(digit_links);
if (one_segment == true) {
delay(1000);
}
digitalWrite(seg_pin_out + 1,LOW);

digitalWrite(seg_pin_out,HIGH);

Print(digit_rechts);

if (one_segment == true) {
delay(1000);
}
digitalWrite(seg_pin_out,LOW);

//Leer bzw. Punkt
if (one_segment == true) {
digitalWrite(seg_pin_out,HIGH);
Print(31);
delay(1000);
}
}

int clear_all_seg() {
digitalWrite(seg_pin[0] ,LOW);
digitalWrite(seg_pin[1] ,LOW);
digitalWrite(seg_pin[2] ,LOW);
digitalWrite(seg_pin[3] ,LOW);
digitalWrite(seg_pin[4] ,LOW);
digitalWrite(seg_pin[5] ,LOW);
}

int get_time(char modus[]) {
//Korrektur-Routine, weil das Arduino UNO ungefähr nach 50 Tagen die millis() auf 0 zurückstellt
//time_correction_millis = check_if_reset_time(time_in_milliseconds);
time_in_milliseconds = millis() + time_in_millis(plus_hours,“hours“) + time_in_millis(plus_minutes,“minutes“) + time_in_millis(plus_seconds,“seconds“) + plus_milliseconds + time_correction_millis; // Lade die aktuelle Prozessorzeit inkl. Korrektur
hours = convert_time(time_in_milliseconds,“24_hours“);
minutes = convert_time(time_in_milliseconds,“60_minutes“);
seconds = convert_time(time_in_milliseconds,“60_seconds“);

return hours;
}

unsigned long time_in_millis(long time_value, char calc_modus[]) {
//Faktor für Umrechnung
long t_millis = 0; //Standardmässig gleichen Wert zurückgeben

if (calc_modus == „hours“) {
// Stunden in Milllisekunden umrechnen
t_millis = time_value * 60 * 60 * 1000;
}
if (calc_modus == „minutes“) {
// Minuten in Milllisekunden umrechnen
t_millis = time_value * 60 * 1000;
}
if (calc_modus == „seconds“) {
// Minuten in Milllisekunden umrechnen
t_millis = time_value * 1000;
}

return t_millis;
}

unsigned int convert_time(unsigned long t_millis,char conv_modus[]) {
//Konvertiere eine Zeit in Millisekunden zu modus: Tage ‚days‘, Stunden ‚hours‘ ’24_hours‘, Minuten ‚minutes‘ ’60_minutes‘, Sekunden ‚seconds‘ ’60_seconds‘, ‚millis‘ ‚1000_millis‘
// 60_ bzw. 1000_ gibt nur die Zeitangabe zurück, die für eine Uhr korrekt ist, also z.B. Sekunden zwischen 0 – 59

unsigned long days_tmp;
unsigned long hours_tmp;
unsigned long minutes_tmp;
unsigned long seconds_tmp;
unsigned long conv_return; //Rückgabewert

// Stunden pro Tag max. 23 (:59:59:999)
if (conv_modus == „hours“) {
conv_return = t_millis / 1000 / 60 / 60;
//return 17; //h zurückgeben
return conv_return;
}

if (conv_modus == „minutes“) {
conv_return = t_millis / 1000 / 60;
//return 21; //m bzw. n für Minuten zurückgeben
return conv_return;
}

if (conv_modus == „seconds“) {
conv_return = t_millis / 1000;
//return 26; //s für Ekunden zurückgeben
return conv_return;
}

if (conv_modus == „millis“) {
return t_millis;
}

if (conv_modus == „days“) {
conv_return = t_millis / 24 / 1000 / 60 / 60;
return conv_return;
}

if (conv_modus == „24_hours“) { //Geber nur die aktuelle Stunde zurück
days_tmp = convert_time(t_millis, „days“);
conv_return = t_millis – days_tmp * 24 * 1000 * 60 * 60;
conv_return = convert_time(conv_return,“hours“);
return conv_return;
}

if (conv_modus == „60_minutes“) { //Gebe nur die aktuellen Minuten zurück
hours_tmp = convert_time(t_millis, „hours“);
conv_return = t_millis – hours_tmp * 1000 * 60 * 60;
conv_return = convert_time(conv_return,“minutes“);
return conv_return;
}

if (conv_modus == „60_seconds“) {
minutes_tmp = convert_time(t_millis,“minutes“);
conv_return = t_millis – minutes_tmp * 1000 * 60;
conv_return = convert_time(conv_return, „seconds“);
return conv_return;
}

if (conv_modus == „1000_millis“) {
seconds_tmp = convert_time(t_millis,“seconds“);
conv_return = t_millis – seconds_tmp * 1000;
conv_return = convert_time(conv_return, „millis“);
return conv_return;
}

return 14; // E für Error / Fehler ausgeben

}

unsigned long check_if_reset_time (unsigned long last_time_in_millis){
unsigned long time_correction = 0;

if (last_time_in_millis > millis()) { //Falls Millis auf 0 zurückgestellt
//Verbesserungshinweis: Es könnte eine Differenz im Millisekunden-Bereich entstehen!!!!
time_correction = get_day_millis(last_time_in_millis);

//Korrekturzeiten auf 0 zurückstellen, da die Korrektur in der time_correction enthalten ist
plus_hours = 0;
plus_minutes = 0;
plus_seconds = 0;
plus_milliseconds = 0;

return time_correction;

} else {
return time_correction_millis; //Falls keine Korrektur, dann bestehende Korrektur als Wert zurückgeben
}
}

unsigned long get_day_millis(unsigned long t_millis_total){
// Eliminiere Volle Tage zu 86 400 000 Millisekunden
long millis_pro_tag = 24 * 60 * 60 * 1000;
int ganze_tage = t_millis_total / millis_pro_tag – 0.5; //Runde auf ganze Tage, 40.5 Tage würde 41, also – 0.5. 40 Tage wird so zu 39.5 und wird auf 40 aufgerundet
long millis_ganze_tage = ganze_tage * millis_pro_tag;
return (t_millis_total – millis_ganze_tage); //Gebe Zeit in Millisekunden des angebrochenen Tages zurück

}

boolean key_pressed(int k_pin){
if (digitalRead(k_pin) == LOW) { //Taster ist nicht gedrückt
if (count > 200) {
count = 0;
stay_on = 0;
}

} else { //Falls Taster gedrückt ist, Pin key[] ist HIGH / 5 Volt
stay_on = 1;
count = count + 1;
time_reset_key = millis();
}

if (time_reset_key + 1000 < millis()) {
count = 0;
stay_on = 0;
digitalWrite(3, LOW);
}

if (stay_on == 2) {
digitalWrite(3, HIGH);
return false; //Falls Taste bedreits Gedrückt, Prellen unterdrücken und False zurückgeben
}

if (stay_on == 1) {
//digitalWrite(2, HIGH);
stay_on = 2;
return true;
} else {
//digitalWrite(2, LOW);
return false;
}

}

int get_analog_value() {
analog_value = analogRead(key_analog_pin); // Gibt 1024 Werte zurück (0 kein Strom – 1023 5V)
return analog_value; //Für Direktaufruf Wert zurückgeben, wird aber auch in analog_value global zur Verfügung gestellt

}

int print_to_display(long output_value){
//verwende Print_Two_Digits zur Ausgabe sämtlicher 6 Digits
//Print_Two_Digits(hours, „hours“, false);
//Print_Two_Digits(minutes, „minutes“, false);
//Print_Two_Digits(seconds, „seconds“, false);

int right_two_digits;
int mid_two_digits;
int left_two_digits;

//isoliere die linken zwei Digits
x = output_value / 100;
right_two_digits = output_value – x * 100;

//isoliere die rechten zwei Digits
left_two_digits = output_value / 10000;

//isoliere Rest = mittlere zwei Digits
mid_two_digits = output_value – left_two_digits * 10000 – right_two_digits; //z.B.3200 für 32, muss noch durch 100 geteilt werden
mid_two_digits = mid_two_digits / 100;

//Print_Two_Digits(left_two_digits, „hours“, false);
//Print_Two_Digits(mid_two_digits, „minutes“, false);
//Print_Two_Digits(right_two_digits, „seconds“, false);

Print_Two_Digits(left_two_digits, „hours“, false);
Print_Two_Digits(mid_two_digits, „minutes“, false);
Print_Two_Digits(right_two_digits, „seconds“, false);

}

int change_analog_key_status() {

//Verhindere Doppelanschläge, falls kurzzeitig analog_value == 0
if (analog_value == 0) {
if (stay_on < 2 && stay_on > 0) {
delay(200);
stay_on = stay_on + 1;
return;
} else {
stay_on = 0;
}
}

//Falls SET-Taste, dann Modus wechseln
if (analog_value > 1005 && stay_on == 0) {
stay_on = 1;
display_mode = display_mode + 1;
if (display_mode > 5) {
display_mode = 0;
}
}

//Je nach SET-Modus werden Werde geändert
if (analog_value > 600 && analog_value < 800 && stay_on == 0) {
stay_on = 1;

//Korrigiere Zeit
if (display_mode == 1) {
plus_hours = plus_hours + 1;
delay(200);
if (plus_hours >= 23) {
plus_hours = 0;
}
}
if (display_mode == 2) {
plus_minutes = plus_minutes + 1;
delay(200);
if (plus_minutes >= 59) {
plus_minutes = 0;
}
}
if (display_mode == 3) {
plus_seconds = plus_seconds + 1;
delay(200);
if (plus_seconds >=59) {
plus_seconds = 0;
}
}
}
}

int scale_temperatur() {
//hier können Werte skaliert werden

int temp;
temp = analog_value / 3;
return temp;
}

//———————————————————- Ende Funktionen —————————————————