Signal pwm langage C PIC16F876A

[invite3de9f323]

Salut, j'ai a nouveau un prob, je voudrais faire un signal pwm sur les sorties de mon pic, mais ca ne fonctionne pas, je voudrai faire une tension moyenne variant de 0 à 5V.
Voici le code que j'ai mis.
#include <16F876A.H>
#use delay (clock=20000000)

void main()
{

setup_ccp1(CCP_PWM); // Configure CCP1 en PWM
setup_ccp2(CCP_PWM);
setup_timer_2 (T2_DIV_BY_1, 127, 1);


set_pwm1_duty(25);
set_pwm2_duty(250);


}
C'est tout con, mais ca ne fonctionne pas, quand j'arrive à allumer une led, c'est du tout ou rien, je n'arrive pas à faire varier son intensité.
Si vous avez la solution, j'ai cherché sur le net, mais pas trouvé grand chose de concluant.
Merci.
-----

[invite3de9f323]

Pour la pwm c'est tout bon, je sais pas pourquoi ca ne marchais pas, j'ai fait exactement le meme code que ce que j'ai mis juste au dessus.

Par contre j'ai un soucis pour les lcd, je vais utiliser un PCF8594 je crois, je confirme plus tard, mais en gros, c'est un CAN i2c avec des sortie parralelles, mais je sais pas comment est ce que l'on envoie les données pour que ca affiche quelque chose a l'ecran.
Si vous connaissez un site qui explique bien le transfert de i2c a // en passant par un CAN, je suis prenneur, parce que j'ai chercher mais pas trouvé.
le langage de programmation est en C avec le compilateur ccs.

Merci

[invite3de9f323]

Le CAN c'est un pcf8574AP, voila, si vous pouvez m'aider.

[invite3de9f323]

un petit up

[A voir en vidéo sur Futura]

[invite03481543]

Salut,

désolé mais je ne suis pas très présent cette semaine pour ma part.

Tout d'abord si tu essayes de faire du CAN avec un PCF8574A ça va pas être possible car celui-ci est un 8 I/O I2C.

Donc si j'ai bien compris, tu veux réaliser un interface I2C entre ton µC et ton afficheur LCD, c'est donc bien un PCF8574 qu'il faut prendre.

Voici déjà un code qui permet de gérer en I2C le PCF8574:

/***********************************************************************/
/*  Gestion du PCF8574                     	                       */
/*  i2c-Interface 			              		       */
/*                                                                     */
/*  fichier : pcf8574.c				                       */
/*                		       			               */
/* date de création : 24.05.08                                         */
/* HULK28                                                                    */
/***********************************************************************/

#include "pcf8574.h"

#define PCF8574_TX  0x70    // PCF8574 Adresse en écriture
#define PCF8574_RX  0x71    // PCF8574 Adresse en lecture

/* Fonctions */

/* écrire une donnée dans le PCF8574  */

int I2C_tx_pcf8574(int data,int adr)
{
 int ret;
 I2C_start();
 ret = I2C_send_byte(PCF8574_TX + (adr*2));
 if (ret)
 {
   ret = I2C_send_byte(data);
   if (ret) I2C_stop();
 }  
 return ret;
}

/* lire une donnée dans le PCF8574  */

int I2C_rx_pcf8574(int *data,int adr)
{
 int ret;
 I2C_start();
 ret = I2C_send_byte(PCF8574_RX + (adr*2));
 if (ret)
 {
   *data = I2C_read_byte(0);
 } else *data = 0;
 I2C_stop();
 return ret;
}

Je regarde pour te faire un code pour dialoguer avec un LCD.
@+

[invite3de9f323]

Je te remercie deja pour ce bout de code, par contre, j'ai regardé, mais je ne trouve pas de fichier pcf8574.h j'ai un pcf8570.C mais pas celui que tu inclut.

[invite03481543]

Normal je l'ai écrit spécifiquement.

Bon j'ai bien avancé sur le programme, voici une version qui devrait tourner (en tout cas je n'ai pas d'erreur à la compilation).

Le code suivant permet de gérer un afficheur LCD alphanumérique en I2C avec un PCF8574.
Tu auras juste à remplacer I2C_Start(), I2C_Init(), I2C_Stop(), I2C_Rd() et I2C_Wr() par les fonctions prédéfinies de ton compilateur.
Bien sur il faut initialiser le PIC au niveau des ports, adapter les timmings en fonction du quartz, mais tu as déjà ici 90% du travail fait.

Toutes les fonctions utiles pour gérer le LCD et le PCF8574 sont implantées, il reste à les utiliser dans le main() pour faire afficher quelque chose.
Je te laisse travailler un peu.
Ce code peut servir pour des PIC des familles 16F ou 18F.

Je regarderai pour faire évoluer ce code vers un programme d'application.
Toutes remarques pour ajouter des fonctions (ou optimiser) sont bien sur les bienvenues.
Et si vous l'utilisez n'oubliez pas de citer votre source.

/***********************************************************************/
/*  Gestion d'un LCD en I2C (avec PCF8574) en mode 4-bits                                                */
/*                                                                                                                             */
/*  nom : lcd_pcf8574.c		             	                                                   */
/*                		       				                                      */
/*  date de création : 28/05/08   Compilateur MikroC V8.2                                                  */
/*  HULK28                                                                                                                 */
/***********************************************************************/


#define PCF8574_W   0x70	       // PCF8574 Adresse en écriture
#define PCF8574_R    0x71         // PCF8574 Adresse en lecture

/* renommage pour les adresses du LCD  */
#define LCD_IREG	             0x00		// Instruction Register
#define LCD_DREG	             0x01		// Data Register
#define LCD_BL	             0x08		// Backlight
#define LCD_CURSOR_OFF    0x0C		// Cursor Off
#define	LCD_CURSOR_ON	 0x0E		// Cursor On
#define LCD_CURSOR_BLINK  0x0F		// Cursor Blink
#define LCD_CURSOR_HOME	 0x02		// Cursor Home
#define LCD_CLR	              0x01		// Display Clear
#define LCD_OFF	              0x08		// Display Off
#define	LCD_ADR               0x80		// Adresse

