PIC16F1509/Sansmart LCD2004/I2C , benötige etwas Hilfe

[Harry R. (harryr)]

Hallo zusammen,

als PIC-Anfänger bin ich am WE (mal wieder) an meine Grenzen gestoßen 
:-(

Worum gehts es ?

Ich möchte via I2C ein 4-zeiliges LCD-Display ansteuern.
Als PIC nehme ich den PIC16F1509

Ich verwende MPLAB X 6.10 mit MCC im Modus "Melody".

Melody implementiert I2C via Interrupt, was meiner Meinung nach
eine gute Lösung darstellt.

Nachdem ich ein neues Projekt erstellt habe und via MCC die Devices/etc 
konfiguriert habe, existiert folgende Konfiguration (hier: Dateien, 
Verzeichnisse): LCDI2C1.png

Der Zweig i2c_host stellt dabei die Funktionen für eine Kommunikation 
via I2C zur Verfügung.

Nun muss ich also (nur noch) eine LCD-Schnittstelle implementieren, die
die generierte  I2C-Schnittstelle verwendet.

Ich habe mich dazu in diversen Seiten im Internet schlau gemacht und
versucht, die grundlegenden Funktionen zu implementieren.

Die erste ist natürlich eine Initialisierungsroutine:

bool LCD_Initialize(unsigned char lAddress)
{
  if (lAddress == 0)
    return(false);
  else
    lcdAddress = lAddress;
  
  unsigned char _displayfunction = LCD_4BITMODE | LCD_2LINE | LCD_5x8DOTS;
    
  IO_Expander_Write(0x00);
  __delay_ms(30);
  LCD_CMD(0x03);
  __delay_ms(5);
  LCD_CMD(0x03);
  __delay_ms(5);
  LCD_CMD(0x03);
  __delay_ms(5);
  LCD_CMD(LCD_RETURN_HOME);
  __delay_ms(5);
  LCD_CMD(0x20 | (LCD_TYPE << 2|_displayfunction));
  __delay_ms(50);
  LCD_CMD(LCD_TURN_ON);
  __delay_ms(50);
  LCD_CMD(LCD_CLEAR);
  __delay_ms(50);
  LCD_CMD(LCD_ENTRY_MODE_SET | LCD_RETURN_HOME);
  __delay_ms(50);
    
  initialized = true;
  return(true);
};

Man sieht am Code schon, dass dort "Ideen" aus anderen Implementierungen 
eingeflossen sind. Ich zeige gerne den ganzen Code, vorerst möchte ich 
aber schlicht und ergreifend wissen, ob diese Init überhaupt 
funktioniert. Auch hier schon mal die Information, immerhin kann ich die 
Hintergrundbeleuchtung damit an/ausschalten, so verkehrt kann es also 
nicht sein. Dito stimmt die I2C-Adresse des LCD-Moduls schonmal. 
Allerdings ist das Togglen des Backlights sehr lowlevel, also unabhängig 
von der Auflösung des Dislays. Und da scheint der Hund begraben zu sein, 
denn bisher hat sich noch kein Zeichen auf dem Display  gezeigt. Das 
Display sieht auch so aus, als ob es mit meinem Init gar nicht 
einverstanden ist. Grundlegende Schreibroutinen funktionieren, denn 
sonst könnte ich das LCD nicht togglen.

Das LCD sieht so aus wie in Bild LCDI2C2.JPG.
Das ist merkwürdig zweizeilig. Für das Verständnis der Funktion zeige 
ich jetzt mal alle verwendeten #defines

#define LCDDEFAULTI2CAdress2 0x27
#define LCDI2CAdress LCDDEFAULTI2CAdress2  // = lAddress

#define LCD_BACKLIGHT          0x08
#define LCD_NOBACKLIGHT        0x00
#define LCD_FIRST_ROW          0x80
#define LCD_SECOND_ROW         0xC0
#define LCD_THIRD_ROW          0x94
#define LCD_FOURTH_ROW         0xD4
#define LCD_CLEAR              0x01
#define LCD_RETURN_HOME        0x02
#define LCD_ENTRY_MODE_SET     0x04
#define LCD_CURSOR_OFF         0x0C
#define LCD_UNDERLINE_ON       0x0E
#define LCD_BLINK_CURSOR_ON    0x0F
#define LCD_MOVE_CURSOR_LEFT   0x10
#define LCD_MOVE_CURSOR_RIGHT  0x14
#define LCD_TURN_ON            0x0C
#define LCD_TURN_OFF           0x08
#define LCD_SHIFT_LEFT         0x18
#define LCD_SHIFT_RIGHT        0x1E
#define LCD_TYPE               2       // 0 -> 5x7 | 1 -> 5x10 | 2 -> 2 lines
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00

Wenn ich Glück habe und ihr mir helft, ist "der Hund" bereits hier 
begraben. Ansonsten gebe ich gerne mehr Information raus, ich will im 
Moment meinen Beitrag hier nur nicht ausufernd lang machen.

Danke vorab für jeden Beitrag
Harry

[Frank K. (fchk)]

Hast Du einen Logic Analyzer? Wenn nicht, dann kauf Dir einen. Die 
billigen 24MHz/8Ch Teile von Amazon reichen.

Dann verifizierst Du, ob das was Du in Deinem Programmcode senden 
willst, auch tatsächlich auf dem I2C gesendet wird und dass Du für jedes 
geschriebene Byte ein ACK bekommst.

Dann nimmst Du Dir das Datenblatt zum Display und schaust, welche 
Befehle das kann. Dann hängst Du Dich mit Deinem Logicanalyzer direkt an 
das Display (d.h. an die Datenleitungen D4...D7 (das Display wird 
wahrscheinlich im 4-Bit Modus betrieben) und E, RS und W) und schaust, 
ob die Signale, die da im Datenblatt stehen, genauso richtig ankommen.

Wenn Du damit durch bist, sollte das gehen.

Du musst lernen zu lernen anstelle für jeden Mist hier zu fragen.
Du musst lernen, systematisch Fehlersuche zu betreiben.
Du musst lernen, welche Tools es gibt, wann Du sie einsetzt und wie sie 
funktionieren.

Auf!

fchk

[Harry R. (harryr)]

Frank K. schrieb:
> Hast Du einen Logic Analyzer? Wenn nicht, dann kauf Dir einen. Die
> [...]
> Auf!
>
> fchk
Dein Beitrag hilft mir nicht weiter und dein Ton gefällt mir nicht.
Würde es dir etwas ausmachen, diesen Thread einfach zu ignorieren ?
Wenn ja: gut, wenn nicht auch gut, aber bitte nicht antworten, ich habe 
echt keine Lust das auszudiskutieren.

[Stephan S. (uxdx)]

Harry R. schrieb:
> Dein Beitrag hilft mir nicht weiter und dein Ton gefällt mir nicht.

Frank hat Dir eine absolut korrekte Antwort gegeben, so sucht man den 
Fehler.

DEIN TON ist hier unangebracht.

[Harry R. (harryr)]

Stephan S. schrieb:
> Harry R. schrieb:
>> Dein Beitrag hilft mir nicht weiter und dein Ton gefällt mir nicht.
>
> Frank hat Dir eine absolut korrekte Antwort gegeben, so sucht man den
> Fehler.
>
> DEIN TON ist hier unangebracht.
Für dich gilt das gleiche wie für Frank. Vielen Dank

[ElC (elc)]

Hi
Meine Erfahrung mit PIC16F1509 und MLAB ist gleich null.
Aus Zeitvertreib habe ich mal gegoogelt.
Möglicherweise hilft dir dieser Link weiter:

https://controllerstech.com/lcd-20x4-using-i2c-with-stm32/

Aufgefallen ist mir auf den ersten Blick die dortige 
Initialisierungs-Sequenz, die I2C Adresse und auch der von dir 
abweichende Wert bei der Definition für den 4-Bit Mode. Nur (?) unter 
der Arduino IDE ist die I2C Adresse 0x27 oder 0x3F.

MfG

[Harry R. (harryr)]

ElC schrieb:
> Hi
> Meine Erfahrung mit PIC16F1509 und MLAB ist gleich null.
> Aus Zeitvertreib habe ich mal gegoogelt.
> Möglicherweise hilft dir dieser Link weiter:
>
> https://controllerstech.com/lcd-20x4-using-i2c-with-stm32/
>
> Aufgefallen ist mir auf den ersten Blick die dortige
> Initialisierungs-Sequenz, die I2C Adresse und auch der von dir
> abweichende Wert für den 4-Bit Mode. Nur (?) unter der Arduino IDE ist
> die I2C Adresse 0x27 oder 0x3F.
>
> MfG
Die Adresse muss stimmen, sonst könne ich das BackLight nicht 
An/Aussschalten (mit bewusst falscher Adresse funktioniert das eben 
nicht,
habe ich eben nochmal mal mit der FALSCHEN Adresse 0x28 getestet).

Ändern des 4Bit-Modes im Quelltext ändert nichts am Problem.

Also:

  LCD_CMD(0x20 );   //| (LCD_TYPE << 2|_displayfunction));

ändert nichts.

Dito funktioniert die Sequenz

  LCD_CMD(0x20 );
  __delay_ms(50);
  LCD_CMD(0x08 );
__delay_ms(50);

nicht :-(

Danke und Grüße
Harry

[Εrnst B. (ernst)]

Dann zeig doch mal, wie du "LCD_CMD" implementiert hast.
Wenn dort einfach garnix oder was falsches passiert, wird das nix mit 
dem Display.
nach allem was wir bislang wissen, könntest du ja auch ein

#define LCD_CMD(x) IO_Expander_Write(rand())

irgendwo versteckt haben, um uns zu trollen.

[Sigi S. (sermon)]

Nur Codeschnipsel, kein Displaytyp, keine Hilfe.....

[Ottmar K. (wil1)]

Hallo Harry,

Tut mir leid für Dich, daß Dich. Den gelegentlich herablassenden Ton 
mußt Du hier einfach hin und wieder erdulden (rühmliche Ausnahmen gibt 
es natürlich).

Jetzt aber zu Deinem Problem, vielleicht hilft es Dir, wenn Du im 
Datenblatt des verbauten LCD-Controllers HD44780 nachliest - vermutlich 
handelt es sich bei Deinem LCD um einen solchen - wie die 
Initialisierung im 4- Bit Modus abzulaufen hat. Ich versuche es mal so:

Das LCD startet im 8Bit-Modus. Warum? Vom Hersteller so festgelegt. Zum 
Start der Initialisierung muß die Betriebsspannung einen Mindestwert 
erreicht haben, daher das Delay.

Nachfolgend die Initialisierung per Assembler (Für ASM unvollständig, da 
hier nur die Zahlenwerte und der systematische Ablauf gezeigt werden 
sollen). Die Zahlenwerte nach "movlw" mußt Du eben ins Hex-Format 
umwandeln und mit LCD_CMD absenden. Die Sequenz ist zwar binär codiert, 
aber einfach in das von Dir verwendete Hex-Format umzuwandeln.

Jeder Befehl muß per Toggeln des "Enable-Pins LCD_E" in den 
Arbeitsspeicher des LCD geschoben werden. Ich zeige das nur wegen dem 
Prinzip, dürfte bei Dir wegen des verwendeten Librarys auch so ablaufen.

mfG Ottmar

Hier die Sequenz
----------------
;Wait for more than 40 ms after Vcc rises to 2.7 V
   movlw    b'00110000'    ;1. Function set
   movwf    LCD_LAT        ;   (Interface is 8 bits long  .)
   bsf      LCD_E          ;   Toggle LCD_LAT,E
   nop
   bcf      LCD_E
   ;
   movlw    b'00110000'    ;1. Function set
   movwf    LCD_LAT        ;   (Interface is 8 bits long.)
   bsf      LCD_E          ;   Toggle LCD_LAT,E
   nop
   bcf      LCD_E
   ;
   ;wait for more than 4.1ms
   ;
   movlw    b'00110000'    ;2. Function set
   CALL     Control8Bit    ;   (Interface is 8 bits long.)
   ;
   movlw    b'00110000'    ;3. Function set
   CALL     Control8Bit    ;   (Interface is 8 bits long.)
   ;
   movlw    b'00100000'    ;4. Function set
   CALL     Control8Bit    ;   INTERFACE IS NOW 4 BITS LONG.
   ;
   movlw    b'00101000'    ;5. Function set 2 AND MORE LINES 5x8 Dot
   ;   movlw   b'00100000'    ;   Function set 1 SINGLE LINE    5x8 Dot
   CALL     OutLcd_Ctrl    ;   send function to LCD
   ;
   movlw    b'00001000'    ;6. display off
   CALL     OutLcd_Ctrl
   ;
   movlw    b'00000110'    ;7. entry mode, increment
   CALL     OutLcd_Ctrl  ;   disable display-shift
   ;
   movlw    b'00000011'    ;8. cursor home, cursor home
   CALL     OutLcd_Ctrl
   ;
   movlw    b'00001100'    ;9. Set   Display ON, CRSR_ON OFF Blink OFF
   CALL     OutLcd_Ctrl    ;   b3      b2         b1          b0
   ;
   movlw    b'00000001'    ;   Display löschen und cusor home
   CALL     OutLcd_Ctrl
   RETURN

[Ottmar K. (wil1)]

Hi,ich glaub es nicht!

Gerade schau ich auf den Tisch,, in der Schaltung vor mir liegt ja das 
LCD2004/I2C, gekauft bei Amazon und ist HD44780-kompatibel. Läuft 
prächtig mit meinem 2Wire-Adapter.
Ottmar

[Εrnst B. (ernst)]

Ottmar K. schrieb:
> Läuft
> prächtig mit meinem 2Wire-Adapter.

Aber du versuchst auch nicht, den 4-Bit-Modus im 4-Bit-Modus zu 
aktivieren.

Deshalb meine Frage nach der LCD_CMD... wenn da keine automatische 
Umschaltung für 8bit/4bit-Modus drinnen versteckt ist, ist Harry's 
Initialisierungssequenz falsch.

[Sigi S. (sermon)]

Εrnst B. schrieb:
> Ottmar K. schrieb:
>> Läuft
>> prächtig mit meinem 2Wire-Adapter.
>
> Aber du versuchst auch nicht, den 4-Bit-Modus im 4-Bit-Modus zu
> aktivieren.
>
> Deshalb meine Frage nach der LCD_CMD... wenn da keine automatische
> Umschaltung für 8bit/4bit-Modus drinnen versteckt ist, ist Harry's
> Initialisierungssequenz falsch.

Das sollte doch alles der Controlle auf dem I2C Adapter übernehmen?!

Er erklärt die Lösung in C für einen PI.
Da sollte locker zum Ziel führen
https://youtu.be/1p1rgkslO0U

[H. H. (Gast)]

Sigi S. schrieb:
> Das sollte doch alles der Controlle auf dem I2C Adapter übernehmen?!

Auf den üblichen Adaptern werkelt kein Controller, da gibts nur einen 
PCF8574T.

[Sigi S. (sermon)]

Ok,

das ist richtig.
Dann sollte er das Datenblatt studieren.
Anfang der 90 er kannte ich das auswendig.
Mit den 805xx dann in Assembler programmiert.

[Harry R. (harryr)]

Εrnst B. schrieb:
> Dann zeig doch mal, wie du "LCD_CMD" implementiert hast.
> Wenn dort einfach garnix oder was falsches passiert, wird das nix mit
> dem Display.
> nach allem was wir bislang wissen, könntest du ja auch ein
>

> #define LCD_CMD(x) IO_Expander_Write(rand())
>

> irgendwo versteckt haben, um uns zu trollen.
Trollen mache ich nur im AfD-Forum :-)
Spaß beiseite, hier mal die Funktionen, die im Endeffekt das machen, was
nötig ist, um via I2C zu kommunizieren.

unsigned char RS;

void I2C__Write(unsigned char Data)
{
   unsigned char tmpData = Data;
   I2C1_Host.Write(lcdAddress, &tmpData, sizeof(tmpData) );
}

void IO_Expander_Write(unsigned char Data)
{
  I2C__Write(Data | BackLight_State);
}

void LCD_Write_4Bit(unsigned char Nibble)
{
  // Get The RS Value To LSB OF Data..
  Nibble |= RS;
  IO_Expander_Write(Nibble | 0x04);
  IO_Expander_Write(Nibble & 0xFB);
}

void LCD_CMD(unsigned char CMD)
{
  RS = 0; // Command Register Select
  LCD_Write_4Bit(CMD & 0xF0);
  LCD_Write_4Bit((CMD << 4) & 0xF0);
}

void LCD_Write_Char(char Data)
{
  RS = 1;  // Data Register Select
  LCD_Write_4Bit(Data & 0xF0);
  LCD_Write_4Bit((Data << 4) & 0xF0);
}

/*
void LiquidCrystal_I2C::send(uint8_t value, uint8_t mode) {
  uint8_t highnib=value&0xf0;
  uint8_t lownib=(value<<4)&0xf0;
       write4bits((highnib)|mode);
  write4bits((lownib)|mode); 
}
 * */

void LCD_Write_String(char* Str)
{
    for(int i=0; Str[i]!='\0'; i++)
       LCD_Write_Char(Str[i]);
}

[Sigi S. (sermon)]

Sigi S. schrieb:
> Dann sollte er das Datenblatt studieren.

Des uns nicht bekannten LCD Controllers.................

[Εrnst B. (ernst)]

Harry R. schrieb:

 void LCD_CMD(unsigned char CMD)
 {
   RS = 0; // Command Register Select
   LCD_Write_4Bit(CMD & 0xF0);
   LCD_Write_4Bit((CMD << 4) & 0xF0);
 }

Genau da liegt das Problem. Beim Initialisieren ist das Display im 8 
Bit-Modus. da kannst du nicht zwei Nibble hintereinander raussenden und 
einzeln per E-Toggle übernehmen.
Du brauchst da nur das High-Nibble vom "Set 4 Bit Mode"-Commando setzen, 
einmal E Togglen.
d.H.: erste Initialisierung per "LCD_Write_4Bit", nicht per "LCD_CMD".
TLDR:

RS=0;
LCD_Write_4Bit(0x20);

[Harry R. (harryr)]

Εrnst B. schrieb:
> Genau da liegt das Problem. Beim Initialisieren ist das Display im 8
> Bit-Modus. da kannst du nicht zwei Nibble hintereinander raussenden und
> einzeln per E-Toggle übernehmen.
Klingt logisch :-)
> Du brauchst da nur das High-Nibble vom "Set 4 Bit Mode"-Commando setzen,
> einmal E Togglen.
E togglen ?
Aber LCD_Write_4Bit(unsigned char Nibble)

