Mit dsPIC33FJ128GP802 ein LCD Display über I²C ansteuern

// This is a guard condition so that contents of this file are not included

// more than once.  

#ifndef I2C_MGMNT_H

#define  I2C_MGMNT_H

//#include <xc.h> // include processor files - each processor file is guarded.  

#ifdef  __cplusplus

extern "C" {

#endif /* __cplusplus */

#ifndef FCY

#define FCY             (unsigned long)10000000 //default FCY 10MHz

#endif

//#include <libpic30.h>

#ifndef I2C_BAUDRATE

#define I2C_BAUDRATE    (unsigned long)100000 //default baud rate 100kHz

#endif

#define I2C_ERROR           -1

#define I2C_OK              1

extern void i2c_init(void);

extern int setBaudRate(void);

extern int I2C_WriteReg(char dev_addr, char reg_addr, char value);

extern int I2C_ReadReg(char dev_addr, char reg_addr, char *value);

#ifdef  __cplusplus

}

#endif /* __cplusplus */

#endif  /* XC_HEADER_TEMPLATE_H */

/* I2C Register - Übersicht

 * http://ww1.microchip.com/downloads/en/DeviceDoc/70000195f.pdf

 * 

 * I2CxCON: I2Cx Control Register

 * I2CxSTAT: I2Cx Status Register

 * I2CxMSK: I2Cx Slave Mode Address Mask Register

 *      -> für mehrere Adressen

 * 

 * I2CxRCV: I2Cx Receive Buffer Register

 *      -> hier werden Daten gelesen

 * 

 * I2CxTRN: I2Cx Transmit Register

 *      -> hier werden Daten gesendet

 * 

 * I2CxADD: I2Cx Address Register

 *      -> Slave Adresse

 * 

 * I2CxBRG: I2Cx Baud Rate Generator Reload Register

 * 

 * ACKSTAT:

 *  Acknowledge Status bit 

 * 1 = NACK received from slave

 * 0 = ACK received from slave

 *  * 

 * TRSTAT: Transmit Status bit (I2C? Master mode transmit operation)

1 = Master transmit is in progress (8 bits + ACK)

0 = Master transmit is not in progress

 */

#include "i2c_mgmnt.h"

#include "p33FJ128GP802.h"

void i2c_init(void) {

    I2C1CONbits.I2CEN = 1; // enable I2C functionality

    I2C1CONbits.I2CSIDL = 0; // continue when idle

    I2C1CONbits.SCLREL = 1; // used in master mode           (nicht 100% sicher)

    I2C1CONbits.IPMIEN = 0; // don't use IPMI                (ein industriestandard, der dinge verumständlicht)

    I2C1CONbits.A10M = 0; // use 7-bit addressing

    I2C1CONbits.DISSLW = 1; // slew rate control disabled (nicht nötig in slow mode)

    I2C1CONbits.SMEN = 0; // don't use SMBus thresholds

    I2C1CONbits.GCEN = 0; //General call address disabled

    I2C1CONbits.STREN = 0; //Disable Software or release clock

    /*I2C1BRG = [( 1/Fscl - PGD)*Fcy/2]-2 = 195,4

     * Fcy = 40MHz

     * Fscl = 100KHz

     * PGD = 130ns

     */

    I2C1BRG = 195; // set the baud rate

    //__delay_ms(1);

    int i;

    for(i=0; i<1000; i++);

}

int I2C_WriteReg(char dev_addr, char reg_addr, char value)

{

    char wr_dev_addr = dev_addr << 1; //first bis is ACK

    // Send I2C start condition

  I2C1CONbits.SEN = 1;      

  while(I2C1CONbits.SEN == 1);

  // Send I2C device address on the bus for write operation

  I2C1TRN = wr_dev_addr;      

  while(I2C1STATbits.TRSTAT);      

  if (I2C1STATbits.ACKSTAT)        

  {                

    I2C1CONbits.PEN = 1;

    while(I2C1CONbits.PEN);      

    return I2C_ERROR;          

  }

    // Send register address on the bus

  I2C1TRN = reg_addr;

  while(I2C1STATbits.TRSTAT);

  if (I2C1STATbits.ACKSTAT)

  {

    I2C1CONbits.PEN = 1;

    while(I2C1CONbits.PEN);

    return I2C_ERROR;

  }

  // Send register value on the bus    

  I2C1TRN = value;

  while(I2C1STATbits.TRSTAT);

  if (I2C1STATbits.ACKSTAT)

  {

    I2C1CONbits.PEN = 1;

    while(I2C1CONbits.PEN);

    return I2C_ERROR;

  }

  /// Send I2C stop condition

  I2C1CONbits.PEN = 1;

  while(I2C1CONbits.PEN);

  return I2C_OK;

}

