Nano an I2C Display 1602

Hallo Freunde der Technik,

ich möchte kurz mein Problem vorstellen:

Ein 10-Bit Messwert (0-1023) wird von einem ATTiny 85 (derzeit noch ein Nano) über ein Funkmodul FS1000A an einen Nano mit Empfänger XY-MK-5V gesendet. Die Funkverbindung steht. Nun soll dieser Messwert auch wieder als 10-Bit-Wert auf einem I2C Display 1602 dargestellt werden, also als Zahl zw. 0-1023. Der Messwert kommt ohne Probleme rein und wird sogar am Seriellen Monitor sauber angezeigt, nur das Display zeigt völlig andere Zahlen zw. 48 und 54 an.

Muss ich dem Display den (char)-Wert anders servieren als dem seriellen Monitor?
Das Display wird durch di LiquidChrystal_I2C Bibliothek angesprochen.

Serial.println((char)buf*); → funktioniert*
lcd.print((char)buf*); → funktioniert nicht*
(vorher ist noch eine if-Schleife wo angeblich die Bufferlänge über ‘i’ angepasst wird…)
Ich wäre über Hilfe sehr dankbar und entschuldige mich schon jetzt für alle vergessenen Angaben. Bin ein Neuling auf dem Gebiet.
Beste Grüße

Entweder Du sendest den Meßwert als LOW-Byte und High Byte und baust ihn wieder zusammen oder Du wandelst die Ashii-Kode der Zahlen in einen numerischen Wert um.

Bitte poste doch mal deinen Sketch in Code-Tags (</>).

Dann können wir dir sicher einfach weiter helfen.
Welche Library verwendest du zum senden mit den Funkmodulen?

Ich vermute, du hast da irgend etwas falsch deklariert.
Normalerweise sendet der Sender das Signal als String und der Empfänger setzt das so um, dass du es im SerialMonitor sowie im LCD anzeigen kannst.

Hier mein Sketch für das Empfängermodul (Nano mit Display und Empfänger):

#include <VirtualWire.h>                      // Bibliothek einbinden
#define rxPin 2                               // Pin 2 als Receive-Pin definieren
#undef abs
#undef double
#undef round
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
 
void setup()                                  // Initialisierung
{
    Serial.begin(9600);                       // Serielle Schnittstelle setzen
    pinMode(2,INPUT);                         // Pin 2 als Eingang definiert
    vw_set_ptt_inverted(true);                // Benötigt für RX Link Modul
    vw_setup(1000);                           // Datenrate in Bits pro Sekunde
    vw_set_rx_pin(rxPin);                     // Pin 2 (rxPin) an RX Link Modul  
    vw_rx_start();                            // Startet den Empfänger
    lcd.begin(16,2); 
}
 
void loop()                                   // Programmschleife
{
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;
    lcd.setCursor(0,0); 
    lcd.print("Drehmoment:"); 
    delay(50);
    //lcd.clear();
    lcd.setCursor(13,1);
    lcd.print("Nm");
    
   
    if (vw_get_message(buf, &buflen))         // Prüft, ob etwas empfangen wurde
    {
    int i;                                               // Setzt "i" als Integer-Variable
          
    for (i = 0; i < buflen; i++)              // Passt den Datenpuffer an die Nachrichtenlänge an
    {
    lcd.setCursor(4,1);
    lcd.print((char)buf[i]); 
    Serial.print((char)buf[i]);           // Sendet Daten aus Puffer an serielle Schnittstelle
        }
    Serial.println(" ");
     }  
  }

versuch es mal so:

[/#include <VirtualWire.h>                      // Bibliothek einbinden
#define rxPin 2                               // Pin 2 als Receive-Pin definieren
#undef abs
#undef double
#undef round
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
char val[5];
int val_int;
 
void setup()                                  // Initialisierung
{
    Serial.begin(9600);                       // Serielle Schnittstelle setzen
    pinMode(2,INPUT);                         // Pin 2 als Eingang definiert
    vw_set_ptt_inverted(true);                // Benötigt für RX Link Modul
    vw_setup(1000);                           // Datenrate in Bits pro Sekunde
    vw_set_rx_pin(rxPin);                     // Pin 2 (rxPin) an RX Link Modul  
    vw_rx_start();                            // Startet den Empfänger
    lcd.begin(16,2); 
}
 
void loop()                                   // Programmschleife
{
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;
    lcd.setCursor(0,0); 
    lcd.print("Drehmoment:"); 
    delay(50);
    //lcd.clear();
    lcd.setCursor(13,1);
    lcd.print("Nm");
    
   
    if (vw_get_message(buf, &buflen))         // Prüft, ob etwas empfangen wurde
    {
    int i;                                               // Setzt "i" als Integer-Variable
          
    for (i = 0; i < buflen; i++)              // Passt den Datenpuffer an die Nachrichtenlänge an
    {
      val[i]=(char)buf[i]);
      val_int_atoi(val)
    lcd.setCursor(4,1);
    lcd.print(val_int); 
    Serial.print((char)buf);           // Sendet Daten aus Puffer an serielle Schnittstelle
        }
    Serial.println(" ");
     }  
  }code]