sendet doch via IO_Expander_Write zweimal hintereinander 8 Bits.

Ich glaube ich/wir sind kurz vor der Lösung, aber mein Groschen hängt 
noch fest .. Kannst du bitte das  LCD_Initialize(unsigned char lAddress)
mal so übermitteln, wie es richtig wäre ?

[Εrnst B. (ernst)]

Harry R. schrieb:
> Kannst du bitte das  LCD_Initialize(unsigned char lAddress)
> mal so übermitteln, wie es richtig wäre

Gucks dir hier ab:
https://github.com/lucasmaziero/LiquidCrystal_I2C/blob/master/LiquidCrystal_I2C.cpp#L69

"write4bits" entspricht deinem "LCD_Write_4Bit"
"command" entspricht deinem "LCD_CMD"
usw.

Harry R. schrieb:
> sendet doch via IO_Expander_Write zweimal hintereinander 8 Bits.

Von den 8 Bit, die der Expander ausgibt, sind nur 4 (die 4 oberen, das 
High-Nibble) mit den Datenleitungen des Displays verbunden.
Deshalb: Jeder 8-Bit-Schreibvorgang am Expander schreibt 4 Bits zum 
Display und die anderen 4 Bits bedienen Steuerleitungen (E, RS, RW, 
Backlight)

