j'aurais besoin d'aide pour un exercice qui provient de mon tuteur (je suis en stage).
mon objectif est d'afficher sur l'écran lcd le code que l'on tape sur le pc. la ligne du haut du lcd est pour régler la ligne de transmission et la ligne du bas le code que l'on tape.
voici mon matos :
5 condensateurs polarisés de 1 uF, les 3 boutons poussoirs, mon MAX232 l'écran lcd et l'arduino uno et le pc. j'ai aussi une Arduino Pro Mini qui remplacera la arduino uno à la fin.
mes boutons poussoirs me servent à régler la parité, la vitesse et le 3éme le nombre de bits stop. mon tuteur m'a dis de commencer par choisir un boitier qui contiendra le tout à la fin soit les composants, l'écran, les boutons poussoirs, une prise femelle DB9 et l'alim.
Pour l'alimentation plus tard de la mini carte je sais que :
La petite carte à µC est un Arduino Pro Mini, c'est-à-dire l'un des rares modèles d'Arduino n'intégrant pas d'interface vers un PC.
Cette carte est disponible en plusieurs versions, en 5V ou 3,3V, et à des fréquences de quartz différentes (8, 10, 16 ou 20 MHz).
La version 3,3V peut être alimentée par une tension comprise entre 3,35V et 12V sur l'entrée RAW. La version 5V peut être alimentée par une tension comprise entre 5V et 12V sur l'entrée RAW.
L'entrée RAW est reliée à un régulateur intégré qui fournit au µC la tension VCC nécessaire.
Il est également possible d'alimenter directement le µC, sans passer par le régulateur, par l'entrée VCC. La tension à appliquer est alors beaucoup plus stricte. Elle ne doit en aucun cas dépasser 6,0 V, et sa valeur minimale dépend de la fréquence du quartz :
2,4 V < VCC < 6,0V pour 8 MHz 2,7 V < VCC < 6,0V pour 10 MHz 3,8 V < VCC < 6,0V pour 16 MHz 4,5 V < VCC < 6,0V pour 20 MHz
Moi j'ai une 5V mais derrière cette mini carte il y a 4 cases mais aucunes n'est cochées, j'ai 8 MHz 16MHz 3V3 et 5V je suis sûr que c'est 5 V car il est écrit sur l'emballage.
en supposant que se soit 16 MHz, le modèle 5V/16MHz pourrait ainsi être directement alimenté par une batterie de quatre éléments Ni-MH ou Ni-Cd (4×1,2V) sur l'entrée VCC.
enfin cela peut attendre
je vais écrire le code pour afficher sur la ligne du haut la vitesse, la parité O, E ou N et le nombre de bit stop et me servir des boutons pour les changer.
Pour plus de clarté dans les futurs codes, je déclare une variable globale nommée "bouton1" "bouton2" "bouton3" et ayant la valeur 2 , 4 et 7 qui correspondent au numéro des entrées de la carte et j'utilise les pullup intégrés pour les BP
Comme ceci :
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Set the LCD address to 0x27 for a 16 chars and 2 line display
const int bouton1 = 2; //le bouton1 est connecté à la broche 2 de la carte Adruino
const int bouton2 = 4; //le bouton2 est connecté à la broche 4 de la carte Adruino
const int bouton3 = 7; //le bouton3 est connecté à la broche 7 de la carte Adruino
void setup() {
Serial.begin(9600); //Lancer le mode série
// initialize the LCD
lcd.begin();
// Turn on the blacklight and print a message.
lcd.backlight();
pinMode(bouton1, INPUT);
digitalWrite(bouton1, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
pinMode(bouton2, INPUT);
digitalWrite(bouton2, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
pinMode(bouton3, INPUT);
digitalWrite(bouton3, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
}
void loop()
{
}
je vais avoir besoin d'aide pour afficher sur la ligne du haut les paramètres et comment on les changent avec les BP car je sais le faire en programme mais pas avec les BP
Et bien commence par faire ce que tu sais faire, ensuite montre nous la partie du code qui te pose problème.
Sinon, je n'ai pas bien pigé le plan de base, tu veux envoyer un message à ton arduino genre via hyperterminal ou un truc comme ça puis le renvoyer vers ton écran ?
oui je dois afficher ce que je tape dans un terminal sur la ligne du bas du lcd, sa je pense savoir le faire, j'ai un petit programme qui permet d'afficher sur le lcd ce que je tape dans le moniteur série.
le problème concerner ce que je dois afficher sur la ligne du haut c'est à dire la vitesse, la parité soit N ou odd ou even puis je dois afficher aussi le nombre de bit stop. De plus avec 3 BP je dois pouvoir changer ces paramètres, c'est la que je bloque niveau programmation.
pour l'instant j'ai :
void loop()
{
etatBouton1 = digitalRead(bouton1); //Rappel : bouton = 2
int A; // A représente le débit de la carte qui sera afficher sur le lcd
if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
{
Serial.begin(9600); //je reste à 9600
A=9600;
lcd.print (A);
}
else //test si le bouton a un niveau logique différent de HAUT (donc BAS)
{
Serial.begin(14400); //le bouton est appuyé, le débit passe à 14400
A=14400;
lcd.print (A);
}
}
mais je vois pas comment écrire en code que je veux si je rappui passer encore à une autre valeur soit 19200 puis etc
on me dit : crée une variable binaire qui définit ta vitesse, variable que tu inverses à chaque détection de pression sur ton bouton avec la fonction NOT.
Bon, deja, il y a une chose essentielle a savoir, pour faire un bon programmeur, il faut une grosse feignasse : si on se donne la peine de programmer une machine, c'est justement pour qu'elle fasse le boulot a notre place... Dès qu'on le peut on en fait le moins possible.
Donc déjà, sur ton code, à peu de chose près tu as écrit 2 fois la même chose, il va falloir trouver un moyen de ne l'écrire qu'une fois. Parce que si tu veux pouvoir gérer les 13 vitesses standards, tu n'as pas envie d'écrire la meme chose 13 fois.
Par exemple, je vois que tu utilises A pour mémoriser le debit en cours, du coup, tu peux ptêt juste changer A et n'écrire le reste qu'une fois comme :
if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
{
A=9600;
}
else //test si le bouton a un niveau logique différent de HAUT (donc BAS)
{
A=14400;
}
Serial.begin(A);
lcd.print (A);
Peut-être passer par une table dans laquelle on mettrait les valeurs possibles...
Ensuite, il faut savoir que le test va être fait plusieurs fois dans une seconde, hors ce que tu veux, c'est changer la valeur une seule fois à chaque appui et non la changer tant qu'on est appuyé...
Tu dois donc détecter un front montant de ton bouton, donc un changement d'état de bas vers haut, je te laisse y réflechir avec un indice : on a un front montant quand le signal est à 1 alors qu'il était à 0...
Normalement, tu as de quoi avancer un peu et éventuellement résoudre ton problème.
Avant de continuer la programmation j'aurais une petite question.
pouvez vous me dire si c'est correcte.
Le MAX232 sert d'interface entre une liaison série TTL (0-5V) et une liaison série RS232 (+12 -12V) et ce avec une simple alimentation 5V.
La liaison série asynchrone (TTL) est un moyen de communication entre deux systèmes électroniques facile à mettre en œuvre. La plupart des microcontrôleurs modernes disposent d'un circuit spécialisé (UART) leur permettant d'échanger des données avec l'extérieur. Sur cette liaison, une tension de 0V correspond à un 0 logique. Une tension de 3.3V ou 5V selon la tension nominale du circuit correspond à un 1 logique. Cette liaison s'apparente à la liaison RS-232 dont certains PC sont encore équipés, mais elle s'en différencie par les tensions utilisées. En RS-232, un 1 logique correspond à une tension entre -3V et -25V et un 0 logique à une tension entre +3 et +25V.
Par conséquent, si on veut connecter une sortie série utilisant les niveaux TTL soit la mini Arduino à son ordinateur, il faut un adaptateur spécialisé. Ici se sera mon MAX232 qui est l'adaptateur pour connecter la mini Arduino avec le PC parce qu'elle n'a pas de port USB mais un UART matériel qui est le composant utilisé pour faire la liaison entre l'ordinateur et le port série (synonyme de RS232).
Pour connecter le max232 à la mini arduino j'utilise le shéma suivant :
voila mais je ne sais pas comment connecter le pc à l'arduino car j'ai le composant qui permet de faire l'interface mais il me faudra quand même un USB pour tout connecter à l'ordi et envoyer le programme dans le microcontrôleur nn ?
je dois écrire un programme le mettre dans le microcontroleur de l'arduino mini sa ok
Le programme doit me permettre de : changer le débit, la parité et le nombre de bits stop avec 3 boutons poussoirs
par exemple à chaque appuie sur le BP 1 je change de valeur de débit je passe de 9600 à 14400 si je r'appuie je passe à la prochaine valeur.
Le problème avec l'ordinateur que j'utilise est qu'il me manque des librairies car quand je compile le code suivant :
Code:
#include <LiquidCrystal_I2C.h>
//*********** Librairies utilisées **********//
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
//*********** Règle la taille du LCD : 16 colonnes et 2 lignes **********//
LiquidCrystal_I2C lcd(0x27, 16, 2);
const int bouton1 = 2; //le bouton1 est connecté à la broche 2 de la carte Adruino
const int bouton2 = 4; //le bouton2 est connecté à la broche 4 de la carte Adruino
const int bouton3 = 7; //le bouton3 est connecté à la broche 7 de la carte Adruino
int etatBouton1;
int etatBouton2;
int etatBouton3;
//*********** tableau avec les 11 valeurs de débit possible **********//
float valeurdudebit[11] = {300,1200,2400,4800,9600,14400,19200,28800,38400,57600,115200};
void setup() {
Serial.begin(9600); //Lancer le mode série
// Initialiser l'écran LCD
lcd.begin();
// Allumer la lumiére noire : obligé d'être écrit pour faire fonctionner l'écran
lcd.backlight();
pinMode(bouton1, INPUT);
digitalWrite(bouton1, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
pinMode(bouton2, INPUT);
digitalWrite(bouton2, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
pinMode(bouton3, INPUT);
digitalWrite(bouton3, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
}
void loop()
{
etatBouton1 = digitalRead(bouton1); //Rappel : bouton = 2
int A; // A représente le débit de la carte qui sera afficher sur le lcd
int i=0;
if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
{
A=9600;
}
else //test si le bouton a un niveau logique différent de HAUT (donc BAS)
{
A=valeurdudebit[i];
i++;
}
Serial.begin(A);
lcd.print (A);
}
la première est : projet_1.ino: In function 'void setup()': projet_1:29: error: no matching function for call to 'LiquidCrystal_I2C::begin()' C:\Documents and Settings\Manu\Mes documents\Arduino\libraries\ic i/LiquidCrystal_I2C.h:59: note: candidates are: void LiquidCrystal_I2C::begin(uint8 _t, uint8_t, uint8_t)
d'après mon maitre de stage, il me faut plusieurs librairies mais je ne vois pas lesquelles car jusqu'a présent je n'utilisais que liquidcrystal_I2C que j'ai installé dans le logicile arduino de mon netbook mais les erreurs restent, pas moyen de compiler
oui bien sur mais par exemple ce code suivant compile chez moi mais pas sur ce netbook et savais vous comment on supprime des librairies importées car j'ai trouvé comment on supprime celles déja dans le logiciel (dans le dossier librairies ) mais pas celles importées.
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
// Set the LCD address to 0x27 for a 16 chars and 2 line display
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup() {
Serial.begin(9600); //Lancer le mode série
// initialize the LCD
lcd.begin();
// Turn on the blacklight and print a message.
lcd.backlight();
lcd.print("Hello, world!");
}
void loop() {
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
lcd.setCursor(0, 1);
// print the number of seconds since reset:
lcd.print(millis()/1000);
}
//*********** Librairies utilisées **********//
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
//*********** Règle la taille du LCD : 16 colonnes et 2 lignes **********//
LiquidCrystal_I2C lcd(0x27, 16, 2);
const int bouton1 = 2; //le bouton1 est connecté à la broche 2 de la carte Adruino
const int bouton2 = 4; //le bouton2 est connecté à la broche 4 de la carte Adruino
const int bouton3 = 7; //le bouton3 est connecté à la broche 7 de la carte Adruino
int etatBouton1;
int etatBouton2;
int etatBouton3;
//*********** tableau avec les 11 valeurs de débit possible **********//
float valeurdudebit[11] = {300,1200,2400,4800,9600,14400,19200,28800,38400,57600,115200};
int A;
int i=0;
void setup() {
Serial.begin(9600); //Lancer le mode série
// Initialiser l'écran LCD
lcd.begin();
// Allumer la lumiére noire : obligé d'être écrit pour faire fonctionner l'écran
lcd.backlight();
pinMode(bouton1, INPUT);
digitalWrite(bouton1, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
pinMode(bouton2, INPUT);
digitalWrite(bouton2, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
pinMode(bouton3, INPUT);
digitalWrite(bouton3, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
// A représente le débit de la carte qui sera afficher sur le lcd
}
void loop()
{
etatBouton1 = digitalRead(bouton1); //Rappel : bouton = 2
if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
{
A=9600;
}
else //test si le bouton a un niveau logique différent de HAUT (donc BAS)
{
A=valeurdudebit[i];
i++;
}
Serial.begin(A);
lcd.print (A);
}
Sur l'écran il y a bien 9600 qui s'affiche mais il est écrit plein de fois à la suite du genre 960096009600.. sur les 2 lignes du lcd
Quand j'appuie sur le bouton poussoir il se passe qqchose mais tout défile à très grande vitesse comme si il affichait toutes les valeurs et quand je le relache sa revient à 9600.
Ce que je veux c'est changer avec ce BP le débit et afficher une seul fois la valeur du débit qui est utilisée sur la ligne du haut du lcd
Cela semble tout à fait normal puisque lorsque tu n'appuies pas sur le bouton, tu vas faire défiler toutes les valeurs contenues dans ta table, il te faut incrémenter l'index qu'une unique fois, sur front montant de ton bouton. Un front montant ça se calcul par :
"est actif" && "n'était pas actif"
Est-il nécessaire de le rappeler, la fonction loop() est une boucle, ce qu'elle contient est donc exécuté plusieurs fois par seconde. Une fois que tu as transmis à ton afficheur ce qu'il doit afficher, il est inutile de le matraquer encore et encore avec la même consigne, normalement, il a très bien compris la première fois. On ne lui envoie des consignes d'affichage que s'il doit afficher autre chose que ce qu'il affiche déjà.
Même principe donc, on envoie à l'afficheur une consigne QUE si : à afficher != déjà affiché
//*********** Librairies utilisées **********//
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
//*********** Règle la taille du LCD : 16 colonnes et 2 lignes **********//
LiquidCrystal_I2C lcd(0x27, 16, 2);
const int bouton1 = 2; //le bouton1 est connecté à la broche 2 de la carte Adruino
const int bouton2 = 4; //le bouton2 est connecté à la broche 4 de la carte Adruino
const int bouton3 = 7; //le bouton3 est connecté à la broche 7 de la carte Adruino
//*********** tableau avec les 11 valeurs de débit possible **********//
float valeurdudebit[11] = {300,1200,2400,4800,9600,14400,19200,28800,38400,57600,115200};
int etatBouton1 = 0; //Variable pour l'état actuel du bouton poussoir 1
int lastetatBouton1 = 0; // Variable pour l'état précédent du bouton poussoir 1
int etatBouton2;
int etatBouton3;
void setup() {
Serial.begin(9600); //Lancer le mode série
// Initialiser l'écran LCD
lcd.begin();
// Allumer la lumiére noire : obligé d'être écrit pour faire fonctionner l'écran
lcd.backlight();
pinMode(bouton1, INPUT);
digitalWrite(bouton1, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
pinMode(bouton2, INPUT);
digitalWrite(bouton2, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
pinMode(bouton3, INPUT);
digitalWrite(bouton3, HIGH); //on active la résistance de pull-up en mettant la broche à l'état haut
// A représente le débit de la carte qui sera afficher sur le lcd
}
int A;
int i=0;
void loop()
{
etatBouton1 = digitalRead(bouton1); //Rappel : bouton1 = 2; lit l'état actuel du bouton poussoir et le mémorise dans la variable
// compare l'état actuel du bouton poussoir à l'état précédent mémorisé
if (etatBouton1 != lastetatBouton1) {
if(etatBouton1 == HIGH) //test si le bouton a un niveau logique HAUT
{
A=9600;
}
else //test si le bouton a un niveau logique différent de HAUT (donc BAS)
{
A=valeurdudebit[i];
i++;
Serial.begin(A);
lcd.print (A);
}
//mémorise l'état courant du bouton poussoir
//pour les prochains passages dans la boucle loop
lastetatBouton1 = etatBouton1;
}
}
je pense avoir qqchose de mieux. une fois le programme téléchargé, en haut à gauche de l'écran on voit 300 si j'appuie sur le BP il affiche 3001200 puis après 30012002400 quand je r appui soir les valeurs de mon tableau. je voulais savoir si il est possible qu'il affiche le débit suivant à la place de l'ancien soit au lieu d'afficher à la suite 3001200 se serais plutôt 300 et quand j'appuie il n'y a que 1200 qui s'affiche à la place de 300
je sais enfin changer le débit et afficher sur l'écran celui que j'utilise.
Maintenant je dois pouvoir changer la parité et le nombre de bits stop.
je pense que je dois utiliser SERIAL_5N1 SERIAL_6N1 SERIAL_7N1 SERIAL_8N1 (celui par défaut) SERIAL_5N2 SERIAL_6N2 SERIAL_7N2 SERIAL_8N2 SERIAL_5E1 SERIAL_6E1 SERIAL_7E1 SERIAL_8E1 SERIAL_5E2 SERIAL_6E2 SERIAL_7E2 SERIAL_8E2 SERIAL_5O1 SERIAL_6O1 SERIAL_7O1 SERIAL_8O1 SERIAL_5O2 SERIAL_6O2 SERIAL_7O2 SERIAL_8O2
C'est à dire que lorsque j'appui sur le bouton je change la parité et sur l'autre bouton je change le nombre de bits stop. Et afficher sur le lcd la parité que j'ai et le nb de bits stop.
Mais là je ne vois pas comment faire, si je dois dire tous les cas possibles.
Bah tu prepares une chaine et tu remplaces juste la valeur qui t'interesse dedans (sprintf ou en bricolant directement le tableau de caracteres de la chaine)
Tu as juste la parite et le stop a change ? Dans ce cas fais deux if/else et ca sera simple.
S'il y a plus de choses a changer, il faudra etre plus malin si tu veux pas te taper un paquet de if/else imbrique.
oui je n'ai que sa à changer et à afficher au milieu et à droite sur la ligne du haut du lcd 2*16 lignes
sur le bas je dois afficher le code que je tape, j'ai un programme qui permet d'afficher sur le lcd ce que je tape dans le moniteur série. je dois juste faire en sorte qu'il l'affiche sur la ligne du bas.
Le premier bouton poussoir m'a servi à changer le débit que je devais afficher en haut à gauche du lcd, c'est fait, j'ai utilisé pour changer le débit : Serial.begin ( valeur du débit) en fait j'ai créé un tableau avec les valeurs des débits possibles et quand j'appui sur le BP sa change le débit tout en l'affichant.
pour changer la parité et les bits stop je pense que je dois utiliser
Mais je ne pense pas que les if et else soit utile ici ?
je pensais fair un truc du genre SERIAL_B
avec B qui est un tableau qui contient [ 5N1, 6N1, 7N1,.....] soit les changer possibles. le problème est que en faisant sa je change la parité et le nb de bits stop avec alors que je dois les changer indépendamment si c'est possibles
oui je n'ai que sa à changer et à afficher au milieu et à droite sur la ligne du haut du lcd 2*16 lignes
sur le bas je dois afficher le code que je tape, j'ai un programme qui permet d'afficher sur le lcd ce que je tape dans le moniteur série.
je dois juste faire en sorte qu'il l'affiche sur la ligne du bas.
Le premier bouton poussoir m'a servi à changer le débit que je devais afficher en haut à gauche du lcd
, c'est fait, j'ai utilisé pour changer le débit : Serial.begin ( valeur du débit) en fait j'ai créé un tableau avec les valeurs des débits possibles et quand j'appui sur le BP sa change le débit tout en l'affichant.
pour changer la parité et les bits stop je pense que je dois utiliser
Mais je ne pense pas que les if et else soit utile ici ?
je pensais fair un truc du genre SERIAL_B
avec B qui est un tableau qui contient [ 5N1, 6N1, 7N1,.....] soit les changer possibles. le problème est que en faisant sa je change la parité et le nb de bits stop avec alors que je dois les changer indépendamment si c'est possibles
il est possible de retrouver les defines, il y a un logique dans les définitions dont tu peux te servir pour redéfinir le mode de connexion, je te laisse chercher, de simples additions devraient faire l'affaire :
merci pour votre aide, j'ai utilisé une autre méthode.
J'arrive à changer le débit la parité et le nb de bits stop avec les 3 BP.
cependant tous s'affichent en à gauche de l'écran j'aimerais plutôt en haut à gauche le débit, en haut au milieu la parité et en haut à droite le nb de bits stop.
puis une fois que j'arrive à afficher les 3 correctement,
il me restera juste à bien changer la parite et le nb de bits stop
je vais faire du style
If parité = xx and bitsstop = YY then "define TTT"
Pou tout afficher comme je le souhaite on me dit d'utiliser la fonction String mais même en regardant sur internet je ne vois
pas comment l'utiliser pour que sa face ce que je veux ( afficher les 3 débit,parité,bits stop, sur la ligne du haut de l'écran)
avec B la parité et C le nb de bit stop; est ce que sa se not comme sa car comme erreur j'ai :
avec_2BP.ino: In function 'void loop()': avec_2BP:149: error: lvalue required as left operand of assignment avec_2BP:151: error: 'define' was not declared in this scope avec_2BP:151: error: expected `;' before numeric constant
et quand j'écris #define de cette façon :
if (B = "No P " && C = 1) { #define SERIAL_8N1; }
mais comme erreur j'ai
avec_2BP.ino: In function 'void loop()': avec_2BP:149: error: lvalue required as left operand of assignment
j'ai trouvé mon erreur il faut d'abord mettre == et non =. et aussi Serial.begin(9600, SERIAL_8N1) ; je voulais savoir, sur la ligne du bas je dois voir apparaître ce que je tape sans le moniteur série. comme code j'ai :
//*********** Librairies utilisées **********//
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
//*********** Règle la taille du LCD : 16 colonnes et 2 lignes **********//
LiquidCrystal_I2C lcd(0x27, 16, 2);
void setup()
{
Serial.begin(9600); //Lancer le mode série
lcd.begin(); // Initialiser l'écran LCD
lcd.backlight(); // Allumer la lumiére noire : obligé d'être écrit pour faire fonctionner l'écran
lcd.setCursor(0,1);
}
void loop()
{
char val;
// regarde si quelque chose se trouve dans le buffer
if (Serial.available()) {
// lit le premier byte dans la pile (valeur entre 0 to 255)
val = Serial.read();
lcd.print (val); // par exemple
}
}
le truc est que lorsque j'arrive à la fin de la ligne du bas je dois tapper 20 lettres pour qu'il recommence à écrire sur la ligne du haut.
N'est il pas possible qu'il écrive seulement sur la ligne du bas et dès qu'il arrive au bout de la ligne il recommence au début de la ligne du bas
Notamment sur le rôle de l'horloge temps réel, à quoi sert-elle ?
aide programmation arduino
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Bonhomme !! | Jeu de plateforme : Prototype.
Bonhomme !! | Jeu de plateforme : Prototype.
Bonhomme !! | Jeu de plateforme : Prototype.
Retrouvez moi sur mon blog et ma chaine Youtube !
Bonhomme !! | Jeu de plateforme : Prototype.
Retrouvez moi sur mon blog et ma chaine Youtube !
Retrouvez moi sur mon blog et ma chaine Youtube !
Retrouvez moi sur mon blog et ma chaine Youtube !
Retrouvez moi sur mon blog et ma chaine Youtube !
Bonhomme !! | Jeu de plateforme : Prototype.
Retrouvez moi sur mon blog et ma chaine Youtube !