PS. sende deinen Sketch bitte in Code-Tags (</>) oben links.

das lief erstmal um einiges besser als vorher, musste Deine Sketch-Variante nur an ein paar Stellen leicht korrigieren… Jetzt zeigt er anfangs und nach jedem Reset des nano die richtigen Werte zw. 0-1023 an, aber nach ein paar Werten scheint irgendwie der Buffer voll zu sein und er schreibt unverständliche Werte.

Schicke ich HIGH schreibt er korrekt 1023 schicke ich LOW schreibt er manchmal 300er bis 6200er Werte…

#include <VirtualWire.h>                      // Bibliothek einbinden
#define rxPin 2                               // Pin 2 als Receive-Pin definieren
#undef abs
#undef double
#undef round
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
char val[5];
int val_int;
 
void setup()                                  // Initialisierung
{
    Serial.begin(9600);                       // Serielle Schnittstelle setzen
    pinMode(2,INPUT);                         // Pin 2 als Eingang definiert
    vw_set_ptt_inverted(true);                // Benötigt für RX Link Modul
    vw_setup(1000);                           // Datenrate in Bits pro Sekunde
    vw_set_rx_pin(rxPin);                     // Pin 2 (rxPin) an RX Link Modul  
    vw_rx_start();                            // Startet den Empfänger
    lcd.begin(16,2); 
}
 
void loop()                                   // Programmschleife
{
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;
    lcd.setCursor(0,0); 
    lcd.print("Drehmoment:"); 
    delay(50);
    //lcd.clear();
    lcd.setCursor(13,1);
    lcd.print("Nm");
    
   
    if (vw_get_message(buf, &buflen))         // Prüft, ob etwas empfangen wurde
    {
    int i;                                               // Setzt "i" als Integer-Variable
          
    for (i = 0; i < buflen; i++)              // Passt den Datenpuffer an die Nachrichtenlänge an
    {
      val[i]=((char)buf[i]);
      val_int = atoi(val);
    lcd.setCursor(4,1);
    lcd.print(val_int); 
    Serial.println(val_int);           // Sendet Daten aus Puffer an serielle Schnittstelle
        }
    Serial.println(" ");
     }  
  }

versuch es nochmal so.

[/for (i = 0; i < buflen; i++)              // Passt den Datenpuffer an die Nachrichtenlänge an
    {
      val[i]=(char)buf[i]);
      val_int_atoi(val)code]

Setze doch bitte deine Sketche in Code-Tags.
Wir haben doch schon mehrfach darauf hingewiesen.

Schaltfläche “</>” oder am Anfang [ code ], am Ende [ /code ] Ohne Leerzeichen.
Ach und deinen Code kannst du auch nachträglich noch in die Code-Tags setzen.

Danke.

Und du kannst es in der Loop auch ohne zusätzliche Konvertierung schreiben:

      val[i] = char(buf[i]);

      lcd.setCursor(4, 1);
      lcd.print(val);
      Serial.print(val);           // Sendet Daten aus Puffer an serielle Schnittstelle

grefis1987: ... aber nach ein paar Werten scheint irgendwie der Buffer voll zu sein und er schreibt unverständliche Werte.

Wenn der Buffer vollläuft fehlt das Leeren:

memset(val, 0, sizeof(val));

setze das hinter die Zeile:

 Serial.print(val);           // Sendet Daten aus Puffer an serielle Schnittstelle

Schicke ich HIGH schreibt er korrekt 1023 schicke ich LOW schreibt er manchmal 300er bis 6200er Werte...

Das scheint aber an deinem Sender-Sketch zu liegen, dann brauchen wir den auch.

hallo ardubu,

so will er es nicht. vor 'char' sollten 2 Klammern stehen und den Befehl 'atoi' mit Unterstrich davor erkennt er als undefinierte Variable.

grefis1987: so will er es nicht. vor 'char' sollten 2 Klammern stehen und den Befehl 'atoi' mit Unterstrich davor erkennt er als undefinierte Variable.

Die Konvertierung brauchst du nicht, lies bitte meinen Post oben.

Super, das mit den Code-Tags hat schon mal geklappt,

danke.

Hier nochmal der aktuelle Sketch. Jetzt zeigt er zumindest auf seriellem Monitor und LCD das Gleiche an. 1023 kommt immer gut rein, alles andere nicht. mal 0330 mal 6720…

#include <VirtualWire.h>                      // Bibliothek einbinden
#define rxPin 2                               // Pin 2 als Receive-Pin definieren
#undef abs
#undef double
#undef round
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
char val[5];
int val_int;
 
