Afficheur LCD

[invite2d9e7c03]

qu'est ce qui ne marche pas exactement.
pour moi c'a bien marché.
est ce que c'est un probleme de brochage ou de programmation
bon courage
-----

[invitec2ba3917]

Bonjour,
Je pense avoir trouvé comme toi :

1-(+5V)
2-not used
3-CLK
4-DATA
5- E
6- RS
7-GND

Mais regarde si ça vient du même lien :
http://www.eio.com/public/lcd.2004/1855.html

Ce brochage est incorrect , car le pin 2 est représente le CLK pour le circuit 74H164 .
et donc , voici la version correct du brochage :

1-(+5V)
2-CLK pour 74HC164
3-CLK pour 74HC74
4-DATA
5- E
6- RS
7-GND
en effet , le 74HC164 est un convertisseur série/parallèle 8bits (Registre à décalage) , et le 74HC74 est une bascule D (Latch ) ( puisque le HD44780 (Driver LCD) fonctionne en mode parallèle)
d'où la gestion de cette afficheur lcd est exactement comme lcd standard (parallèle) sauf que la donnée (DATA) se transmit en mode série .
et donc pour envoyer un octet au HD44780(qui fonctionne en mode parallèle) , il faut le transmettre en série avec 8 coude d'horloge sur les pin 2 et 3.
et après avoir que le 74HC164 reconstruit l'octet (sous forme // ) vous pouvez commandez l'afficheur LCD D 48 08040 60.

[invitef0bbc377]

Bonjour
je veut savoir qu'est ce qu'il faut modifier dans le ".h" (le driver) d'un afficheur de type HD44780 simple(8 ou 4 ligne de donnée)
d'une autre façon comment assurer l'interfaçage série avec le uC en point de vue programmation
même un petit idée peut être important pour moi
merci

[invitec71dc2a4]

Salut,
s.v.p aide moi
je veux un programme de I2C dans C qui afficher sur LCD afficheur HH:MM:SS
et merci

[invite03481543]

Bonsoir,

quelques fonctions pour gérer un LCD avec 2 PCF8574P en mode 8 bits.
Un autre pour gérer un clavier.

#include "Config_Reg_sol.h"
#include "RTC_DS1307_v1.h"
#include "Reg_sol.h"

// adresse courante du curseur , positionné dans LCD_busy //
int static cursor_adr;

// Les textes à afficher stockés en Flash
const char *message_lcd31 = {"  h  mn    s"} ;
const char *message_lcd32 = {"  /     20  "} ;

const char *message_lcd33 = {"Reg. Horloge"} ;

const char *message_lcd35 = {" Annulation "} ;
const char *message_lcd36 = {"  Appuyer   "} ;
const char *message_lcd37 = {"   sur V    "} ;
const char *message_lcd38 = {"Oui:+  Non:-"} ;

// Prototype des fonctions

short I2C_W_pcf8574(unsigned short data, unsigned short adr);
short init_lcd(void);

char LCD_write_BYTE(char regdir, char data);
char LCD_read_BYTE(char regdir, char data);
char LCD_write_char(int data);
char LCD_write_str(const char *lstr);

char LCD_get_adress(void);

char LCD_busy(void);
void efface_LCD(void);
void LCD_pos(unsigned char ligne,unsigned char pos);
void Static_LCD_text(void);

char Scrut_Clavier_I2C(char Adresse);

void init_LCD_BL(void);
void test_touche_PLUS(void);
void test_touche_MOINS(void);
void test_touche_VALID(void);
void test_touche_MENU(void);

void lecture_RTC(void);

/******************************************************************************/
/*************   Fonction permettant d'écrire dans le PCF8574   ***************/
/******************************************************************************/

char I2C_W_pcf8574(unsigned char data, unsigned char adr)
{
 char ret ;
 I2C_Start() ;
 while(I2C_Is_Idle() == 0) ;
 ret = I2C_Wr(adr) ;
 while(I2C_Is_Idle() == 0) ;
 ret = I2C_Wr(data);
 if(ret == 0) I2C_stop() ;
 return(ret) ;
}