/* LCD Parametres */
#define	LCD_LIN	         2		  // nombre de lignes
#define	LCD_CHR	         16		  // nombre de caractères par ligne

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

/* Variables globales */

int  lcd_B_LIGHT;		// 1 = ON; 0 = Off
int  lcd_ADRESS;		// Adresse RAM
char lcd_STRING[LCD_LIN*(LCD_CHR-1)];	// String

/* prototypes des fonctions */

char init_lcd(void);				// Initialise le LCD en mode 4 bits, 2 lignes
char lcd_instr(char cmd);			// LCD Commande
char lcd_wr_char(char data);		// Ecrit un caractère sur le LCD
char lcd_rd_char(char *data, char adr);	// Lit un caractère sur le LCD à l'adresse "adr"
char lcd_write_str(char *lstr);		// Ecrit une chaîne sur le LCD
char lcd_read_str(char len, char adr);		// Lit une chaine de caractères dans lstr, de l'Adresse adr, d'une longueur len
char lcd_backlight(char cmd);		// 0 -> B.L éteint, 1 B.L allumé
char lcd_get_adress(void);                            // Lit l'Adresse actuelle sur le LCD
char lcd_write_nibble(char regdir, char data);	// regdir LCD_IR | LCD_IR , DatenByte
char lcd_read_nibble(char regdir);		// regdir LCD_IR | LCD_DR , DatenByte
char lcd_busy(void);			// Donne 1 si Busy, 0 si OK

char I2C_W_pcf8574(char data, char adr);      // fonction d'écriture dans le PCF8574
char I2C_R_pcf8574(char *data, char adr);     // fonction de lecture dans le PCF8574


/******************************************************************************/
/*********            Initialisation de l'afficheur en mode 4-BIT , 2 lignes                     *************/
/******************************************************************************/
char init_lcd(void)
{
 char ret;
 ret = I2C_W_pcf8574(8,PCF8574_W); // BL = 1; RS/RW = 0
 Delay_us(15000);
 ret=lcd_write_nibble(LCD_IREG,0x03);
 Delay_us(5000);
 ret=lcd_write_nibble(LCD_IREG,0x03);
 Delay_us(200);
 ret=lcd_write_nibble(LCD_IREG,0x03);
 Delay_us(50);
 ret=lcd_write_nibble(LCD_IREG,0x02);
 ret=lcd_instr(0x28); 	// 4 BIT-Mode , 2 lignes
 ret=lcd_instr(LCD_OFF);	// LCD_Off
 ret=lcd_instr(LCD_CLR);	// LCD_Clear
 ret=lcd_instr(0x02);	// Curseur à l'origine
 ret=lcd_instr(0x06);	// Curseur direction +1
 ret=lcd_instr(0x0E);	// Display ON , Curseur off, No Blinking
 lcd_ADRESS=0; 		// Adresse actuelle = 0
 lcd_B_LIGHT=1;		// B.L = 1
 cursor_adr=0;
 return(ret);
}

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

char I2C_W_pcf8574(char data, char adr)
{
 char ret;
 I2C_Start();
 ret = I2C_Wr(PCF8574_W + (adr*2));
 if (ret)
 {
   ret = I2C_Wr(data);
   if (ret) I2C_stop();
 }
 return(ret);
}

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

char I2C_R_pcf8574(char *data, char adr)
{
 char ret;
 I2C_Start();
 ret = I2C_Wr(PCF8574_R + (adr*2));
 if (ret)
    {
    *data = I2C_Rd(0);
    }
 else *data = 0;
 I2C_Stop();
 return(ret);
}

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

char lcd_write_char(int data)
{
 char ret,temp;
 ret=0;
 if(!lcd_busy())
   {
   temp = data >> 4;
   ret = lcd_write_nibble(LCD_DREG,temp);
   temp = data & 0xf;
   ret = lcd_write_nibble(LCD_DREG,temp);
   }
 return(ret);
}

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

char lcd_read_char(char *data, char adr)
{
 char ret;
 char data_l,data_h;
 ret=1;
 ret=lcd_instr(0x80+adr);		// position de l'adresse
 if(!lcd_busy())
   {
   data_h = lcd_read_nibble(LCD_DREG);
   data_l = lcd_read_nibble(LCD_DREG);
   *data = (data_l >> 4) | data_h;
   }
 return(ret);
}

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

char lcd_write_str(char *lstr)
{
 char ret,n,i;
 ret = 1;
 i = strlen(lstr);
 if (i>LCD_CHR) i = LCD_CHR-1;
 for (n=0;n<i;n++) lcd_write_char(lstr[n]);
 return(ret);
}

/******************************************************************************/
/**********                    Lit une chaîne à l'adresse "adr", de longueur "len"                 ***********/
/******************************************************************************/

char lcd_read_str(char len, char adr)
{
 char ret,n,i,c;
 char ch;
 ret = 1;
 c =0;
 i = adr ; /* lcd_get_adress(); */
 // printf("getadr %d,len %d \n",i,len);
 for (n=i;n<(i+len);n++)
     {
     lcd_read_char(&ch,(i+c));
     lcd_STRING[c] = ch;
     c++;
     lcd_instr(0x80+adr+c);
     }
     lcd_STRING[c] = '\0';
 return(ret);
}

/******************************************************************************/
/*************                    envoi de la commande du backlight                    *****************/
/******************************************************************************/