[Harry R. (harryr)]

Εrnst B. schrieb:
> Harry R. schrieb:
>> Kannst du bitte das  LCD_Initialize(unsigned char lAddress)
>> mal so übermitteln, wie es richtig wäre
>
> Gucks dir hier ab:
> 
https://github.com/lucasmaziero/LiquidCrystal_I2C/blob/master/LiquidCrystal_I2C.cpp#L69
Tatsächlich ist das der Ursprung meines Versuchs, ich gehe das mit neuem 
Wissen nochmal an.
> "write4bits" entspricht deinem "LCD_Write_4Bit"
> "command" entspricht deinem "LCD_CMD"
> usw.
>
> Harry R. schrieb:
>> sendet doch via IO_Expander_Write zweimal hintereinander 8 Bits.
>
> Von den 8 Bit, die der Expander ausgibt, sind nur 4 (die 4 oberen, das
> High-Nibble) mit den Datenleitungen des Displays verbunden.
> Deshalb: Jeder 8-Bit-Schreibvorgang am Expander schreibt 4 Bits zum
> Display und die anderen 4 Bits bedienen Steuerleitungen (E, RS, RW,
> Backlight)
Ah, verstehe, jetzt ist mir das schon sehr viel klarer, ich bin kurz vor 
dem Verständnis :-)