/******************************************************************************/
/*************   Fonction permettant de lire dans le PCF8574   ****************/
/******************************************************************************/

char I2C_R_pcf8574(unsigned char *data, unsigned char adr)
{
 char ret ;
 I2C_Start() ;
 while(I2C_Is_Idle() == 0) ;
 ret = I2C_Wr(adr) ;
 if (ret == 0)
    {
    *data = I2C_Rd(0) ;
    while(I2C_Is_Idle() == 0) ;
    }
 else *data = 0 ;
 I2C_Stop() ;
 return(ret) ;
}

/******************************************************************************/
/********* Initialisation de l'afficheur en mode 8-BIT , 2 lignes *************/
/******************************************************************************/
char init_lcd(void)
{
 char ret ;
 ret = 0 ;
 Delay_ms(30) ;                           // on attend + de 15ms
 LCD_write_BYTE(LCD_IREG, 0x30) ;
 Delay_ms(10);
 LCD_write_BYTE(LCD_IREG, 0x30) ;
 Delay_ms(3);
 LCD_write_BYTE(LCD_IREG, 0x30) ;
 Delay_ms(2);
 LCD_write_BYTE(LCD_IREG, 0x38) ;
 LCD_write_BYTE(LCD_IREG, 0x08) ;
 LCD_write_BYTE(LCD_IREG, 0x01) ;
 LCD_write_BYTE(LCD_IREG, 0x06) ;
 LCD_write_BYTE(LCD_IREG, 0x0C) ;

 return(ret) ;
}

/******************************************************************************/
/*****************       Scrutation du clavier      *******************/
/******************************************************************************/

char Scrut_Clavier_I2C(char Adresse)  /* lecture du clavier matriciel */
{
 char i,Clav_mode ;
 char Key, Key1 ;

  Key = 0 ;

  Clav_mode = 0 ;     /* controle le mode range/colone sur le clavier */
  
  while(Clav_mode < 2)
  {
    if(clav_mode == 0)
      {
      I2C_W_pcf8574(0xE0, PCF_CLAVIER_W) ; /*force les ranges a 1 sauf BL */
      while(I2C_Is_Idle() == 0) ;
      }
    
    if(clav_mode == 1)
      {
      I2C_W_pcf8574(0x0F, PCF_CLAVIER_W) ; /*force les colones a 1 */
      while(I2C_Is_Idle() == 0) ;
      }

    I2C_R_pcf8574(&Key1, PCF_CLAVIER_R) ;
    while(I2C_Is_Idle() == 0) ;
    Key = Key1 | Key ;
    Clav_mode = Clav_mode+1 ;

  }
  I2C_W_pcf8574(0xEF, PCF_CLAVIER_W) ;
   while(I2C_Is_Idle() == 0) ;
  return(Key) ;
}

/******************************************************************************/
/*****************     Masque ecran par defaut (RTC)      *******************/
/******************************************************************************/

void Static_LCD_text(void)
{
 efface_LCD() ;
 Delay_ms(20) ;
 LCD_pos(0,0) ;
 LCD_write_str(message_lcd31) ;
 LCD_pos(1,0) ;
 LCD_write_str(message_lcd32) ;
}

/******************************************************************************/
/*****************      écrit un BYTE sur l'afficheur      ******************/
/******************************************************************************/