char lcd_backlight(char bl_cmd) 	  // 0 -> B.L "off", 1-> B.L "on"
{
  char ret;
  lcd_B_LIGHT=bl_cmd; // Variable positionnée
  if (lcd_B_LIGHT)
  ret = I2C_W_pcf8574(LCD_BL,PCF8574_W); //transmission de la Cde B.L au PCF8574
  else
  ret=I2C_W_pcf8574(0,PCF8574_W);
  return(ret);
}


/******************************************************************************/
/***************                    envoi une commande à l'afficheur                 ******************/
/******************************************************************************/

char lcd_instr(char data)
{
 char ret,temp;
 ret = 0;
 if(!lcd_busy())
   {
   temp = data >> 4;
   ret  = lcd_write_nibble(LCD_IREG,temp);
   temp = data & 0xf;
   ret  = lcd_write_nibble(LCD_IREG,temp);
   }
 return(ret);
}

/******************************************************************************/
/***************                 retourne l'adresse actuelle du curseur            *******************/
/******************************************************************************/

char lcd_get_adress(void)
{
 char ret;
 ret = -1;
 if(!lcd_busy())
   {
   ret = cursor_adr;
   }
 return(ret);
}

/******************************************************************************/
/*****************                  envoi un Nibble à l'afficheur                      ******************/
/******************************************************************************/

char lcd_write_nibble(char regdir, char data)
{
  char ret;
  char temp;
 
  temp = data * 16;
  if (lcd_B_LIGHT==1) temp=temp + LCD_BL;
  temp = temp & 0xfe; 		// Enable 0
  if (regdir == LCD_IREG)
  {
   temp = temp & 0xfb;	 	//  P2 à LOW instruction
  } else temp = temp | 0x4; 	//  P2 High, RegisterData
    
  temp = temp & 0xfc;		//  P1 à 0, écriture
  ret=I2C_W_pcf8574(temp,PCF8574_W);
  temp =temp | 0x01;
  ret=I2C_W_pcf8574(temp,PCF8574_W);
  temp =temp & 0xfe;
  ret=I2C_W_pcf8574(temp,PCF8574_W);
 return(ret);
} 

/******************************************************************************/
/*****************                lit un Nibble dans l'afficheur                       *******************/
/******************************************************************************/

char lcd_read_nibble(char regdir)
{
  char temp,ibyte;
  char ret;
  ret   = 0;
  ibyte = 0;
  temp  = 0xf0;
  
  if (lcd_B_LIGHT) temp=temp + LCD_BL;
  temp = temp & 0xfe; 	// Enable = LOW
  if (regdir == LCD_IREG)
     {
     temp = temp & 0xfb;
     }
  else temp = temp | 0x04 ;
  temp = temp | 0x02; 
  ret=I2C_W_pcf8574(temp,PCF8574_W);
  temp=temp | 0x01;
  ret=I2C_W_pcf8574(temp,PCF8574_W);
  ret=I2C_R_pcf8574(&ibyte,PCF8574_R);
  temp=temp & 0xfe;  // Enable de nouveau = LOW
  ret=I2C_W_pcf8574(temp,PCF8574_W);
  ibyte = ibyte & 0xf0;
  return (ibyte);  
}

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

char lcd_busy(void)
{
  int busy, time_cnt, time_out,data_1,data_2;
  time_out=10; 	// 10x Test
  time_cnt=0;   // compteur temps initialisé à 0.
  busy=1;

  do {
     time_cnt++;
     data_1=lcd_read_nibble(LCD_IREG);
     Delay_us(1);
     data_2=lcd_read_nibble(LCD_IREG);
     
     if (data_1 & 0x10)
        {
        busy=1;
        }
     else
        {
        busy =0;
        cursor_adr = data_1 + (data_2 >> 4);
        break;
        }
     }
  while (time_cnt < time_out);
  return(busy);
}


void main(void)
{

  I2C_Init(100000);
  I2C_Start();

  while(1);
}

[invite3de9f323]

Bon, ben j'ai toujours pas reçus mon écran, peu pas encore tester, suis dégouté.
Par contre, j'ai un petit soucis avec la PWM en passant par le PCF8591P.
J'ai deux potars de brancher sur les entrées, la conversion se fait bien et tout, mais en sortie de PWM du PIC, je ne peu pas monter au dessus de 2.5V.
C'est comme si je fonctionnait sous 128bit au lieu de 256.

Si quelqu'un trouve le problème dans mon code.
Je pense que c'est le timer2 qui n'est pas bien configurer, mais j'ai pas très bien compris comment ca fonctionne réellement ce truc.

//****************************** ****************************** ******************
//
// Nom du programme Valise.c
// Date : 26/05/2008
// Objet : Ce petit bout de code permet de generer de la PWM selon la valeur
// des potentiomètres.
// La valeur du potentiomètre n'est lut que quand le BP est appuyé.
//
//
//****************************** ****************************** ******************

#include <16F876A.H>
#use delay (clock=40000000)
#define SRAM_SDA PIN_C4
#define SRAM_SCL PIN_C3
#use i2c(master, sda=SRAM_SDA, scl=SRAM_SCL)


//********************CONSTANTE* ****************************** ******************
#DEFINE BPVALIDE1 input(PIN_C5)
#DEFINE BPVALIDE2 input(PIN_C6)
#DEFINE BPVALIDE3 input(PIN_C7)
#DEFINE BPSORTIE input(PIN_B7)
#DEFINE PCF8591_W 0x90
#DEFINE PCF8591_R 0x91
#DEFINE CANAL_0 0x00
#DEFINE CANAL_1 0x01
#DEFINE LEDMARCHE PIN_C0
#DEFINE OVLED PIN_B5
#DEFINE SCLED PIN_B6

//********************Definition fonction********************** *****************
void Demarrage();
void Initialisation_PWM();
void MenuLCD();
void PetitCourant();
void GrandCourant();
void SondePTC();
void Init_LCD();


//********************Variable globales********************** *******************

