Go Down

Topic: verständnis probleme (Read 840 times) previous topic - next topic

Mar 06, 2012, 12:27 pm Last Edit: Mar 28, 2012, 06:00 pm by timmmartus Reason: 1
Hallo hab vor einer Woche hier eine Programmierung gefunden heute wollte ich mit dieser noch ein Paar Sachen versuchen.Ich verstehe aber noch nicht alles ,hab die definitionen die ich verstehe mit hin geschrieben.vielleicht kann mir einer beim rest helfen


Joghurt

Was genau verstehst Du davon nicht? Bitte die entsprechenden Zeilen markieren, sonst dauert das zu lange... ;)

sth77

Setz den Quellcode doch bitte in die entsprechenden Tags: [ code ] Quellcode [ /code ]

Zum Sketch: Wer hat das denn verbrochen?  :D

Was lcd.createChar(...) bewirkt, kann man ja auch schnell in der Hilfe nachlesen. Die zuvor definierten Zeichen werden als benutzerdefinierte Zeichen in die Zeichentabelle aufgenommen. Der Rest ist eigentlich nur einfache Mathematik und beschreibt, an welchen Positionen ausgefüllte Blöcke (lcd.write(255);)zur Balkendarstellung gezeichnet werden müssen, ausgehend von einem Ursprung nach links oder nach rechts. Außerdem wird der Balken noch sauberer abgestuft durch die benutzerdefinierten Zeichen, um große "Blocksprünge" zu vermeiden.
Mein Arduino-Blog: http://www.sth77.de/ - letzte Einträge: Teensy 3.0 - Teensyduino unter Window 7 - Teensyduino unter Windows 8

sth77

#3
Mar 06, 2012, 04:46 pm Last Edit: Mar 06, 2012, 05:18 pm by sth77 Reason: 1
Code: [Select]

#include <Wire.h>                           // Einbetten von Bibliotheken
#include "nunchuck_funcs.h"               // Einbetten von Bibliotheken
#include <LiquidCrystal.h>              // Einbetten von Bibliotheken

LiquidCrystal lcd(12,11,10,7,6,5,4);    // Konfiguration Displayanschluss

byte L1[8] = {B00001,B00001,B00001,B00001,B00001,B00001,B00001,B00001};    // ein dünner Strich, rechtsbündig für Balkendarstellung nach links
byte L2[8] = {B00011,B00011,B00011,B00011,B00011,B00011,B00011,B00011};    // ein mittelstarker Strich, rechtsbündig
byte L3[8] = {B00111,B00111,B00111,B00111,B00111,B00111,B00111,B00111};    // ein schmaler Block, rechtsbündig
byte L4[8] = {B01111,B01111,B01111,B01111,B01111,B01111,B01111,B01111};    // ein breiterer Block, rechtsbündig
byte R1[8] = {B10000,B10000,B10000,B10000,B10000,B10000,B10000,B10000};    // ein dünner Strich, linksbündig für Balkendarstellung nach rechts
byte R2[8] = {B11000,B11000,B11000,B11000,B11000,B11000,B11000,B11000};    // ein mittelstarker Strich, linksbündig
byte R3[8] = {B11100,B11100,B11100,B11100,B11100,B11100,B11100,B11100};    // ein schmaler Block, linksbündig
byte R4[8] = {B11110,B11110,B11110,B11110,B11110,B11110,B11110,B11110};    // ein breiterer Block, linksbündig

byte zero = 115;  // Normalstellung des Lagesensors

void setup(){                      //routine die einmal beim start ausgeführt wird
 nunchuck_setpowerpins();           //stromversorgung
 nunchuck_init();                    //initilisieren nunchuck
 lcd.begin(16,2);                  // initialisieren display
 lcd.createChar(1,L1);          // Sonderzeichen L1 an als benutzerdefiniertes Zeichen 1
 lcd.createChar(2,L2);
 lcd.createChar(3,L3);
 lcd.createChar(4,L4);
 lcd.createChar(5,R1);
 lcd.createChar(6,R2);
 lcd.createChar(7,R3);
 lcd.createChar(8,R4);        // Sonderzeichen R4 an als benutzerdefiniertes Zeichen 8
}

void loop(){                                // Hauptprogramm
 nunchuck_get_data();                 //daten vom nunchuck einlesen
 int accx  = nunchuck_accelx();     // korrigiert: Beschleunigungswert x-Achse in Variable accx schreiben
           
 lcd.setCursor(0,0);                 //position cursor
 lcd.print("Neigung:");              // korrigiert: festen Text schreiben
 lcd.setCursor(13,0);               //position cursor
 lcd.print(accx-zero);              // korrigiert: Normalstellung als Nullstellung, demnach negative Werte für Auslenkung nach links, pos. Werte für Auslenkung rechts
 if (accx<zero+40&&accx>zero-40) showBar(accx);  // Balkenanzeige nur, wenn 75 <= accx <=155, mehr passt sowieso nicht aufs 16x2-Display
 delay (100);             // korrigiert: Aktualisierungsintervall
 lcd.clear ();              //löscht display
}