char LCD_write_BYTE(char regdir, char data)
{
  char ret ;

  if (regdir == LCD_IREG)  // Si registre de commande utilisé
     {
     I2C_W_pcf8574(2, PCF_LCD_CONTROL_W) ;                // R/W=0,Enable=1, RS=0
     I2C_W_pcf8574(data, PCF_LCD_DATA_W) ;    // on présente le BYTE sur le bus Data
     Delay_ms(5) ;
     I2C_W_pcf8574(0, PCF_LCD_CONTROL_W) ;                // R/W=0,Enable=0, RS=0 => transfert BYTE
     Delay_ms(5) ;
     I2C_W_pcf8574(2, PCF_LCD_CONTROL_W) ;                // R/W=0,Enable=1, RS=0
     Delay_ms(5) ;
     }
     
  else if(regdir == LCD_DREG)
     {
     I2C_W_pcf8574(3, PCF_LCD_CONTROL_W) ;                // R/W=0,Enable=1, RS=1
     I2C_W_pcf8574(data, PCF_LCD_DATA_W) ;    // on présente le BYTE sur le bus Data
     Delay_ms(5);
     I2C_W_pcf8574(1, PCF_LCD_CONTROL_W) ;                // R/W=0,Enable=0, RS=1 => transfert BYTE
     Delay_ms(5) ;
     I2C_W_pcf8574(3, PCF_LCD_CONTROL_W) ;                // R/W=0,Enable=1, RS=1
     Delay_ms(5) ;
     }

 return(ret) ;
}

/******************************************************************************/
/************         Ecrire une chaine sur l'afficheur                    ****************/
/************      l'adresse doit être fixée au préalable      ****************/
/******************************************************************************/

char LCD_write_str(const char *lstr)
{
 char ret ;
 char *dest ;
 char buf[LCD_CHR+1] ;
 char i, n ;
 
 ret = 1 ;
 dest = buf ;
 *dest = *lstr ;
 i = LCD_CHR ;
 for (n = 0; n < i; n++) lcd_write_char(lstr[n]) ;
 *dest = 0 ;
 return(ret) ;
}


/******************************************************************************/
/****************     Ecrire un char sur l'afficheur       ********************/
/******************************************************************************/

char LCD_write_char(int data)
{
 char ret ;
 ret = 0 ;
 if(!lcd_busy()) ret = LCD_write_BYTE(LCD_DREG,data) ;
 return(ret) ;
}

/******************************************************************************/
/************          Lire un char dans l'afficheur          *****************/
/******************************************************************************/

char LCD_read_char(char *data, char adr)
{
 char ret ;
 char data1 ;
 ret = 1 ;
 ret = LCD_write_BYTE(LCD_IREG, 0x80 + adr) ;                // position de l'adresse
 if(!LCD_busy())
   {
   *data = LCD_read_BYTE(LCD_DREG, data1) ;
   }
 return(ret) ;
}

/******************************************************************************/
/***********    Test si l'afficheur est occupé, 1 = Busy , 0 = OK   ***********/
/******************************************************************************/

char LCD_busy(void)
{
  char busy, time_cnt, time_out, busy_flag, data1 ;
  time_out = 10 ;         // 10x Test
  time_cnt = 0 ;   // compteur temps initialisé à 0.
  busy = 1 ;

  do {
     time_cnt++ ;
     busy_flag = LCD_read_BYTE(data1, LCD_IREG) ;
     busy_flag = (busy_flag >> 8) & 0x01 ;
     Delay_ms(1) ;

     if (busy_flag == 1 ) busy = 1 ;

     else if(busy_flag == 0)
        {
        busy = 0 ;
        cursor_adr = data1 ;
        break ;
        }
     }
  while (time_cnt < time_out) ;
  return(busy) ;
}

/******************************************************************************/
/*****************       lit un BYTE sur l'afficheur      *******************/
/******************************************************************************/

char LCD_read_BYTE(char regdir, char data)
{
  char ibyte ;
  char ret ;
  ret   = 0 ;
  ibyte = 0 ;

  if (regdir == LCD_IREG)
     {
     I2C_W_pcf8574(6, PCF_LCD_CONTROL_W) ; // R/W=1, E=1, RS=0
     I2C_R_pcf8574(&ibyte,PCF_LCD_DATA_R) ;
     Delay_ms(1) ;
     I2C_W_pcf8574(4, PCF_LCD_CONTROL_W) ; // R/W=1, E=0, RS=0
     Delay_ms(1) ;
     I2C_W_pcf8574(6, PCF_LCD_CONTROL_W) ; // R/W=1, E=1, RS=0
     }
     
  else if(regdir == LCD_DREG)
     {
     I2C_W_pcf8574(7, PCF_LCD_CONTROL_W) ; // R/W=1, E=1, RS=1
     I2C_R_pcf8574(&ibyte,PCF_LCD_DATA_R) ;
     Delay_ms(1) ;
     I2C_W_pcf8574(5, PCF_LCD_CONTROL_W) ; // R/W=1, E=0, RS=1
     Delay_ms(1) ;
     I2C_W_pcf8574(7, PCF_LCD_CONTROL_W) ; // R/W=1, E=1, RS=1
     }

  return (ibyte) ;
}