#include <p33FJ128GP802.h>

//Prozessorspezifische Headerdatei

#include "port_mgmnt.h"

#include "adw_mgmnt.h"

#include "pwm_mgmnt.h"

#include "system_init.h"

#include "read_write.h"

#include "timer_mgmnt.h"

#include "i2c_mgmnt.h"

//custom headers

void main(void) {

    clk_boost(80);

    clr_ports();

    i2c_init();

    while(1){

        //I2C_WriteReg(0x27, 0x40, 0xFF);

        I2C1CONbits.SEN = 1;  

        I2C1TRN = 0x56;

        while(I2C1CONbits.SEN == 1);

        I2C1TRN = 0x56;

    }

}

I2C_WriteReg(0x27, 0x40, 0xFF);

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    display_send(0b00000111);

    //übertragen einer instruction set Anweisung

    //entry mode set

    ////////////////////////////

    i2c_start();

    //starten des i2c Bus

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    i2c_write(0b00110100); //write func set second time

    //übertragen einer function set Anweisung

    waitXus(1);

    i2c_write(0b00110000);

    //übertragen einer function set Anweisung

    i2c_stop();

    waitXus(21500);

    //////////////////////////////////////

//display_mgmnt.c

#include "display_mgmnt.h"

#include <p33FJ128GP802.h>

//Prozessorspezifische Headerdatei

#include "i2c_mgmnt.h"

#include "timer_mgmnt.h"

#include "port_mgmnt.h"

//custom headers

#define backlight_on 0x04

int waitfor = 1;

int timecount = 0;

/*I2C Backpack: PCF8574AT, K44001, 05, KNM00463

 *standard I2C Adresse des PCF8574AT ICs ist 0x3F

 * I2C Datenword hat 8 Bit, wovon die unteren vier Bit für die Steuerung 

 * des Displays parallel an das HD44780U weitergegeben werden. Die oberen

 * drei Bit sind das enable, register select und das r/w Bit!

 * 

 * Die Frage ist, wo am IO Port des Displays das LSB des seriellen Datenwortes ausgegeben wird.

 * Pins am Display:     x   x   x   RS  RW  E   DB0 DB1 DB2 DB3 DB4 DB5 DB6 DB7 x   x

 * Pins vom PCF8574AT:              P0  P1  P2                  P4 P5 P6 P7

 * ==> Datenwort muss wie folgt an den PCF8574AT Übertragen werden: (MSB) DB7 DB6 DB5 DB4 x E RW RS (LSB)

 *  

 * Display muss also im 4 Bit Mode betrieben werden:

 * Es werden nur DB7-DB4 genutzt, 8 Bit Daten werden als zwei mal 4 Bit übertragen,

 * wobei erst die oberen und dann die unteren Bits gesendet werden. Nach jedem Paar 4 Bit 

 * Daten muss die Busy Flag abgefragt werden.

 * 

 * Das Display wird anfangs durch den Internal Reset Circuit mit verschiedenen Parametern initialisiert.

 * Für unseren Zweck müssen wir ein paar dieser Parameter ändern (siehe display_init).

 * 

 * Grundlegende Befehle:

 * RS 0, RW 0: Instruction Register write as internal operation

 * RS 0, RW 1: Read Busy Flag and AC (DB0 bis DB7)

 * RS 1, RW 0: Data Register write as internal operation

 * RS 1, RW 1: Data Register read as internal operation

 *

 * function set Befehl:

 * RS   RW  DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0

 * 0    0   0   0   1   DL  N   F   x   x

 * DL data/interface length: 1 8 Bit, 0 4 Bit

 * N number of display lines: 1 2 lines, 0 1 line

 * F character font: 1 5x10 dots, 0 5x8 dots

 * 

 * display control Befehl:

 * RS   RW  DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0

 * 0    0   0   0   0   0   1   D   C   B

 * D display on/off

 * C cursor on/off

 * B blinking cursor on/off

 * 

 * entry mode Befehl:

 * RS   RW  DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0

 * 0    0   0   0   0   0   0   1   I/D S

 * I/D: 0 decrement, 1 increment

 * S: 1 accompanies display shift

 * 

 */