byte channel;
long i;
long j;
unsigned char LectPotar1;
unsigned char LectPotar2;


//********************Programme Principale******************** ******************
void main()
{
Init_LCD();
Demarrage();
//Initialisation_PWM();
Initialisation_PWM();
While(TRUE)
{
//On selectionne se que l'on veux faire.
MenuLCD();

if(BPVALIDE1 == 1 && BPVALIDE2 == 0 && BPVALIDE3 == 0)
{
PetitCourant();
}
if(BPVALIDE2 == 1 && BPVALIDE1 == 0 && BPVALIDE3 == 0)
{
GrandCourant();
}
if(BPVALIDE3 == 1 && BPVALIDE2 == 0 && BPVALIDE1 == 0)
{
SondePTC();
}

output_B(32);
}
}


//********************Fonctions* ****************************** ******************
void Initialisation_PWM()
{
//setup_port_a(ALL_ANALOG); //Port A en analogique
//setup_adc(adc_clock_internal); //Port A avec horloge interne
//Configuration de la PWM
setup_ccp1(CCP_PWM); //Configuration de CCP1 en sortie PWM
//setup_ccp2(CCP_PWM); //Configuration de CCP2 en sortie PWM
setup_timer_2(T2_DIV_BY_1, 255, 1); //Mise à jour du Timer sur 255 bits
}

void Init_LCD()
{

//On initialise l'ecran LCD avec le message d'acceuil.
}

void MenuLCD()
{

//On affiche un menu de selction sur l'ecran LCD

}

void Demarrage()
{
for(i=0;i<2;i++)
{
output_high(LEDMARCHE);
output_high(OVLED);
output_high(SCLED);
delay_ms(200);
output_low(LEDMARCHE);
output_low(OVLED);
output_low(SCLED);
delay_ms(200);
output_A(0x00);
output_B(0x00);
output_C(0x00);
}

}

void PetitCourant()
{
while(BPSORTIE == 0)
{
output_B(0b01000000);

//Affiche du nouveaux menu sur l'ecran LCD.
//On effecture une lecture en i2c pour connaitre la valeur du potar
//On affiche la valeur sur l'ecran LCD.

if(BPVALIDE1 == 1)
{
while(BPVALIDE1 == 1){}

i2c_start();
i2c_write(PCF8591_W); //Selection du PCF8591 + mode écriture
i2c_write(CANAL_0); //Selection du canal 0
i2c_start(); //Restart
i2c_write(PCF8591_R); //Passage en mode lecture
LectPotar1 = i2c_read();
i2c_stop();
set_pwm1_duty(LectPotar1);
set_pwm2_duty(0);
}
}
}

void GrandCourant()
{
while(BPSORTIE == 0)
{
output_B(0b01000000);

//Affiche du nouveaux menu sur l'ecran LCD.
//On effecture une lecture en i2c pour connaitre la valeur du potar
//On affiche la valeur sur l'ecran LCD.

if(BPVALIDE2 == 1)
{
while(BPVALIDE2 == 1){}

i2c_start();
i2c_write(PCF8591_W); //Selection du PCF8591 + mode écriture
i2c_write(CANAL_1); //Selection du canal 1
i2c_start(); //Restart
i2c_write(PCF8591_R); //Passage en mode lecture
LectPotar2 = i2c_read();
i2c_stop();
set_pwm2_duty(LectPotar2);
//set_pwm1_duty(0);
}
}
}

void SondePTC()
{
While(BPSORTIE == 0)
{

if(BPVALIDE3 == 1)
{
j++;
if(j>5){j=0;}
while(BPVALIDE3 == 1){}
}

if(BPVALIDE2 == 1)
{
j = j - 1;
if(j<0){j=5;}
while(BPVALIDE2 == 1){}
}

switch (j)
{

case 0utput_B(1);

break;

case 1utput_B(2);

break;

case 2utput_B(4);

break;

case 3utput_B(8);

break;

case 4utput_B(16);

break;

defaultutput_B(96);

break;
}


}
}

Merci

[invite3de9f323]

C'est tout bon, le problème est réglé, je sai psa trop comment j'ai fait, mais bon ca marche.

[invite3de9f323]

Ca y'est j'ai recus l'afficheur.
j'ai commencer a travailler ton code, mais je plante un peu.
Dejà, mon afficheur est un 4X20 et non un 2X16, je ne sais pas si faut juste changer les numeros dans le programme pour que ca puisse fonctionner.

Ensuite, j'ai un gros soucis au niveaux du branchement.
Je ne sais pas comment brancher l'afficheur sur le pcf. il est sur 4 bit, oui, mais pour les entrées REGISTER, ENABLE, et read write, ainsi que le BL, je ne sais pas ou les mettres, sur quel port.

Et enfin, j'ai pas mal d'erreur lors de la compilation, je n'ai pas mikroC mais ccs c, et ils ne prend pas grand chose apparement. J'ai telecharger mikroC mais pas réussis a compiler quoi que ce soit. Galere.

Si tu peu m'aider vite fait.
merci

[invite03481543]

Salut,

/* Affectation des ports du PCF8574

P0 Enable E
P1 R/_W -> 1 Lecture / 0 Ecriture
P2 D/_I -> 1 Data / 0 Instruction
P3 BL -> 1 actif / 0 inactif (backlight)
P4-P7 lignes de données

*/

@+

[invite03481543]

#define LCD_LIN 2 // nombre de lignes
#define LCD_CHR 16 // nombre de caractères par ligne

/* Variables globales */

extern int lcd_B_LIGHT; // 1 = ON; 0 = Off
extern int lcd_ADRESS; // Adresse im RAM
extern char lcd_STRING[LCD_LIN*(LCD_CHR-1)]; // String

Tu remplaces LCD_LIN 2 par LCD_LIN 4 et LCD_CHR 16 par LCD_CHR 20

[invite3de9f323]