void setup()                                  // Initialisierung
{
    Serial.begin(9600);                       // Serielle Schnittstelle setzen
    pinMode(2,INPUT);                         // Pin 2 als Eingang definiert
    vw_set_ptt_inverted(true);                // Benötigt für RX Link Modul
    vw_setup(1000);                           // Datenrate in Bits pro Sekunde
    vw_set_rx_pin(rxPin);                     // Pin 2 (rxPin) an RX Link Modul  
    vw_rx_start();                            // Startet den Empfänger
    lcd.begin(16,2); 
}
 
void loop()                                   // Programmschleife
{
    uint8_t buf[VW_MAX_MESSAGE_LEN];
    uint8_t buflen = VW_MAX_MESSAGE_LEN;
    lcd.setCursor(0,0); 
    lcd.print("Drehmoment:"); 
    delay(50);
    //lcd.clear();
    lcd.setCursor(13,1);
    lcd.print("Nm");
    
   
    if (vw_get_message(buf, &buflen))         // Prüft, ob etwas empfangen wurde
    {
    int i;                                               // Setzt "i" als Integer-Variable
          
    for (i = 0; i < buflen; i++)              // Passt den Datenpuffer an die Nachrichtenlänge an
    {
    val[i]=char(buf[i]);
    //val_int = atoi(val);
    lcd.setCursor(4,1);
    lcd.print(val); 
    Serial.println(val);           // Sendet Daten aus Puffer an serielle Schnittstelle
    //memset(val, 0, sizeof(val)); 
        }
    Serial.println(" ");
     }  
  }

mit der Konvertierung atoi schreibt er nur 0 oder 1. Das memset bringt nur 0

Wenn adere Werte nicht ankommen, liegt es, wie schon geschrieben, am Sendersketch. Den musst du uns auch zeigen.

Hier also der Sender-Sketch, der 10-bit Wert kommt aber wie gesagt richtig an.

#include <VirtualWire.h>                  // Einbinden der Bibliothek
#define txPin 4                           // definiert txPin an Pin4
#define SensorPin 3                       // definiert SensorPin an Pin3
int WERT;                                 // "WERT" als Integer-Variable
char MITTEILUNG[10];                       // "MITTEILUNG" als 8-bit Datentypkonvertierung

void setup()

{
 
 pinMode(SensorPin,INPUT);                // Setzt SensorPin an Pin 3 als Eingang
 pinMode(txPin,OUTPUT);                   // Setzt txPin an Pin 4 als Ausgang

    vw_setup(1000);                       // Setzt Datenrate Funk auf 1000 Bits pro Sekunde
    vw_set_tx_pin(txPin);                 // Setzt txPin als Sender
}

void loop()
{
  WERT = analogRead(SensorPin);           // Variable WERT speichert Daten vom Sensor als 10-bit Wert
  itoa(WERT,MITTEILUNG,10);               // Konvertiert Integer-Wert nach Char-Wert
  const char *msg = MITTEILUNG;           // Variable MITTEILUNG als Nachricht definiert

 vw_send((uint8_t *)msg, strlen(msg));    // Senden der Nachricht
 vw_wait_tx();                            // Warten bis Nachricht gesendet wurde
 }

Hast du es mal manuell versucht, also verschiedene Werte durch manuelle Eingabe am Sender zu übertragen?

So kann man dem Problem auf die Spur kommen. Ich vermute, es liegt an der Wandlung des gemessenen Wertes.

Ja das habe ich bereits vor dem Anschluss des Displays probiert mit einem Poti. Da kommen ja Werte zw. 0-255 an, die ließ ich umwandeln und er funkte sauber 0-1024, welche dann auch wieder am seriellen Monitor ausgegeben wurden. Es kann nur an dem (Wandler-)Befehl und der Übertragung zum Display liegen.

Ich finde überdies auch keine Liste, welche Befehle die Liquid-Chrystal_I2C Bibliothek unterstützt...

An der Übertragung zu Display liegt es nicht mehr. Dder Wert wird falsch gewandelt. Ich kann es hier nicht testen, da ich nur am Tablet sitze.

Mit manuell meine ich auch, einzeln am SerialMonitor eingeben und dann übertragen. Da kannst du es mit jedem Wert testen. Las das Poti mal weg und teste es so, geht einfacher. Und wenn es mit allen Werten geht, liegt es sicher an der Wandlung.

Ich setze hier auch 433 MHz Module mit der Library ein und kann alles übertragen, problemlos.

Falls Du im neuen Jahr Zeit findest, kannst Du mir gerne mal einen Sketch schicken, mit dem es bei Dir funktioniert. Gutsch Rutsch und danke bis hier hin!

grefis1987: Falls Du im neuen Jahr Zeit findest, kannst Du mir gerne mal einen Sketch schicken, mit dem es bei Dir funktioniert. Gutsch Rutsch und danke bis hier hin!

Ok, danke dir auch. Wir treffen uns. ;)