void waitXus(int val) {

    timecount = 0;

    set_timer4(0, val, 16);

    while (timecount == 0);

    timecount = 0;

    T4CONbits.TON = 0;

    //Disable Timer 4

}

void display_send(unsigned int data) {

    //data: 8 Bit, MSB DB7 ... DB0 LSB

    //nur instructions: RS 0, RW 0

    i2c_write((data & 0xF0) | 0x04);

    //übertragen der der oberen Bit mit E high

    waitXus(1);

    i2c_write(data & 0xF0);

    //übertragen der der oberen Bit mit E low

    waitXus(250);

    i2c_write((data << 4) | 0x04);

    //übertragen der der unteren Bit mit E high

    waitXus(1);

    i2c_write(data << 4);

    //übertragen der der unteren Bit mit E low

    waitXus(250);

}

int check_bf(char deviceid) {

    //ließt des Status des busy flags aus und übergibt ihn

    unsigned char bf = 0;

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    i2c_write(0b00000110);

    //Schreiben der busy flag read instruction

    //setzen des enable bits gleichzeitig mit dem Rest. Eventuell früher nötig?

    i2c_restart();

    //Neustart des Bus

    i2c_write((deviceid << 1) | 0x1);

    //ansprechen des Slaves mit Lesebefehl

    bf = i2c_read(8);

    //Funktion muss auch vor dem Einstellen der 4 Bit operation funktionieren

    //eigentlich nur die oberen 4 Bit interessant, deshalb nur einmaliges Lesen

    //zurückgegebene Bits entsprechen: x RS RW E DB7 DB6 DB5 DB4

    i2c_restart();

    //Neustart des Bus

    if (bf & 0x80) return 1;

        //busy flag up!

    else return 0;

    //no busy flag

}

void display_clear(char deviceid) {

    //leert das gesamte Display

    while (check_bf(deviceid)); //wait for busy flag to clear

    i2c_write(deviceid << 1); //ansprechen des Slaves mit Schreibbefehl

    i2c_write(0b00000100); //übertragen einer instruction set Anweisung Teil 1

    waitXus(1);

    i2c_write(0b00010100);

    //übertragen einer instruction set Anweisung Teil 2

    waitXus(250);

    //display clear

}

void display_init(char deviceid) {

    //initiiert das LCD und führt einen clear aus

    //Werte für das Warten mit Timer 4:

    //21500 4,3 ms

    //600 120us

    //250 50us

    timecount = 0; //warte auf betriebsspannung ~50ms

    set_timer4(0, 25000, 16);

    while (timecount < 10);

    timecount = 0;

    //40ms warten

    T4CONbits.TON = 0;

    //Disable Timer 4

    i2c_start();

    //starten des i2c Bus

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    i2c_write(0b00110100); //write func set first time

    //übertragen einer function set Anweisung

    //waitXus(1);

    i2c_write(0b00110000);

    //übertragen einer function set Anweisung

    i2c_stop();

    waitXus(21500);

    ////////////////////////////

    i2c_start();

    //starten des i2c Bus

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    i2c_write(0b00110100); //write func set second time

    //übertragen einer function set Anweisung

    waitXus(1);

    i2c_write(0b00110000);

    //übertragen einer function set Anweisung

    i2c_stop();

    waitXus(21500);

    //////////////////////////////////////

    i2c_start();

    //starten des i2c Bus

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    i2c_write(0b00110100); //write func set third time

    //übertragen einer function set Anweisung

    //waitXus(1);

    i2c_write(0b00110000);

    //übertragen einer function set Anweisung

    i2c_stop();

    //waitXus(250);

    i2c_start();

    //starten des i2c Bus

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    i2c_write(0b00110100);

    //übertragen einer function set Anweisung

    //waitXus(1);

    i2c_write(0b00110000);

    //übertragen einer function set Anweisung

    i2c_stop();

    //waitXus(250);

    i2c_start();

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl    

    i2c_write(0b00100100);

    //übertragen einer function set Anweisung    

    //waitXus(1);

    i2c_write(0b00100000);

    //übertragen einer function set Anweisung

    //waitXus(250);

    while (check_bf(deviceid));

    //wait for busy flag to clear

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    display_send(0b00111000);

    //übertragen der function set Anweisung

    //4 Bit mode, 2 lines, 5x8 dots

    while (check_bf(deviceid));

    //wait for busy flag to clear

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    display_send(0b00001111);

    //übertragen einer instruction set Anweisung

    //display & cursor off, blinking cursor off

    display_clear(deviceid);

    while (check_bf(deviceid));

    //wait for busy flag to clear

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    display_send(0b00000111);

    //übertragen einer instruction set Anweisung

    //entry mode set

    i2c_stop();

    waitXus(21500);

}