void showBar (byte w){
 byte col;    // Variable für Spaltenposition
 byte c;      // Variable für Zeichen aus Zeichentabelle    
 if (w==zero){                 // wenn Anzeige in Normalstellung ohne seitl. Auslenkung, dann  
   lcd.setCursor(7,1);       // positioniere Cursor mittig auf dem Display, untere Zeile
   lcd.write (1);              // schreibe benutzerdefiniertes Sonderzeichen 1
   lcd.write (5);              // schreibe benutzerdefiniertes Sonderzeichen 5
 } else {
   if (w<zero){                // wenn seitliche Auslenkung (hier: nach links)
     c=w%5;                    // ganzzahliger Restwert bei Division des Sensorwertes durch 5 (weil Einzelelement 5px breit ist)
     if (c==0) c=255;        // wenn Restwert = 0, dann ist das zu setzende Zeichen ist ein voller Block
     if (c==1) c=4;           // wenn Restwert = 1, dann ist das zu setzende Zeichen ist ein fast voller Block (links fehlt eine Spalte)
     if (c==2) c=3;           // wenn Restwert = 2, dann ist das zu setzende Zeichen ist ein mitteldicker Block (links fehlen zwei Spalte)
     if (c==3) c=2;           // usw. ....
     if (c==4) c=1;           // und so fort. Eine einzelne dünne Linie bleibt
     col=(w-zero+1)/5+7;  // Spaltenbestimmung für
   }
   if (w>zero){                // das selbe in grün, allerdings für Neigung nach rechts, also Sensorwerte größer als Normalstellung
     c=w%5;
     if (c==0) c=255;
     if (c==1) c=5;
     if (c==2) c=6;
     if (c==3) c=7;
     if (c==4) c=8;
     col=(w-zero-1)/5+8;
   }
   // bisher haben wir nur ermittelt, welches Zeichen als Abschlusszeichen des Balkens verwendet wird, jetzt zeichen wir:
   if (col<7){                         // ... bei starker Auslenkung nach links (mehr als ein ganzes Feld über die Mittelstellung hinaus)
     lcd.setCursor (col+1,1);    // position cursor <---- eigentlich ein nichtssagender Kommentar ;)
     for (int i=1; i<=7-col;i++) lcd.write (255);  // ... entsprechend viele fette Blöcke links der Normalstellung
   }  
   if (col>8){  // ... oder bei starker Auslenkung nach rechts
     lcd.setCursor (8,1);        //position cursor
     for (int i=1; i<col-7;i++) lcd.write (255);  // ... entsprechend viele fette Blöcke rechts der Normalstellung
   }  
   lcd.setCursor(col,1);        //position cursor
   lcd.write (c);                 // abschließendes, benutzerdefinierte Sonderzeichen als dünner oder mittlerer Strich, schmaler Block oder breiter Block
 }
}


That's it!

[edit] Noch ein paar Sachen ergänzt...
Mein Arduino-Blog: http://www.sth77.de/ - letzte Einträge: Teensy 3.0 - Teensyduino unter Window 7 - Teensyduino unter Windows 8

sth77

Schau doch nach, von wem du den Code kopiert hast. ;)
Ja, der ist von mir. Wenn du dir den gesamten zugehörigen Thread durchliest, wird dir auffallen, dass alles in kürzester Zeit, also mit der heißen Nadel gestrickt wurde. Daher sind Anpassungen nicht ganz so einfach möglich, die Begrenzung auf 40 Werte nach links und rechts ist ja nur vom LCD abhängig, mit einem 20x2-Display lassen sich auch mehr Werte einstellen. Wer weniger als 40 Werte in eine Richtung haben will, muss eben mit verkürzten Balken leben oedr den Code selbst anpassen. Es ist als proof of cocept zu sehen, mehr nicht.

Mein Arduino-Blog: http://www.sth77.de/ - letzte Einträge: Teensy 3.0 - Teensyduino unter Window 7 - Teensyduino unter Windows 8

alles klar ich schau mal was ich so hinbekomme

eine frage hätte ich an den entwickler noch und zwar sind die ausgegebenen zahlen bei der neigung reale neigungsdaten des sensors bzw die reale schräglage eines objekts in dem der sensor verbaut ist oder sind das nur fiktive zahlen?

mkl0815

Was genau meinst Du damit?
Reale Zahlen, im Sinne von der Wert entspricht dem Neigungswinkel. Ja, sonst wäre das Projekt ja nicht wirklich sinnvoll. Es stellt sich viel mehr die Frage nach der Genauigkeit und damit nach dem Messfehler.

Go Up