Vais encore avoir besoin d'un coup de main.
J'ai tout bien brancher le lcd sur le pcf selon le branchement que tu ma donnée.
A moins que je ne me soit planté sur la ligne de donnée:
j'ai mis : DB4(11) sur P4(9)
et DB7(14) sur P7(12).
Seulement, rien ne se passe.
Ensuite je me suis dit qu'il faut faire les appels dans le main, j'ai donc appeler init_lcd(), mais pareil, il ne se passe rien, l'ecran reste noire 1ere ligne blanche 2eme, idem pour ligne suivante.

[invite3de9f323]

Ah, et apres, je ne sais pas comment faire pour envoyer le texte désiré, puisque quand je met, lcd_write_str(hello); il me dit que hello n'est pas identifier, il doit le voir comme une variable.

[invite3de9f323]

Je galere, j'ai réussis à envoyer des données à l'ecran LCD, mais en passant directement par le pic, et en mode 8 bits., Dès que je passe en 4 bit, ca ne marche plus, et quand je passe par le PCF, ben rien du tout.
Si tu peu m'aider, je ne voit pas comment appeler la routine init_lcd, j'ai mis init_lcd(); dans le main, ca compile et tout, mais quand j'envoie le prog dans le pic, j'ai absolument rien du tout qui se passe.

pour le branchement, j'ai mis DB7 sur le bit de poid fort P7 du pcf. Je pense que c'est bon.
En tout cas, si quelqu'un peu m'aider rapidement.
Merci.

[invite3de9f323]

Ca y'est
avec un peu de perseverence, j'ai réussis a afficher quelque chose.
Mais j'ai toujours un probleme, et un gros.
Donc comme je l'avais dis, l'afficheur est un 4 lignes.
J'ai voulu écrire un mot par ligne, en ayant mis chaque mot dans un tableau different,
Le probleme, est que je ne peu afficher les mots que sur les deux premieres lignes.
Impossible d'afficher les 4 mots en meme temps.
J'ai regardé sur le net pour la commande de saut de ligne, j'ai trouvé, 0xC0, ca me saute bien la premiere ligne, mais appres, quelque soit le nombre de saut de ligne que je fait, je me retrouve toujours au debut de la deuxieme ligne, et non au debut de la troisieme, comme ca devrai l'être.
Si vous avez une idée.

Merci.

[invite3de9f323]

ca y'est j'ai réussis l'affichage sur toutes le lignes.
par contre, j'ai un gros soucis de memoire, pour chaque mot je fait un tableau.

Y'aurai t'il moyen d'envoyer une chaine de caractere sans passé par un tableau qui me prend enormement de place ?

[invite03481543]

Salut,

désolé mais je suis assez peu présent sur le forum cette semaine, trop de travail par ailleurs...

Pour tes textes il faut les placer en flash et non pas en Ram:

const char *text = "mon texte ici";

Il te faut également une fonction qui passe en Ram les textes en flash:

void StrConstCpy(char row, char col, const char *source)

{
char *dest;
char buf[21]; // buffer contient la taille maximum du texte source +1

dest = buf;
while(*source)
*dest++=*source++;
*dest=0;
lcd8_Out(row,col,buf);  // on appelle la fonction d'écriture sur le LCD
}                       // row-> n° de ligne, col-> n° de colonne, buf-> contenu

il faudra adapter avec ton compilateur, lcd8_Out est propre à MikroC, tu dois avoir une fonction similaire sur le tiens.

Pour le PCF8574, ça fonctionne bien avec le code que je t'ai donné, il faut vérifier au scope si les ordres envoyés sont biens transmis sur les bits de commandes (E,RS,R/W) et voir si tu as des signaux en D4....D7

De toute façon si c'est ton premier prog avec un afficheur, il vaut mieux te faire la main en le pilotant directement sur un port du micro, ensuite quand tout fonctionnera bien tu pourras revenir au PCF8574, qui demande plus d'attention.
Je ne connais pas ton compilateur, le mieux serait que tu postes le programme que tu tentes de faire fonctionner, il y a surement quelques détails qui ne vont pas.
@+

[invite03481543]

Tu peux faire quelque chose comme ça aussi:

void Message_Lcd(const char* texte) // écriture d'une chaine de caractère
{
char cnt=0;
while (texte[cnt] != 0 )
Wr_Lcd(texte[cnt++],1);
}

[invite3de9f323]

C'est tout bon, j'ai réussis a faire afficher ce que je voulais en utilisant lcd_wr_char("text"); et me suis fait un petit truc pour choisir ma ligne ou je veu ecrire.

Tout fonctionne presque comme je veux.
Mis à part le fait qu'avec le reste de mon prog, ben y'a plus du tout de place.

Je regarde pour passé sur un 18F252, apparement compatible pin par pin.
Mais avec plus de memoire.
Par contre, j'ai du mal a trouver un bootloader pour ce type de pic, dans tous les cas, je mettrait à dispo de tous, le schema et le code du programme pour piloter ce genre d'ecran.
Tellement galerer, que je pense que d'autre sont dans le meme cas.

En tout cas, merci à toi Hulk, ton code ma été d'un grand secour.
Si tu trouve un bootloader pour le 18F252, je serai prenneur.

[invite3de9f323]

J'ai encore une question.
J'ai un potentiomètre qui passe par un CAN pcf8591 pour me retourner la valeur sur 256 bits, afin de sortir un signal PWM en conséquence.

Ce que je voudrai, c'est afficher sur l'écran, la valeur non pas sur 256 bits, mais de 0à10 dans un cas, 0 à 20 dans l'autre et 0 à 5 dans le dernier cas.
C'est a dire que pour 0 au potar, j'aurai 0 d'afficher et pour 255 j'aurai 10, donc aussi pour 128 je devrai avoir 5.