void __attribute__((__interrupt__, no_auto_psv)) _T4Interrupt(void) {

    waitfor = 0;

    timecount++;

    //d_write(25, ~d_read(25));

    //T4CONbits.TON = 0;

    //Timer 4 wieder ausschalten

    IFS1bits.T4IF = 0;

    //Clear Timer 4 Interrupt Flag

}

int display_write(char deviceid, char *text) {

    //schreibt eine Abfolge von Zeichen sequentiell auf das Display

    return 1;

}

------ Ende display_mgmnt.h

/* 

 * File:   display_mgmnt.h

 * Author: finst

 *

 * Created on 13. Dezember 2017, 20:00

 */

#ifndef DISPLAY_MGMNT_H

#define  DISPLAY_MGMNT_H

#ifdef  __cplusplus

extern "C" {

#endif

    extern void display_clear(char deviceid);

    extern void display_init(char deviceid);

    extern void __attribute__((__interrupt__, no_auto_psv)) _T4Interrupt(void);

    extern int timecount;

    extern void display_send(unsigned int data);

    extern int check_bf(char deviceid);

    extern void waitXus(int val);

#ifdef  __cplusplus

}

#endif

#endif  /* DISPLAY_MGMNT_H */

-------

//i2c_mgmnt.c

/* I2C Register - Übersicht

 * http://ww1.microchip.com/downloads/en/DeviceDoc/70000195f.pdf

 * 

 * I2CxCON: I2Cx Control Register

 * I2CxSTAT: I2Cx Status Register

 * I2CxMSK: I2Cx Slave Mode Address Mask Register

 *      -> für mehrere Adressen

 * 

 * I2CxRCV: I2Cx Receive Buffer Register

 *      -> hier werden Daten gelesen

 * 

 * I2CxTRN: I2Cx Transmit Register

 *      -> hier werden Daten gesendet

 * 

 * I2CxADD: I2Cx Address Register

 *      -> Slave Adresse

 * 

 * I2CxBRG: I2Cx Baud Rate Generator Reload Register

 * 

 * ACKSTAT:

 * Acknowledge Status bit 

 * 1 = NACK received from slave

 * 0 = ACK received from slave

 * 

 * TRSTAT: Transmit Status bit (I2C? Master mode transmit operation)

 * 1 = Master transmit is in progress (8 bits + ACK)

 * 0 = Master transmit is not in progress

 * 

 * Beim Senden der Adresse muss an der Stelle Null des Datenwortes ein R/!W Bit eingefügt werden, 

 * sodass der Slave weiß, wer sendet und wer empfängt!

 * 0: master tx, slave rx

 * 1: master rx, slave tx

 * 

 * 

 * Generelle Funktionsstruktur nach Patz:

 * start - startbiz, deviceid, ACK y/n

 * writedata - data (reg addr / data), ACK y/n

 * stop

 * readdata - data, ACK y/n

 */

#include "i2c_mgmnt.h"

#include "p33FJ128GP802.h"

#include "port_mgmnt.h"

