next topic »

[on:]

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

[Reply #1 on:]

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

[Reply #2 on:]

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

Zum Sketch: Wer hat das denn verbrochen? 

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.

[Reply #3 on:]

Code:

#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...

[Reply #4 on:]

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.

[Reply #5 on:]

alles klar ich schau mal was ich so hinbekomme

[Reply #6 on:]

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?

[Reply #7 on:]

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.