Je voudrai donc afficher les valeurs sur l'écran LCD, mais je ne voit pas comment, pour passer de 0 - 255 a 0 - 10, je fait, (variable*10)/255
normalement ça devrai me donner le bon truc, mais après, pour l'envoyer sur le LCD, si je met lcr_wrt_char("(variable*10)/255"); il me marque le calcul mais ne me le fait pas.
et si je met lcr_wrt_char((variable*10)/255); il me met le caractère correspondant, mais pas la valeur souhaité.
Comment est ce que je pourrait faire ?

[invite03481543]

Bonsoir,

il faut formater le résultat selon ce que tu veux afficher.

1/ tu récupères la donnée de mesure du PCF8591 sur 8 bits -> variable res_1.
2/ tu formates ce résultat selon ce que tu souhaites afficher -> variable val_aff.
3/ tu envoies en argument la variable val_aff à afficher dans ta fonction d'écriture sur le LCD.

sur 8 bits le quantum pour 5 est de q=5/256=0,01953125

Il faut donc écrire pour éviter le float: res=res_1*100000000*q

avec comme déclaration de variable:

long int val;

Tu peux te contenter d'un int au prix d'une précision plus faible en écrivant:

res=res_1*10000*q

L'idéal aurait été d'avoir une fonction sprintf du style:

sprintf(text,"%d",i);

Comme tu n'en as pas sur ton compilateur, il faut faire autrement:

aff_res = (t / 10000) % 10; // On extrait la partie entière
LCD_Chr_CP(48+aff_res); // 48 permet d'afficher directement en ASCII
...........
...........
aff_res = res % 10; // la dernière décimale
LCD_Chr_CP(48+aff_res);

il ne reste plus qu'à placer ta virgule.

Maintenant selon ton compilateur, il faut adapter tout ça, mais le principe est là.
@+

[invite3de9f323]

Bon ben j'ai de nouveaux un problème, mais cette fois, ca ne concerne plus l'écran.
Pour l'écran, c'est tout bon, j'affiche tout ce dont j'ai besoin, mais le ca reprend un peu le sujet du titre, car ca concerne ma PWM.
Donc voilà, je génére de la PWM, pour ensuite passé par un AOP, afin de me convertir le signal en 0-10V.
J'utilise le schema suivant :http://www.sonelec-musique.com/image...ension_001.gif
qui fonctionne bien.
Mais le probleme c'est ma sortie PWM qui ne me sort que 4 valeurs de tension. ce qui n'est pas top, pour de la PWM.
Voici les valeurs

valeur LCD || Valeur multi || Valeur PWM

0.00 ||| 0.00 ||| 0
1.05 ||| 1.43 ||| 0.64
1.60 ||| 1.44 ||| 0.64
2.07 ||| 1.44 ||| 0.64
2.85 ||| 7.10 ||| 3.13
3.24 ||| 7.10 ||| 3.13
4.41 ||| 7.10 ||| 3.13
5.89 ||| 9.94 ||| 4.38
6.67 ||| 9.94 ||| 4.38
10 ||| 9.94 ||| 4.38

C'est vraiment pas top comme réglage. d'où peu bien provenir le problème ?

pour initialiser la PWM je fait

char Initialisation_PWM(void)
{
//Configuration de la PWM
setup_ccp1(CCP_PWM); //Configuration de CCP1 en sortie PWM
setup_ccp2(CCP_PWM); //Configuration de CCP2 en sortie PWM
setup_timer_2(T2_DIV_BY_1, 255, 1); //Mise à jour du Timer sur 255 bits
}

et ensuite pour sortir ma PWM, je lis la valeur de mon potar, que je met sur la sortie PWM de cette facon

set_pwm1_duty(LectPotar); //On génére la PWM
set_pwm2_duty(0); //On évite d'avoir deux sorties PWM

Si vous pouvez m'aider.

[invite3de9f323]

Bon j'ai paré au problème plus simplement, j'ai supprimé la PWM, j'utilise directement le point milieu du potar, comme ca pas de soucis, et pour les tension, elles correspondent a 2mV près entre mon LCD et le multimettre, donc je pense être pas trop mal.

[invite3de9f323]

Bon ben voila, j'ai un problème au niveau des correspondances entre la valeur afficher sur mon ecran, et ma mesure au multimetre pour le courant en sortie.
suppression du lien vers le serveur externe.
La courbe en bleu, c'est ma sortie sur mon ecran LCD, et en rouge, c'est ce que je mesure au multimètre.
je voulais savoir si vous saviez comment faire pour faire une correction de sorte à ce que ma courbe bleu colle avec la rouge, sans que la rouge ne soit touché, puisqu'on na pas de controle dessus, voila le code qui m'affiche la valeur à l'écran.

char PetitCourant(void)
{
delay_ms(1000); //Evite les rebonds des boutons
output_BIT(PIN_A0, 1); //Valide le bon circuit
while(BP4 == 0)
{

LecturePot(0); //Lecture des potentiomètres
clear_line(L3);
lcd_instr(L3+1);
complet = ((LectPotar*20)/255);
a = (int) complet;
b = a/10;
lcd_write_char(0x30+b);
a = complet - (b*10);
lcd_write_char(0x30+a);

lcd_write_char(".");


decimal = complet - (int)complet;


for(i=0;i<1;i++){
decimal *=10;
c = (int)(decimal);
lcd_write_char(0x30+c);
decimal = decimal - (int)decimal;
}
lcd_write_char(" mA");


}
}

Si vous pouvez m'aider.
Merci

Merci de prendre l'habitude de déposer les fichiers sur le serveur de FS.

[grd666]