/******************************************************************************/
/*****************       Efface l'afficheur         *******************/
/******************************************************************************/
void efface_LCD()
{
LCD_write_BYTE(LCD_IREG, 0x01) ;                  // Clear LCD
Delay_ms(5) ;
LCD_write_BYTE(LCD_IREG, 0x01) ;                  // Clear LCD
Delay_ms(10) ;
}

/******************************************************************************/
/*****************       fixe la position du texte sur l'afficheur      *******************/
/******************************************************************************/ 

void LCD_pos(unsigned char ligne,unsigned char pos)
{
if(ligne == 0)
  {
  LCD_write_BYTE(LCD_IREG, 0x80+pos) ;   // 0x80 -> adresse DDRAM + début ligne
  }
if(ligne == 1)
  {
  LCD_write_BYTE(LCD_IREG, 0xC0+pos) ;   // 0xC0 -> adresse DDRAM+0x40 (2eme ligne)
  }
}
/******************************************************************************/
/*****************       entrée du programme      *******************/
/******************************************************************************/

void main(void)
{

init_pic() ;
init_LCD_BL() ;

Delay_ms(500) ;
asm CLRWDT ;
etat_BL=BL_ON ;
I2C_W_pcf8574(BL_ON, PCF_CLAVIER_W) ;   // on allume le back light
efface_LCD() ;
Delay_ms(50) ;
LCD_pos(0,0) ;                 // on positionne le message sur ligne 1, colonne 0
LCD_write_str(message_lcd01) ;
LCD_pos(1,0) ;                 // on positionne le message sur ligne 2, colonne 0
LCD_write_str(message_lcd02) ;
Delay_ms(800) ;
asm clrwdt ;
efface_LCD() ;
//ds1307_write(seconds_reg,0x80) ;   // pointe sur le registre des secondes (on met le bit 7 à 1 (enable RTC)
while (I2C_Is_Idle() == 0) ;
Delay_ms(5) ;
Static_LCD_text() ;
Delay_ms(5) ;
Test_RTC() ;
ds1307_write(control_reg, 0b10010000) ; // SQW à 1Hz
Delay_ms(50) ;
asm CLRWDT ;
lecture_RTC() ;
Delay_ms(10) ;

    while(1)
         {
         asm CLRWDT ;
         Cpt_Rendu = Scrut_Clavier_I2C(PCF_CLAVIER_W) ;
         
         if(Cpt_Rendu != 0)
           {
           clavier_detect = 1 ;
           TMR1IE = 0 ;
           }
           
         else if(Cpt_Rendu == 0)
                {
                clavier_detect = 0 ;
                TMR1IE = 1 ;
                }

         if((flag == 1) && (clavier_detect == 0))
           {
           Delay_ms(10) ;
           flag = 0 ;
           tick = 0 ;
           }
           
        // on scrute le clavier
         while(Cpt_Rendu != 0)
         {
         TMR1IE = 0 ;
         asm CLRWDT ;
         test_touche_PLUS()  ;
         test_touche_MOINS() ;

         test_touche_MENU()  ;
         touche_PLUS_MENU()  ;

         touche_PLUS_MOINS() ;
         
         if(Cpt_Rendu == 0x2D)    // Touche "+" ET "M"    (affichage de la RTC)
           {                      //                      (jusqu'à que MENU soit détecté)
           Cpt_Rendu = 0 ;

           efface_LCD() ;
           Static_LCD_text() ;
           Delay_ms(10) ;
           while(!(Cpt_Rendu == 0x6E))   // touche "menu"
               {
               asm CLRWDT ;
               Cpt_Rendu = Scrut_Clavier_I2C(PCF_CLAVIER_W) ;
               lecture_RTC() ;
               }
            }
         
         
         if(Cpt_Rendu == 0x6D)    // Touche "Valid"
               {
               Cpt_Rendu = 0 ;
//............... etc
               }
....
}

[invite03481543]

////////////////////////////////////////////////////////////////////////////////
///                        DS1307 source code                                ///
////////////////////////////////////////////////////////////////////////////////



#include "RTC_DS1307_v1.h"

#define DS1307_DevAdr_Wr       0xD0 //DS1307 Address write mode
#define DS1307_DevAdr_Rd       0xD1 //DS1307 Address read mode



// I2C_Rd(0); send not acknowledge bit
// I2C_Rd(1); send acknowledge bit
// déclaration des variables //

unsigned short result;
char *txt;
unsigned short bcd_data,dec_data,bcd;

// prototypes des fonctions

void RTC_Initial_values(void);  // Valeurs initiales de l'horloge
void ds1307_write(unsigned short rtcreg, unsigned short rtc_data); 
void Read_DS1307(void);
unsigned char ds1307_read_RTC(unsigned char RTC_reg);

void mode_menu(char registre_temps);


//==============================================================================
//                     Temps et date à l'initialisation
//==============================================================================

void RTC_Initial_values() 
{
 I2C_Stop();
 delay_ms(50);

 ds1307_write(seconds_reg,0x00);   // pointe sur le registre des secondes
 while (I2C_Is_Idle() == 0) ;
 ds1307_write(minutes_reg,0x00);   // pointe sur le registre des minutes (0mn)
 while (I2C_Is_Idle() == 0) ;
 ds1307_write(hours_reg,0x16);     // pointe sur le registre des heures (16h)
 while (I2C_Is_Idle() == 0) ;
 ds1307_write(day_reg,0x00);       // pointe sur le registre des jours de la semaine(lundi, mardi, etc)
 while (I2C_Is_Idle() == 0) ;
 ds1307_write(date_reg,0x04);      // pointe sur le registre de la date du jour (n° du jour)
 while (I2C_Is_Idle() == 0) ;
 ds1307_write(month_reg,0x08);     // pointe sur le registre des mois
 while (I2C_Is_Idle() == 0) ;
 ds1307_write(year_reg,0x08);      // pointe sur le registre des années
 while (I2C_Is_Idle() == 0) ;
}

//==============================================================================
//               Ecrire dans les registres de l'horloge I2C DS1307
//==============================================================================

void ds1307_write(unsigned char rtcreg, unsigned char rtc_data)
{
// I2C_Stop();
// delay_ms(10);
 while (I2C_Is_Idle() == 0) ;
 I2c_start();

 I2c_Wr(DS1307_DevAdr_Wr);       // 1101 000 is addres of slave and last 0 is for direction (write)
 while (i2c_Is_Idle() == 0) ;
 I2c_Wr(rtcreg);                 // we tell in which register we want to write
 while (i2c_Is_Idle() == 0) ;
 I2c_Wr(rtc_data);              // write data in that register
 while (i2c_Is_Idle() == 0) ;
// asm nop;
 I2c_stop(); 
} 

unsigned char ds1307_read_RTC(unsigned char RTC_reg)
{
 char RTC_data=0;
 
// I2C_Stop();
// delay_ms(10);
 while (I2C_Is_Idle() == 0) ;
 I2c_start();
 while (i2c_Is_Idle() == 0) ;
 I2c_Wr(DS1307_DevAdr_Wr);       // 1101 000 is addres of slave and last 0 is for direction (write)
 while (i2c_Is_Idle() == 0) ;
 I2c_Wr(RTC_reg);
 while (I2C_Is_Idle() == 0) ;
 I2C_Repeated_Start();
 while (i2c_Is_Idle() == 0) ;
 I2c_Wr(DS1307_DevAdr_Rd);
 while (I2C_Is_Idle() == 0) ;
 RTC_data=I2C_Rd(0);
 while (I2C_Is_Idle() == 0) ;
// asm nop;
 I2c_stop();
 return(RTC_data);
}

//***************************************************************//
//***           read_ds1307_register subroutine               ***//
//***************************************************************//

char read_ds1307_register(char rtcreg)
{
 char rtc_data=0;
 I2C_start();
 I2C_Wr(0xd0);           // Device address
 I2C_Wr(rtcreg);         // Data to device - first we put a pointer to a register from whic will we read later
 I2C_Repeated_Start();   // Restart
 I2C_Wr(0xd1);           // to change data direction
 rtc_data=I2C_Rd(0);     // Now read from slave and send not acknowledge bit for finish of reading
 while (I2C_Is_Idle()==0);
      asm nop;
 i2c_stop();
 return(rtc_data);
}


void Test_RTC(void)
{
char test;


test = ReadRTCRAM(ram_reg8);

if(test != 0x00)    // 0xF5
  {
  RTC_Initial_values();
  WriteRTCRAM(ram_reg8, 0x00);
  Lcd_Custom_Out(2, 17, "**");
  Delay_ms(1000);
  }

Delay_ms(5);

}

/******************************************************************************/
/*                 Fonction d'écriture en RAM horloge                         */
/******************************************************************************/

void WriteRTCRAM(char Address, unsigned char DataToWrite)
{

  Address = Address + 0x08;
  i2c_Start();
  i2c_Wr(0xD0);                    // address DS1307
  while (i2c_Is_Idle() == 0) ;
  i2c_Wr(Address);
  while (i2c_Is_Idle() == 0) ;
  i2c_Wr(DataToWrite);
  while (i2c_Is_Idle() == 0) ;
  i2c_Stop();                      // issue stop signal

}

/******************************************************************************/
/*                 Fonction de lecture en RAM horloge                         */
/******************************************************************************/

char ReadRTCRAM(char Address)
{      // Reading DS1307 RAM - from 0
unsigned char RAMValue;
unsigned char tmp;

  Address = Address + 0x08;         // Address...
  i2c_Start();

  while (i2c_Is_Idle() == 0) ;
  i2c_Wr(0xD0);                     // Address DS1307
  while (i2c_Is_Idle() == 0) ;
  i2c_Wr(Address);                  // Start from RAM address
  while (i2c_Is_Idle() == 0) ;
  i2c_Repeated_Start();
  while (i2c_Is_Idle() == 0) ;
  i2c_Wr(0xD1);                     // Issue a READ command

  while (i2c_Is_Idle() == 0) ;
  tmp =i2c_Rd(0);                   // Read into TEMP
  RAMValue = tmp;                   // Put it into RAMValue
  while (i2c_Is_Idle() == 0) ;
  i2c_Stop();                       // End of comm.
return RAMValue;                    // Send back readed value from RAM
}

Ce code fonctionne, reste à adapter ces fonctions C à vos applis.
merci qui ?

[invitec71dc2a4]

Salut,
s.v.p aide moi
je veux un programme de I2C dans language C avec PCF 8574A qui afficher sur LCD afficheur JJ:MM:AA HH:MM:SS du systeme
et merci Bcp

[invite03481543]

C'est une blague ?

Lisez le code que j'ai posté juste avant et revenez si il y a des choses que vous ne comprenez pas.
Vous avez là tout pour faire votre appli.

[Jack]

Je pense que tu es trop gentil Hulk

A+

[invite9ffaf5d6]

Salut amgab2003,
je suis nouveau sur ce forum.
je voudrais savoir comment tu a programme ton afficheur D48-08040-60.
Je n'est rien trouve sur le net (la plus part des liens ne repondent plus).
A bientot