Problème avec caractère

Bonjour,

Je me suis lancer dans l'exploitation d'un écran LCD pour afficher des infos.
L'écran LCD provient d'un Nokia 5110. Aucun soucis pour l'affichage d'un texte simple.

Mais maintenant, j'ai connecté un capteur de température LM35 à l'arduino, j'arrive à retourner la valeur reçu sur le moniteur série sans soucis en float et en int.
Mais je n'arrive pas à l'afficher sur l'écran LCD.

Le float ne marche évidemment pas mais le int marche pour d'autre valeur.

Par exemple :

int Altitude = "ALT.: 1285 M";
LCDString(Altitude);

marche très bien.

mais :

float Temperature = (analogRead(A0) * 0.48828125); //Conversion de la tension en °C
int Temperature2 = Temperature;

LCDString(Temperature2);

ne marche pas... pourquoi ? cette manière ne convient pas pour convertir du float en int ?

Je ne suis pas encore bien à l'aise avec les types de "chaine" à utiliser.

Merci de votre aide.

Malo

bonjour,
si tu mettais le code entier, ca serait bien

Bonjour,

//Câblage de l'écran sur la carte Arduino (résistance en série)
#define PIN_SCE   7 //Pin 3 on LCD Chip Select (1 k)
#define PIN_RESET 6 //Pin 4 on LCD reset, active low (10 k)
#define PIN_DC    5 //Pin 5 on LCD data/commande (10 k)
#define PIN_SDIN  4 //Pin 6 on LCD SPI Mosi (10 k)
#define PIN_SCLK  3 //Pin 7 on LCD SPI clk (10 k)

//La pin DC indique au LCD si on envoie une donnée ou une commande
#define LCD_COMMAND 0
#define LCD_DATA  1

//Notre écran fait 84 x 48 pixels (à modifier ici pour d'autres LCD)
#define LCD_X     84
#define LCD_Y     48

long temps = 0;  //Pour chronométrer la vitesse de l'affichage
int Heure;