Salut Tyller et Hulk,
Tyller ton programme pour gérer l'afficheur lcd en i2c tu l'utilise sur mplab c'est bien ça?
Hulk ton programme d'affichage pc8574 en ic2 vers un afficheur correspond exactement a une partie que je dois faire mais je comprend quasiment rien a ton programme visiblement tu utilise pas mplab ces 2 fonctions n'éxiste pas sur mplab
Delay_us(15000);
ret=lcd_write_nibble(LCD_IREG, 0x03);
Bref Tyller sa serait possible tu poste ton programme pour l'afficheur sa m'aiderais a comprendre peu être mieux
Merci

[invite3de9f323]

salut grd666, en effet je n'utilise pas MPLAB, et hulk lui utilise MikroC, moi j'ai ccs c.
pour mon code, j'ai fait pas mal de modif pour que ca fonctionne bien avec ce que je veux.
en tout si tu a un pcf8574 comme moi, ben ca devrai bien fonctionner, lol.

/****************************** ****************************** ***********/
/* */
/* Gestion d'un LCD en I2C (avec PCF8574) en mode 4-bits */
/* */
/****************************** ****************************** ***********/




/****************************** ****************************** ******************/
/********* Initialisation de l'afficheur en mode 4-BIT , 2 lignes **********/
/****************************** ****************************** ******************/
char init_lcd(void)
{
I2C_W_pcf8574(0x08); // BL = 1; RS/RW = 0
Delay_us(15000);
lcd_write_nibble(LCD_IREG,0x03 );
Delay_us(5000);
lcd_write_nibble(LCD_IREG,0x03 );
Delay_us(200);
lcd_write_nibble(LCD_IREG,0x03 );
Delay_us(50);
lcd_write_nibble(LCD_IREG,0x02 );
lcd_instr(LCD_MODE); // 4 BIT-Mode , 2 lignes
delay_us(40);
lcd_instr(LCD_OFF); // LCD_Off
delay_us(40);
lcd_instr(LCD_CLR); // LCD_Clear
delay_us(1640);
lcd_instr(LCD_CURSOR_HOME); // Curseur à l'origine
delay_us(1640);
lcd_instr(LCD_CURSOR_DIR); // Curseur direction +1
delay_us(40);
lcd_instr(LCD_CURSOR_ON); // Display ON , Curseur off
delay_us(40);
lcd_B_LIGHT = 1; //BackLight Allumé
}



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

char I2C_W_pcf8574(char data)
{
i2c_start();
I2C_Write(PCF8574_W);
I2C_Write(data);
I2C_stop();
}


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

char lcd_write_char(int data)
{
char temp;
temp = data >> 4;
lcd_write_nibble(LCD_DREG,temp );
temp = data & 0xf;
lcd_write_nibble(LCD_DREG,temp );
}


/****************************** ****************************** ******************/
/************* envoi de la commande du backlight ****************/
/****************************** ****************************** ******************/

char lcd_backlight(char bl_cmd) // 0 -> B.L "off", 1-> B.L "on"
{
lcd_B_LIGHT = bl_cmd; // Variable positionnée
if (lcd_B_LIGHT)
I2C_W_pcf8574(LCD_BL); //transmission de la Cde B.L au PCF8574
else
I2C_W_pcf8574(0);
}


/****************************** ****************************** ******************/
/*************** envoi une commande à l'afficheur ****************/
/****************************** ****************************** ******************/

char lcd_instr(char data)
{
char temp;
temp = data >> 4;
lcd_write_nibble(LCD_IREG,temp );
temp = data & 0xf;
lcd_write_nibble(LCD_IREG,temp );
}

/****************************** ****************************** ******************/
/***************** envoi un Nibble à l'afficheur ******************/
/****************************** ****************************** ******************/

char lcd_write_nibble(char regdir, char data)
{
char temp;

temp = data * 16;
if (lcd_B_LIGHT==1) temp=temp + LCD_BL;
temp = temp & 0xfe; // Enable 0
if (regdir == LCD_IREG)
{
temp = temp & 0xfb; // P2 à LOW instruction
} else temp = temp | 0x4; // P2 High, RegisterData

temp = temp & 0xfc; // P1 à 0, écriture
I2C_W_pcf8574(temp);
temp =temp | 0x01;
I2C_W_pcf8574(temp);
temp =temp & 0xfe;
I2C_W_pcf8574(temp);
}

/****************************** ****************************** ******************/
/***************** Efface une ligne ******************/
/****************************** ****************************** ******************/


char clear_line(char ligne)
{
char cL;
lcd_instr(ligne);
for(cL=0;cL<=15;cL++){lcd_writ e_char(" ");}
}


/****************************** ****************************** ******************/
/***************** MENUS du LCD ***************/
/****************************** ****************************** ******************/

char MenuLCD(void)
{

lcd_instr(LCD_CLR);
lcd_instr(L1+2);
lcd_write_char("CHOISISSEZ SORTIE");

lcd_instr(L2+1);
lcd_write_char("COURANT/TENSION BP1");

/*lcd_instr(L3+5);
lcd_write_char("Temp");
lcd_write_char(0xDF);
lcd_write_char(" carte BP2");
*/

lcd_instr(L4+1);
lcd_write_char("SIMUL SONDE PTC BP3");

}

voila, c'est plein de fonction
donc les trucs d'appel de fonction

/****************************** ****************************** ******************/
/* Définition des propriétés du PIC */
/****************************** ****************************** ******************/
#include <16F876A.H> //On Inclut le PIC de la carte mère
#use delay (clock=20000000) //Quartz à 20MHz
#include <math.h>
#define SRAM_SDA PIN_C4 //Pin SDA pour l'I2C
#define SRAM_SCL PIN_C3 //Pin SCL pour l'I2C
#use i2c(master, sda=SRAM_SDA, scl=SRAM_SCL) //Définition du PIC en maître