void i2c_init(void) { 

    //I2C1BRG = [( 1/Fscl - PGD)*Fcy/2]-2 = 195,4

    //Fcy = 40MHz

    //Fscl = 100KHz

    //PGD = 130ns

    pin_cfg(17, 'd', 'i');

    pin_cfg(18, 'd', 'i');

    //default Konfiguration der Pins, sonst läuft nix

    //SDA, SCL fest verbunden mit Pin 17 & 18

    I2C1BRG = 195; 

    //set baud rate, siehe oben

    I2C1CONbits.I2CEN = 1; 

    //enable I2C functionality

    while(I2C1CONbits.I2CEN == 0);

    //wait until enabled

}

int i2c_start(void){

    IFS1bits.MI2C1IF = 0;

    //löschen des Interrpt Flags

    I2C1CONbits.SEN = 1;

    //send I2C start condition

    while(!IFS1bits.MI2C1IF == 1);

    //warten auf interrupt flag zur Bestätigung

    IFS1bits.MI2C1IF = 0;

    //IF der I2C  Master Events klären

    if (I2C1STATbits.ACKSTAT){

        //Fehler?                      

        return 0;          

    }

    else return 1;

    //Start erfolgreich

}

int i2c_restart(void){

    IFS1bits.MI2C1IF = 0;

    //löschen des Interrpt Flags

    while(I2C1CON & 0x001F);

    //untere fünf Bit des Control Registers müssen null sein, sonst kein Restart zulässig

    I2C1CONbits.RSEN = 1;

    //send I2C restart condition

    while(!IFS1bits.MI2C1IF == 1);

    //warten auf interrupt flag zur Bestätigung

    IFS1bits.MI2C1IF = 0;

    //IF der I2C  Master Events klären

    if (I2C1STATbits.ACKSTAT){

        //Fehler?                      

        return 0;          

    }

    else return 1;

    //Restart erfolgreich

}

int i2c_stop(void){

    IFS1bits.MI2C1IF = 0;

    //löschen des Interrpt Flags

    while(I2C1CON & 0x001F);

    //untere fünf Bit des Control Registers müssen null sein, sonst kein Stop zulässig

    I2C1CONbits.PEN = 1;

    //send I2C start condition

    while(!IFS1bits.MI2C1IF == 1);

    //warten auf interrupt flag zur Bestätigung

    IFS1bits.MI2C1IF = 0;

    //IF der I2C  Master Events klären

    if (I2C1STATbits.ACKSTAT){

        //Fehler?                      

        return 0;          

    }

    else return 1;

    //Stop erfolgreich

}

int i2c_write(char data){

    IFS1bits.MI2C1IF = 0;

    //IF der I2C  Master Events klären

  I2C1TRN = data;  

    //Schreiben der Daten ins Transmit Register

  while(!IFS1bits.MI2C1IF == 1);

    //warten auf interrupt flag zur Bestätigung

    IFS1bits.MI2C1IF = 0;

    //IF der I2C  Master Events klären

  if (I2C1STATbits.ACKSTAT){

        //Fehler?

    return 0;          

  }

    else return 1;

    //Schreiben erfolgreich

}

void i2c_ack(int yn){

    //yn: 0 send ACK, 1 send NACK

    I2C1CONbits.ACKDT=yn;

    //entweder ACK oder NACK senden

    while(I2C1CON & 0x001F);

    //untere fünf Bit des Control Registers müssen null sein, sonst kein Lesen zulässig

    IFS1bits.MI2C1IF = 0;

    //IF der I2C  Master Events klären

    I2C1CONbits.ACKEN=1;

    //starten der acknowledge Sequenz

  while(!IFS1bits.MI2C1IF == 1);

    //warten auf interrupt flag zur Bestätigung

    IFS1bits.MI2C1IF = 0;

    //IF der I2C  Master Events klären

}