VG

[Harry R. (harryr)]

So, da wäre ich wieder mit neuen Erkenntnissen, alten Problemen und 
neuen Fragen. Der Tipp von Εrnst B. schrieb:

> Gucks dir hier ab:
> 
https://github.com/lucasmaziero/LiquidCrystal_I2C/blob/master/LiquidCrystal_I2C.cpp#L69

Das habe ich schon von Anfang an versucht, der Hinweis hat mich aber 
bestärkt es nochmal auf diesem Weg zu versuchen.

Die Portierung vom Arduino in die PIC-Welt sollte zu bewältigen sein.

Ich gehe mal ins Detail, bzgl. der Arduino-Bibliothek gibt ist noch auf 
die Header-Datei zu achten 
(https://github.com/lucasmaziero/LiquidCrystal_I2C/blob/master/LiquidCrystal_I2C.h).

Die erste zu überwindende Hürde ist eigentlich nicht schwer, portiert 
wird von C++ nach C. Sollte man meinen, denn die C++-Klase enthält kein 
print, das nützlich sein könnte :

void LiquidCrystal_I2C::printstr(const char c[]){
  //This function is not identical to the function used for "real" I2C displays
  //it's here so the user sketch doesn't have to be changed 
  print(c);
}

In den Examples findet man ein HelloWorld (leicht gekürzt):

#include <LiquidCrystal_I2C.h>
// Set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup()
{
  // initialize the LCD
  lcd.begin(); //Init with pin default ESP8266 or ARDUINO
  //lcd.begin(0, 2); //ESP8266-01 I2C with pin 0-SDA 2-SCL

  // Turn on the blacklight and print a message.
  lcd.backlight();
  
  lcd.setCursor(0, 0);
#if defined(ESP8266)
  lcd.print("ESP8266");
#else
  lcd.print("ARDUINO");
#endif
  lcd.setCursor(0, 1);
  lcd.print("Hello, world!");
}

Das init des LCD besteht aus dem Constructor und dann dem begin(),
diese beiden Methoden weren in meiner Portierung dann zusammengefasst. 
Aber zurück zum print-Problem, im HW wird einfach lcd.print() 
aufgerufen. Das existiert im Quelltext der Klasse nicht, sondern wird 
irgendwie geerbt

class LiquidCrystal_I2C : public Print 
{

Ich habe mich auf die Suche begeben um herauszufinden welche Klaaase das 
vererbt, bin aber nicht fündig geworden, kann mir da jemand auf die 
Sprünge helfen ?

So, das dazu, das größte Problem ist bisher, dass ich es immer noch 
nicht geschafft habe, das LCD dazu zu bewegen 4 Zeilen anzuzeigen.

Ich zeige hier mal den kompletten Code (ohne Header-Datei).

#include <xc.h>
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include "mcc_generated_files/system/clock.h" 
#include "mcc_generated_files/i2c_host/mssp.h"
#include "custom.h"
#include "lcdi2c.h"

// commands
#define LCD_CLEARDISPLAY   0x01
#define LCD_RETURNHOME     0x02
#define LCD_ENTRYMODESET   0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT    0x10
#define LCD_FUNCTIONSET    0x20
#define LCD_SETCGRAMADDR   0x40
#define LCD_SETDDRAMADDR   0x80

// flags for display entry mode
#define LCD_ENTRYRIGHT          0x00
#define LCD_ENTRYLEFT           0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00

// flags for display on/off control
#define LCD_DISPLAYON  0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON   0x02
#define LCD_CURSOROFF  0x00
#define LCD_BLINKON    0x01
#define LCD_BLINKOFF   0x00

// flags for display/cursor shift
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE  0x00
#define LCD_MOVERIGHT   0x04
#define LCD_MOVELEFT    0x00

// flags for function set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE    0x08
#define LCD_1LINE    0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS  0x00

// flags for backlight control
#define LCD_BACKLIGHT   0x08
#define LCD_NOBACKLIGHT 0x00

#define En 0b00000100  // Enable bit
#define Rw 0b00000010  // Read/Write bit
#define Rs 0b00000001  // Register select bit  : Data
#define Co 0b00000000  // Register select bit : command

void expanderWrite(uint8_t data);
void pulseEnable(uint8_t _data);
void write4bits(uint8_t value) ;
void send(uint8_t value, uint8_t mode) ;
inline void command(uint8_t value); 
void writeChar(uint8_t value); 
void writeStr(char* str);
void writeStrXY(uint8_t col, uint8_t row,char* str);
inline void writeData(char value) ;
bool lcdinit(uint8_t lcd_addr, uint8_t lcd_cols, uint8_t lcd_rows);
bool lcdclose(void);
inline void clear(void);
inline void home(void);
void setCursor(uint8_t col, uint8_t row);
void noDisplay(void); 
inline void display(void) ;
void noCursor(void); 
void cursor(void) ;
void noBlink(void); 
void blink(void) ;
void scrollDisplayLeft(void) ;
void scrollDisplayRight(void) ;
void leftToRight(void) ;
void rightToLeft(void) ;
void autoscroll(void) ;
void noAutoscroll(void) ;
void createChar(uint8_t location, uint8_t charmap[]) ;
void noBacklight(void); 
void backlight(void); 
bool getBacklight(void);

uint8_t _displayfunction  = 0;
uint8_t _displaycontrol   = 0;
uint8_t _displaymode      = 0;
uint8_t _cols             = 0;
uint8_t _rows             = 0;
uint8_t _charsize         = 0;
uint8_t _backlightval     = 0;

unsigned char lcdAddress  = 0;
bool     _initialized      = false;

#define TRY4BITMODE      0x03
#define SET4BITMODE      0x02

inline void expanderWrite(uint8_t data)
{                                        
  data |= _backlightval;
    //bool I2C1_Write(uint16_t address, uint8_t *data, size_t dataLength)
    // & ?
  I2C1_Host.Write((uint16_t)lcdAddress, &data, sizeof(data) );
//  Wire.endTransmission();   
}

inline void pulseEnable(uint8_t _data)
{
  expanderWrite(_data | En);  // En high
  //delayMicroseconds(1);    // enable pulse must be >450ns
  delayUs(1);
    
  expanderWrite(_data & ~En);  // En low
  delayUs(50);
    //delayMicroseconds(50);    // commands need > 37us to settle
}

inline void write4bits(uint8_t value) 
{
  expanderWrite(value);
  pulseEnable(value);
}

// write either command or data
inline void send(uint8_t value, uint8_t mode) 
{
  uint8_t highnib=value&0xf0;
  uint8_t lownib=(value<<4)&0xf0;
  write4bits((highnib)|mode);
  write4bits((lownib)|mode); 
}

inline void command(uint8_t value) 
{
  uint8_t highnib=value&0xf0;
  uint8_t lownib=(value<<4)&0xf0;
  write4bits((highnib));
  write4bits((lownib)); 
}

/*********** mid level commands, for sending data/cmds */

/*
inline void command(uint8_t value) 
{
  send(value, Co);
} */

//inline 
inline void writeChar(uint8_t value) 
{
 // send((uint8_t)value, Rs);
    uint8_t highnib=value&0xf0;
  uint8_t lownib=(value<<4)&0xf0;
  write4bits((highnib)|Rs);
  write4bits((lownib)|Rs); 
}

inline void writeStr(char* str)
{
   for(int i=0; str[i]!='\0'; i++)
       writeChar(str[i]);   
};

inline void writeStrXY(uint8_t col, uint8_t row,char* str)
{
   setCursor(col, row);
   writeStr(str);
};

inline void writeData(char value) 
{
   send((uint8_t)value, Rs);
}

uint8_t setlcdmode = 0b00010000;

inline bool lcdinit(uint8_t lcd_addr, uint8_t lcd_cols, uint8_t lcd_rows)
{
    
  if (lcd_addr == 0)
    return(false);
  else
    lcdAddress = lcd_addr;
  
  _cols = lcd_cols;
  _rows = lcd_rows;
  _charsize = LCD_5x8DOTS;
  _backlightval = LCD_BACKLIGHT;
  
  if (lcd_rows > 1)
      setlcdmode |= 0x08;
    
  _displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
  
  if (_rows > 1) 
  {
  _displayfunction |= LCD_2LINE;
  }
  // for some 1 line displays you can select a 10 pixel high font
  if ((_charsize != 0) && (_rows == 1)) 
  {
  _displayfunction |= LCD_5x10DOTS;
  }

  // SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
  // according to datasheet, we need at least 40ms after power rises above 2.7V
  // before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
  delayMs(50); 

  // Now we pull both RS and R/W low to begin commands
  expanderWrite(_backlightval);  // reset expanderand turn backlight off (Bit 8 =1)
  delayMs(1000);

  //put the LCD into 4 bit mode
  // this is according to the hitachi HD44780 datasheet
  // figure 24, pg 46

  // we start in 8bit mode, try to set 4 bit mode
  // oder
  // write4bits(TRY4BITMODE << 4);

  write4bits(TRY4BITMODE << 4);
  delayMs(5);
  //delayMicroseconds(4500); // wait min 4.1ms

  // second try
  write4bits(TRY4BITMODE << 4);
  //delayMicroseconds(4500); // wait min 4.1ms
  delayMs(5);
    
  // third go!
  write4bits(TRY4BITMODE << 4); 
  delayMs(150);

  // finally, set to 4-bit interface
//  write4bits(0b00101000);
  write4bits(SET4BITMODE << 4); 

  // set # lines, font size, etc.
  command(LCD_FUNCTIONSET | _displayfunction);  
  
  // turn the display on with no cursor or blinking default
  _displaycontrol = LCD_DISPLAYON | LCD_CURSORON | LCD_BLINKOFF;
    
  display();
  
  // clear it off
  clear();
  
  // Initialize to default text direction (for roman languages)
  _displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
  
  // set the entry mode
////  command(LCD_ENTRYMODESET | _displaymode);
  
  home();
  _initialized = true;
  return(true);
}

bool lcdclose(void)
{
  lcdAddress = 0;
  _displayfunction  = 0;
  _displaycontrol   = 0;
  _displaymode      = 0;
  _cols             = 0;
  _rows             = 0;
  _charsize         = 0;
  _backlightval     = 0;
  I2C1_Host.Deinitialize(); 
  _initialized = false;
  return(true);
};

/********** high level commands, for the user! */
inline void clear()
{
  command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero
  delayMs(2);
  //delayMicroseconds(2000);  // this command takes a long time!
}

inline void home()
{
  command(LCD_RETURNHOME);  // set cursor position to zero
  //delayMicroseconds(2000);  // this command takes a long time!
  delayMs(2);
}

void setCursor(uint8_t col, uint8_t row)
{
  char row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
  
  if (row > _rows) 
    row = _rows;
  row = _rows-1;    // we count rows starting w/0
  
  command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}

// Turn the display on/off (quickly)
void noDisplay() 
{
  _displaycontrol &= ~LCD_DISPLAYON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

inline void display() 
{
  _displaycontrol |= LCD_DISPLAYON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turns the underline cursor on/off
void noCursor() 
{
  _displaycontrol &= ~LCD_CURSORON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

void cursor() 
{
  _displaycontrol |= LCD_CURSORON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// Turn on and off the blinking cursor
void noBlink() 
{
  _displaycontrol &= ~LCD_BLINKON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

void blink() 
{
  _displaycontrol |= LCD_BLINKON;
  command(LCD_DISPLAYCONTROL | _displaycontrol);
}

// These commands scroll the display without changing the RAM
void scrollDisplayLeft(void) 
{
  command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
}

void scrollDisplayRight(void) 
{
  command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
}

// This is for text that flows Left to Right
void leftToRight(void) 
{
  _displaymode |= LCD_ENTRYLEFT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// This is for text that flows Right to Left
void rightToLeft(void) 
{
  _displaymode &= ~LCD_ENTRYLEFT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'right justify' text from the cursor
void autoscroll(void) 
{
  _displaymode |= LCD_ENTRYSHIFTINCREMENT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// This will 'left justify' text from the cursor
void noAutoscroll(void) 
{
  _displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
  command(LCD_ENTRYMODESET | _displaymode);
}

// Allows us to fill the first 8 CGRAM locations
// with custom characters
void createChar(uint8_t location, uint8_t charmap[]) 
{
  location &= 0x7; // we only have 8 locations 0-7
  command(LCD_SETCGRAMADDR | (uint8_t)(location << 3));
  for (int i=0; i<8; i++) 
  writeData(charmap[i]);
}

// Turn the (optional) backlight off/on
void noBacklight(void) 
{
  _backlightval=LCD_NOBACKLIGHT;
  expanderWrite(0);
}

void backlight(void) 
{
  _backlightval=LCD_BACKLIGHT;
  expanderWrite(0);
}

// Get status of blacklight
bool getBacklight() 
{
  return(_backlightval == LCD_BACKLIGHT);
}

void load_custom_character(uint8_t char_num, uint8_t *rows)
{
  createChar(char_num, rows);
}

void setBacklight(uint8_t new_val)
{
  if (new_val) 
  {
  backlight();    // turn backlight on
  } 
  else 
  {
  noBacklight();    // turn backlight off
  }
}

bool isinitialized(void)
{
   return(_initialized);
};

const lcd_host_t lcd =
{
  .init = lcdinit,
  .close = lcdclose,
  .printC = writeChar,
  .printStr = writeStr,
  .printStrXY = writeStrXY,   
  .cls = clear,
  .home = home,
  .hideDisplay = noDisplay,
  .showDisplay = display,
  .blinkOff = noBlink,
  .blinkOn = blink,
  .hideCursor = noCursor,
  .showcursor = cursor,
  .scrollLeft = scrollDisplayLeft,
  .scrollRight = scrollDisplayRight,
  .setLeftToRight = leftToRight,
  .setRightToLeft = rightToLeft,
  .backlightOff = noBacklight,
  .backlightOn = backlight,
  .getBacklight = getBacklight,
  .setAutoscrollMode = autoscroll,
  .setNoAutoscrollModel = noAutoscroll,
  .createChar = createChar,
  .setCursor = setCursor,
  .initialized =  isinitialized
} ;

Da sind noch Code-Reste drinnen, die viel. merkwürdig sind, einfach 
nicht beachten. Mittels einer LED konnte ich sehen, dass immerhin schon 
etwas auf den I2C-Bus geschickt wird.

Kommen wir zum Init,  muss vorher noch über die einzelnen Routinen 
gesprochen werden, die sich dann zum "verwenden" des I2C führen.
Aus

void LiquidCrystal_I2C::expanderWrite(uint8_t _data){                                        
  Wire.beginTransmission(_addr);
  Wire.write((int)(_data) | _backlightval);
  Wire.endTransmission();   
}

Wird bei mir:

inline void expanderWrite(uint8_t data)
{                                        
  data |= _backlightval;
    //bool I2C1_Write(uint16_t address, uint8_t *data, size_t dataLength)
    // & ?
  I2C1_Host.Write((uint16_t)lcdAddress, &data, sizeof(data) );
//  Wire.endTransmission();   
}

Da in

  I2C1_Host.Write((uint16_t)lcdAddress, &data, sizeof(data) );

alles "versteckt ist" was die I2C-Schnittstelle betrifft
wird kein Wire.begin mehr benötigt (oder etwa doch ?).
Unsicher bin ich beim Parameter data.

In der Headerdatei (von mcc generiert) ist das so
definiert

bool I2C1_Write(uint16_t address, uint8_t *data, size_t dataLength);

data ist ein Zeiger auf einen uint8_t-Wert. Ich denke mal mein &data 
sollte das richtig implementieren. Die Frage ist, wo befindet sich data 
denn ?
Wenn es auf dem Stack ist wird es nach dem Ende von expanderWrite 
irgendwann überschrieben. Da die I2C-Kommunikation aysynchron über einen 
Interrupt erfogt ist es möglich, dass an dieser Speicherstelle bereits 
etwas anderes steht. Um da auf der sichern Seite zu sein würde ich das 
dannn so implementieren :

inline void expanderWrite(uint8_t data)
{       
  static  uint8_t staticdata = data;
  staticdata |= _backlightval;
  I2C1_Host.Write((uint16_t)lcdAddress, &staticdata, sizeof(data) );
}

Die Routine

inline void pulseEnable(uint8_t _data)
{
  expanderWrite(_data | En);  // En high
      // enable pulse must be >450ns
  delayUs(1);
    
  expanderWrite(_data & ~En);  // En low
  delayUs(50);
       // commands need > 37us to settle
}

ist mir völlig unklar.Wenn ich davon ausgehe, dass I2C1_Host.Write
die einzige Schnittstelle zur I2C-Kommunikation drinnen ist
brauche ich pulseEnable doch gar nicht, oder ??

So, erst mal bis hierhin. Wenn diese Dinge geklärt/erklärt sind kann ich 
mich um die weiterer Implementierung kümmern, sonst wird das hier ein 
sinnloses tryAnderror.

Viele Grüße und danke für jede Hilfe

PS.: Da es vom Compiler Mecker wg. Stackgröße gabe habe ich viel mit 
inline gearbeitet und teilweise routinen auseinandergezogen, damit nicht 
so viele Calls den Stack zumüllen.

[Michael W. (miks)]

Ey Du Stoffel! Diesen Satz gelesen? Und auch verstanden?

● Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Meine Fresse...

[Harry R. (harryr)]

Michael W. schrieb:
> Ey Du Stoffel! Diesen Satz gelesen? Und auch verstanden?
Wenn's für dich zu lang ist, gilt das nicht für alle.
Mach' doch mal einen Längenvorschlag.
> ● Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang
>
> Meine Fresse...
Schmerzen von der letzten Prügelei ?
Gute Besserung :-)

[Christoph S. (155christo)]

Guten Abend:

Diese Seite kennst Du?

https://iradan.com/?p=420

"I used a standard 44780 16×2 LCD, a Tautic development board, and a PIC 
16F1509 (happens to come with the dev board). For programming I used 
MPLAB X IDE v1.95 and XC8 v1.21 (free version) and the PICkit 3 
programmer. The code is commented enough to figure out the hardware 
setup."

PIC1509 und LCD, ok ohne i2c, aber vlt hift es weiter.

[Stephan S. (uxdx)]

Harry R. schrieb:
> Michael W. schrieb:
>> Ey Du Stoffel! Diesen Satz gelesen? Und auch verstanden?
> Wenn's für dich zu lang ist, gilt das nicht für alle.
> Mach' doch mal einen Längenvorschlag.
>> ● Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang
>>
>> Meine Fresse...
> Schmerzen von der letzten Prügelei ?
> Gute Besserung :-)

Es ist schon eine Frechheit einen fast 500 Zeilen langen Quellcode 
einzufügen, dazu noch 'zig Leerzeilen und dann noch rumstänkern, wenn es 
den Mitlesern nicht passt.

Zu hast ganz oben schon mal einen Mitleser der einen korrekten Beitrag 
brachte angemacht, obwohl Du froh sein solltest, hier kostenlose Hilfe 
zu bekommen. Das Leben ist keine Einbahnstrasse: wenn Du etwas von der 
Community erwartest, kann die Community erwarten, dass Du Dich ihr 
anpasst und nicht umgekehrt.

[Harry R. (harryr)]

Christoph S. schrieb:
> Guten Abend:
>
> Diese Seite kennst Du?
>
> https://iradan.com/?p=420
>
> PIC1509 und LCD, ok ohne i2c, aber vlt hift es weiter.
Danke. Nein diese Seite kannte ich bisher nicht, aber das wird sich 
ändern.

[Harry R. (harryr)]

Stephan S. schrieb:

> Es ist schon eine Frechheit einen fast 500 Zeilen langen Quellcode
> einzufügen, dazu noch 'zig Leerzeilen und dann noch rumstänkern, wenn es
> den Mitlesern nicht passt.
- Die Leerzeilen fügt die Forumssoftware größtenteils selbst ein.
- Ich habe nicht gestänkert, sondern den Kommentar kommentiert.
> Zu hast ganz oben schon mal einen Mitleser der einen korrekten Beitrag
> brachte angemacht, obwohl Du froh sein solltest, hier kostenlose Hilfe
> zu bekommen.
Ich habe meine Meinung zu seinem Kommentar abgegeben, ist das hier 
verboten ?
> Das Leben ist keine Einbahnstrasse: wenn Du etwas von der
> Community erwartest, kann die Community erwarten, dass Du Dich ihr
> anpasst und nicht umgekehrt.
Hast du auch was zum Thema beizutragen oder suchst du einfach nur nach 
Dingen, die dir nicht gefallen ?

Einen schönen Abend noch :-)

[Stephan S. (uxdx)]

Harry R. schrieb:
> Hast du auch was zum Thema beizutragen oder suchst du einfach nur nach
> Dingen, die dir nicht gefallen ?

Ich hab etwas beizutragen:
Etwas mehr Dankbarkeit deinerseits den Leuten die Dir hier helfen wäre 
angebracht.

[Harry R. (harryr)]

Stephan S. schrieb:
> Harry R. schrieb:
>> Hast du auch was zum Thema beizutragen oder suchst du einfach nur nach
>> Dingen, die dir nicht gefallen ?
>
> Ich hab etwas beizutragen:
> Etwas mehr Dankbarkeit deinerseits den Leuten die Dir hier helfen wäre
> angebracht.
Ich bedanke mich für jede Hilfe, da kannst du gerne alle meine Beiträge 
durchlesen. Damit würde ich die Diskussion mit dir gerne beenden und das 
Ganze hier wieder auch fachlich/sachlicher Ebene weiter führen.