//Ce tableau comporte les caractères Ascii codés en octets
//Cette police de caractères fait 5 pixels (haut) x 8 (large)
static const byte ASCII[][5] = {
  {0x00, 0x00, 0x00, 0x00, 0x00} // 20
  , {0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
  , {0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
  , {0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
  , {0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
  , {0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
  , {0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
  , {0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
  , {0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
  , {0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
  , {0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
  , {0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
  , {0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
  , {0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
  , {0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
  , {0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
  , {0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
  , {0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
  , {0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
  , {0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
  , {0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
  , {0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
  , {0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
  , {0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
  , {0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
  , {0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
  , {0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
  , {0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
  , {0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
  , {0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
  , {0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
  , {0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
  , {0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
  , {0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
  , {0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
  , {0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
  , {0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
  , {0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
  , {0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
  , {0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
  , {0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
  , {0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
  , {0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
  , {0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
  , {0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
  , {0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
  , {0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
  , {0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
  , {0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
  , {0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
  , {0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
  , {0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
  , {0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
  , {0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
  , {0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
  , {0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
  , {0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
  , {0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
  , {0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
  , {0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
  , {0x02, 0x04, 0x08, 0x10, 0x20} // 5c antislash (bug ici dans le prg. d'origine; corrigé)
  , {0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
  , {0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
  , {0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
  , {0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
  , {0x7f, 0x41, 0x5d, 0x55, 0x55} // 5b Bat1 vide - a
  , {0x7f, 0x41, 0x5d, 0x5d, 0x5d} // 5b Bat1 plein - b
  , {0x55, 0x55, 0x55, 0x55, 0x55} // 5d Bat2 vide/vide - c
  , {0x5d, 0x5d, 0x55, 0x55, 0x55} // 5d Bat2 plein/vide - d
  , {0x5d, 0x5d, 0x5d, 0x5d, 0x5d} // 5d Bat2 plein/plein - e
  , {0x5d, 0x41, 0x7f, 0x22, 0x3E} // 5d Bat4 fixe - f
  , {0x00, 0x06, 0x09, 0x09, 0x06} // 5d degrés °
  // , {0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
  // , {0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
  // , {0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
  // , {0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
  // , {0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
  // , {0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
  // , {0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
  , {0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
  , {0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
  , {0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
  , {0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
  , {0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
  , {0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
  , {0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
  , {0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
  , {0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
  , {0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
  , {0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
  , {0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
  , {0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
  , {0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
  , {0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
  , {0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
  , {0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
  , {0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
  , {0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
  , {0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
  , {0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
  , {0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
  , {0x10, 0x08, 0x08, 0x10, 0x08} // 7e ~
  , {0x78, 0x46, 0x41, 0x46, 0x78} // 7f DEL

};

// Il y a deux banques de mémoire sur le LCD, data/RAM ou commandes
// Cette fonction met la Pin DC high ou low selon les cas, et envoie les octets de data
void LCDWrite(byte data_or_command, byte data) {
  //Indiquer au LCD si on lui écrit soit des données soit une commande
  digitalWrite(PIN_DC, data_or_command);

  //Envoi des data
  digitalWrite(PIN_SCE, LOW);
  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
  digitalWrite(PIN_SCE, HIGH);
}

// Fonction gotoXY
void gotoXY(int x, int y) {
  LCDWrite(0, 0x80 | x);  // Column.
  LCDWrite(0, 0x40 | y);  // Row.  ?
}

// Fonction LCDCharacter
// Elle prend un caractère, le cherche dans la tableau de fonte, l'écrit sur l'écran.
// Un caractère fait 8 bits haut x 5 bits de large, espacés de une colonne vide par côté
void LCDCharacter(char character) {
  LCDWrite(LCD_DATA, 0x00); //Colonne verticale vide gauche de séparation des lettres

  for (int index = 0 ; index < 5 ; index++)
    LCDWrite(LCD_DATA, ASCII[character - 0x20][index]);
  //0x20 est le code ASCII pour espace (' ').
  //La table de police de caractères débute par ce caratère

  LCDWrite(LCD_DATA, 0x00); //Colonne verticale vide droite de séparation des lettres
}

// Affiche une par une des lettres d'une chaine de caractères sur le LCD
void LCDString(char *characters) {
  while (*characters)
    LCDCharacter(*characters++);
}

//Efface le LCD en écrivant des zéros partout
void LCDClear(void) {
  for (int index = 0 ; index < (LCD_X * LCD_Y / 8) ; index++)
    LCDWrite(LCD_DATA, 0x00);

  gotoXY(0, 0); //Puis revenir en haut
}

//Envoi des commandes sur le PCD8544
void LCDInit(void) {

  //Configure les Pins de controle
  pinMode(PIN_SCE, OUTPUT);
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC, OUTPUT);
  pinMode(PIN_SDIN, OUTPUT);
  pinMode(PIN_SCLK, OUTPUT);

  //Reset the LCD à un état connu
  digitalWrite(PIN_RESET, LOW);
  digitalWrite(PIN_RESET, HIGH);

  LCDWrite(LCD_COMMAND, 0x21); //Tell LCD that extended commands follow
  LCDWrite(LCD_COMMAND, 0xBf); //Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
  LCDWrite(LCD_COMMAND, 0x04); //Set Temp coefficent
  LCDWrite(LCD_COMMAND, 0x14); //LCD bias mode 1:48: Try 0x13 or 0x14

  LCDWrite(LCD_COMMAND, 0x20); //We must send 0x20 before modifying the display control mode
  LCDWrite(LCD_COMMAND, 0x0C); //Set display control, normal mode. 0x0D for inverse
}

void setup(void) {
  LCDInit(); //Initialisation du LCD

  Serial.begin(9600);
}

void loop(void) {

  float Temperature = (analogRead(A0) * 0.48828125); //Conversion de la tension en °C
  int Temperature2 = Temperature;

  Serial.print(Temperature);
  
  int Altitude = "ALT.: 1285 M";
  //  int TemperatureTxt = "TEMP.:  " + Temperature + "gC";
  int Direction = "->N-0   355g";
  int Vitesse = "VIT.: 12KM/H";
  int Longitude = "45g11'55.54N";
  int Latitude = "02g12'56.97E";

  LCDClear();  //une ligne de 12 caractères
  LCDString("18:35    acf" );
  LCDString(Altitude);  //6 lignes par écran
  LCDString("TEMP.: ");
  LCDString(Temperature2);
  LCDString("   gC");
  LCDString(Vitesse);   //message de texte
  LCDString(Longitude);
  LCDString(Latitude);
  delay(1000);


}

Malokoxis:
Par exemple :

int Altitude = "ALT.: 1285 M";
LCDString(Altitude);

marche très bien.

Bonjour,

??????? Ça m'étonne fortement.

pourquoi ?

tu veux une photo de l'écran comme preuve ? :wink:

Parce que la conversion d'un char * en int donne une erreur à la compilation.

Aucune erreur à la compilation et l'affichage de ce texte marche bien.
Mais comment faire pour ma variable qui vient du LM35 ?

Merci

Essaie ça:

  char strtemp[10];
  dtostrf(Temperature,2,1,strtemp);
  LCDString(strtemp);

Ca m'étonne que la conversion char * -> int ne génère pas d'erreur de compilation (ou alors il faut dévalider la génération de toutes les erreurs de conversion dans le compilateur).

sérieusement, vous compilez comment votre code?

int Altitude = "ALT.: 1285 M";
int Direction = "->N-0   355g";
int Vitesse = "VIT.: 12KM/H";
int Longitude = "45g11'55.54N";
int Latitude = "02g12'56.97E";

void setup() {}
void loop() {}

n'a vraiment aucune chance d'être accepté par le compilateur parce que des chaines de caractères ce ne sont pas des entiers...

d'ailleurs quand j'essaye de compiler ce qu'il y a ci dessus j'obtiens pour chaque ligne

warning: invalid conversion from 'const char*' to 'int' [-fpermissive]

déjà, tu ne dis pas sur quelle ligne/colonne afficher le texte

gotoXY(x, y);

je viens de compiler ton code et les erreurs apparaissent comme l'indique kamill

Arduino : 1.6.7 (Linux), Carte : "Arduino/Genuino Uno"

/tmp/arduino_8596b823b2456519e3b4d88814c1c4ea/sketch_oct02a.ino: In function 'void loop()':
sketch_oct02a:210: error: invalid conversion from 'const char*' to 'int' [-fpermissive]
int Altitude = "ALT.: 1285 M";
^
sketch_oct02a:212: error: invalid conversion from 'const char*' to 'int' [-fpermissive]
int Direction = "->N-0 355g";
^
sketch_oct02a:213: error: invalid conversion from 'const char*' to 'int' [-fpermissive]
int Vitesse = "VIT.: 12KM/H";
^
sketch_oct02a:214: error: invalid conversion from 'const char*' to 'int' [-fpermissive]
int Longitude = "45g11'55.54N";
^
sketch_oct02a:215: error: invalid conversion from 'const char*' to 'int' [-fpermissive]
int Latitude = "02g12'56.97E";
^
sketch_oct02a:219: error: invalid conversion from 'int' to 'char*' [-fpermissive]
LCDString(Altitude); //6 lignes par écran
^
sketch_oct02a:161: error: initializing argument 1 of 'void LCDString(char*)' [-fpermissive]
void LCDString(char characters) {
^
sketch_oct02a:221: error: invalid conversion from 'int' to 'char
' [-fpermissive]
LCDString(Temperature2);
^
sketch_oct02a:161: error: initializing argument 1 of 'void LCDString(char*)' [-fpermissive]
void LCDString(char characters) {
^
sketch_oct02a:223: error: invalid conversion from 'int' to 'char
' [-fpermissive]
LCDString(Vitesse); //message de texte
^
sketch_oct02a:161: error: initializing argument 1 of 'void LCDString(char*)' [-fpermissive]
void LCDString(char characters) {
^
sketch_oct02a:224: error: invalid conversion from 'int' to 'char
' [-fpermissive]
LCDString(Longitude);
^
sketch_oct02a:161: error: initializing argument 1 of 'void LCDString(char*)' [-fpermissive]
void LCDString(char characters) {
^
sketch_oct02a:225: error: invalid conversion from 'int' to 'char
' [-fpermissive]
LCDString(Latitude);
^
sketch_oct02a:161: error: initializing argument 1 of 'void LCDString(char*)' [-fpermissive]
void LCDString(char characters) {
^
exit status 1
invalid conversion from 'const char
' to 'int' [-fpermissive]

Ce rapport contiendrait plus d'informations si l'option
"Montrer les informations de sortie pendant la compilation"
était activée dans Fichier > Préférences.

merci kamill pour ta réponse à propos de la conversion, ça marche très bien.
Pour les autres, merci de vos réponses. Bizarre que ça marche chez moi. Je vais essayer de résoudre le problème.

Bon je suis reparti un peu à zéro puisque ces ligne servait seulement à m’entrainer avec l’écran LCD.

Le dtostrf de kamill à résolu mon problème pour la température.

J’ai essayé de revoir ma méthode d’affichage. Celle utilisé précédemment ne me convient pas forcément car toutes les lignes auront la même taille et l’affichage d’icône est compliqué.
Je souhaite donc utiliser la librairie de l’écran : PCD8544

Mais j’ai l’impression qu’elle n’est pas très complète.
Par exemple j’arrive à écrire du texte en taille normal (5*8 pixels) mais j’aimerais pourvoir afficher une valeur en gros caractère au milieu de l’écran, et je ne trouve pas comment faire.

J’ai pourtant vu un projet qui le faisait mais avec la librairie Adafruit_PDC8544.
Le problème est que je n’arrive pas à inclure cette librairie dans mon sketch.

Lorsque j’inclue celle-ci dans mon sketch :

#include <Adafruit_PCD8544.h>

J’ai l’erreur suivante qui apparait :

Erreur de compilation pour la carte Arduino/Genuino Uno

J’utilise une carte Arduino Uno et l’IDE 1.6.12.

Quelqu’un aurait une idée d’où peut venir le problème ?
ou comment travailler avec la librairie PCD8544 et non pas Adafruit_PCD8544 ?

Merci

Malo

Bon j'ai résolue mon problème, visiblement l'ordre des procédures est important dans le code, mais je n'ai pas encore compris l'ordre de priorité