char i2c_read(int bits){

    //bits: 8 empfangen von 8 Bit, 16 empfangen von 16 Bit

    //Diese Funktion kann entweder 8 oder 16 Bit empfangen.

    //Mehr ist in unserem Fall nicht notwendig, da unsere Slaves eher 

    //16 Bit oder kleinere Register haben.

    unsigned char buffer=0;

    //Speicher für den Rückgabewert

    while(I2C1CON & 0x001F);

    //untere fünf Bit des Control Registers müssen null sein, sonst kein Lesen zulässig

    IFS1bits.MI2C1IF = 0;

    //IF der I2C  Master Events klären

    I2C1CONbits.RCEN=1;

    //ready to receive

  while(!IFS1bits.MI2C1IF == 1);

    //warten auf interrupt flag zur Bestätigung

    buffer = I2C1RCV;

    //speichern des empfangenen Bytes

    IFS1bits.MI2C1IF = 0;

    //IF der I2C  Master Events klären

    if(bits == 16){

        i2c_ack(0);

        //falls empfangene Nachricht nicht komplett: senden eines acknowledge

        IFS1bits.MI2C1IF = 0;

        //IF der I2C  Master Events klären

        I2C1CONbits.RCEN=1;

        //ready to receive

        buffer = buffer << 8;

        //Platz machen für die nächsten 8 Bit

        while(!IFS1bits.MI2C1IF == 1);

        //warten auf interrupt flag zur Bestätigung

        buffer = buffer + I2C1RCV;

        //speichern des empfangenen Bytes

        IFS1bits.MI2C1IF = 0;

        //IF der I2C  Master Events klären

    }

    i2c_ack(1);

    //falls empfangene Nachricht komplett: senden eines not acknowledge

  return buffer;

    //Rückgabe des empfangenen Wertes

}

----- ende i2c_mgmnt.c

//main

#include <p33FJ128GP802.h>

//Prozessorspezifische Headerdatei

#include "port_mgmnt.h"

//#include "adw_mgmnt.h"

//#include "pwm_mgmnt.h"

#include "system_init.h"

//#include "read_write.h"

#include "timer_mgmnt.h"

#include "i2c_mgmnt.h"

#include "clk_mgmnt.h"

#include "display_mgmnt.h"

//custom headers

void main(void) {

    char deviceid = 0x3F;

    clk_boost(80);

    clr_ports();

    i2c_init();

    //setup

    display_init(deviceid);

    pin_cfg(25, 'd', 'o');

    //set_timer4(0, 250, 16);

    /*i2c_start();

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    display_send(0b00001111);

    check_bf(deviceid);

    int data = 0b01000001;

    i2c_write(deviceid << 1);

    //ansprechen des Slaves mit Schreibbefehl

    i2c_write((data & 0xF0) | 0x05);

    //übertragen der der oberen Bit mit E high

    set_timer4(0, 1, 16);

    while(timecount == 0);

    timecount = 0;

    T4CONbits.TON = 0;      

    //Disable Timer 4

    i2c_write((data & 0xF0) | 0x01);

    //übertragen der der oberen Bit mit E low

    set_timer4(0, 250, 16);

    while(timecount == 0);

    timecount = 0;

    T4CONbits.TON = 0;      

    //Disable Timer 4

    i2c_write((data<<4) | 0x05);

    //übertragen der der unteren Bit mit E high

    set_timer4(0, 1, 16);

    while(timecount == 0);

    timecount = 0;

    T4CONbits.TON = 0;      

    //Disable Timer 4

    i2c_write((data<<4) | 0x01);

    //übertragen der der unteren Bit mit E low

    set_timer4(0, 250, 16);

    while(timecount == 0);

    timecount = 0;

    T4CONbits.TON = 0;      

    //Disable Timer 4

    i2c_write(0b00001000); // turn backlight on

    i2c_stop();*/

    while (1) {

        i2c_start();

        while(check_bf(deviceid));

        int data = 0b11101101;

        i2c_write(deviceid << 1);

        //ansprechen des Slaves mit Schreibbefehl

        i2c_write((data & 0xF0) | 0x05);

        //übertragen der der oberen Bit mit E high

        waitXus(1);

        i2c_write((data & 0xF0) | 0x01);

        //übertragen der der oberen Bit mit E low        

        waitXus(250);

        i2c_write((data << 4) | 0x05);

        //übertragen der der unteren Bit mit E high

        waitXus(1);

        i2c_write((data << 4) | 0x01);

        //übertragen der der unteren Bit mit E low

        waitXus(250);

        i2c_write(0b00001000); // turn backlight on

        i2c_stop();

    }

}