/****************************** ****************************** ******************/
/* Définition des constantes */
/****************************** ****************************** ******************/
#DEFINE BP1 input(PIN_C5) //Bouton de séléction BP1
#DEFINE BP2 input(PIN_C6) //Bouton de séléction BP2
#DEFINE BP3 input(PIN_C7) //Bouton de séléction BP3
#DEFINE BP4 input(PIN_B7) //Bouton de retour au menu
#DEFINE PCF8591_W 0x90 //Adresse du PCF8591 en écriture
#DEFINE PCF8591_R 0x91 //Adresse du PCF8591 en lecture
#define PCF8574_W 0x72 // PCF8574 Adresse en écriture
#define PCF8574_R 0x73 // PCF8574 Adresse en lecture
#DEFINE CANAL_0 0x00 //Canal du Potar 0
#DEFINE CANAL_1 0x01 //Canal du potar 1
#DEFINE OKLED PIN_C0 //Led de fonctionnement programme

/* renommage pour les adresses du LCD */
#define LCD_IREG 0x00 // Instruction Register
#define LCD_DREG 0x01 // Data Register
#DEFINE LCD_MODE 0x28 // Mode 4 bits, 2 lignes
#define LCD_BL 0x08 // Backlight
#define LCD_CURSOR_OFF 0x0C // Cursor Off
#define LCD_CURSOR_ON 0x0E // Cursor On
#define LCD_CURSOR_BLINK 0x0F // Cursor Blink
#define LCD_CURSOR_HOME 0x02 // Cursor Home
#define LCD_CLR 0x01 // Display Clear
#define LCD_OFF 0x08 // Display Off
#DEFINE LCD_CURSOR_DIR 0x06 // Cursor direction +1
#DEFINE L1 0x80 // Adresse ligne 1 du LCD
#DEFINE L2 0xC0 // Adresse ligne 2 du LCD
#DEFINE L3 0x94 // Adresse ligne 3 du LCD
#DEFINE L4 0xD4 // Adresse ligne 4 du LCD


/****************************** ****************************** ******************/
/* Definition fonction */
/****************************** ****************************** ******************/

/* Fonctions globales */
char MenuLCD(void); //Affiche le menu sur le LCD
char RAZ(void); //Remet à 0 toutes les sorties
char Selection(void); //Sous-menu COURANT/TENSION
char init_lcd(void); //LCD en mode 4 bits, 2 lignes
char lcd_instr(char cmd); //Instruction de commande LCD
char lcd_wr_char(char data); //Ecrit un caractère sur le LCD
char lcd_backlight(char cmd); // 0 -> B.L éteint, 1 B.L allumé
char lcd_write_nibble(char regdir, char data); //Passe les données en 4bits
char I2C_W_pcf8574(char data); // fonction d'écriture dans le PCF8574
char Init(void); //Initialisation de départ
char clear_line(char ligne); //Efface une ligne complète
char lcd_write_var(float valeur, int type);


/* Fonctions de génération */
char PetitCourant(void); //Génére PWM pour courant 0-20mA
char GrandCourant(void); //Génére PWM pour courant 0-5A
char Tension(void); //Génére PWM pour courant 0-10V
char SondePTC(void); //Commute résistance pour sonde PTC
char LecturePot(int1 NumPot); //Permet de lire les potentiomètres

/* Fonctions de réglage */
char ReglageT(void); //Réglage de la tension
char ReglagePTC(void); //Sélection résistance
char ReglagePC(void); //Réglage 0-20mA
char ReglageGC(void); //Réglage 0-5A

/* Fonction traduction pour LCD */
char ConvPTC(char valeur);

/****************************** ****************************** ******************/
/* Variables global */
/****************************** ****************************** ******************/

int1 channel; //0-1 suivant le potentiomètre
int16 Decale = 1; //Bit des relais
float LectPotar; //Valeur des potentiomètres
int k; //variable des menus
int j; //N'affiche le menu qu'une fois
int a;
int b;
int c;
float decimal;
float complet;
int i;
//Evite le scintillement de l'écran
byte lcd_B_LIGHT; //Allume ou non le BackLight

de toute facon, je remettrait le code sur mon site, pour justement, ceux qui comme moi on galerer a faire fonctionner un LCD.

Si ca ca t'aide déjà.

[invite03481543]

Bonjour,

tyller je pense que les écarts que tu relèves sont essentiellement liés à un hardware incorrect tel que par exemple de ne pas avoir utilisé un suiveur en entrée de mesure (pour avoir une impédance d'entrée élevée coté entrée de la mesure, et une impédance faible coté entrée du A/D), peut-être également quelques filtrages qui manquent, et enfin il faudrait voir ce que tu as fais coté +Vref/-Vref.
Donc si tu pouvais poster un schéma complet.
@+

[invite3de9f323]

La je ne suis pas chez moi, j'ai pas mon schéma, je doit récup mon disque dur cet aprèm, donc je ne pourrait poster mes schémas que ce soir tard.
Mais en gros, j'ai un potar qui est braché au VCC et au GND, et le point mileux est branché sur une des entrées du CAN(pcf8591), ainsi que sur l'entrée plus de l'aop, qui lui est branché en suiveur. Donc, le point mileu du potar est branché sur une entrée du PCF, et sur le plus de l'aop, le moins reboucle sur la sortie.
De la sortie à la masse, j'ai une resistance de 200Ohm, après la résistance, j'ai un bc546 de branché, donc à la base j'ai une résistance de 4.7K, l'émetteur à la résistancede 200 Ohm et le collecteur, ben c'est la ou je met la charge.
Toute la partie PIC et PCF est alimenté en 0 - 5V, l'AOP lui est en 0 - 15V, et le transistor est lui aussi en 0 - 15V.

Si t'arrive à voir a peu près le montage comme ca.
Mais je le reposterai ce soir.

[invite03481543]

De la sortie à la masse, j'ai une resistance de 200Ohm, après la résistance, j'ai un bc546 de branché, donc à la base j'ai une résistance de 4.7K, l'émetteur à la résistancede 200 Ohm et le collecteur, ben c'est la ou je met la charge.

*********************