Go Down

Topic: Projet mallette fausse bombe (Read 1 time) previous topic - next topic

kamill

Bonjour,

Est ce que tu as bien compris que sprintf n'affiche rien, mais prépare un texte qu'il faut ensuite afficher en faisant un 'lcd.print(message);'

ababi

oups non, je n'avais pas compris ça !
je pensais que cette fonction affichait d'elle-même le texte qu'elle préparait !

Du coup, j'ai testé et ça marche beauuuucoup mieux, et c'est du coup plus propre :)
merci !

ababi

Bonjour !
J'ai enfin fini mon projet !
Tout semble fonctionnel, à voir avec les bêta tests à venir semaine prochaine.

Cependant, je trouve que le "démarrage" est un peu long...
une fois l'arduino branché, il lui faut 7-8 sec pour démarrer le compte à rebours sur l'écran, le temps de "créer" toutes les variables et de tout initialiser je présume, mais ça m'embête un peu, puisque quand les joueurs ouvriront la mallette, ils ne verront rien sur  l'écran pendant ce temps, puisque c'est l'ouverture de la mallette qui va actionner l'interrupteur qui alimente l'arduino.

De plus, j'ai une LED puissante qui sert d'"effet spécial" lorsque la bombe explose, qui pendant ce temps de démarrage, reste allumée, avant de s'éteindre une fois que la boucle est lancée.

N'y a-t-il pas moyen d'accélérer le démarrage ? J'avais pensé à déclarer une partie des variables dans la fonction loop(), mais je crains alors que ça ralentisse celle-ci si à chaque cycle les variables repassent à la moulinette.

Et pour la LED, je l'éteins dès la fonction setup(), mais ça ne change pas grand chose. Y'a-t-il un moyen de mettre une pin à 0 dès la déclaration des variables globales ?

Voilà ma déclaration de variables :

Code: [Select]

//######### LIBRAIRIES KEYPAD #############
#include <Key.h>
#include <Keypad.h>

//########## LIBRAIRIES ÉCRAN #############
#include <Wire.h>
#include "rgb_lcd.h"

//########## FONCTION ÉCRAN LCD ###########
rgb_lcd lcd;


//#########################################
//########## DEFINITION DES PINS ##########
//#########################################

const byte pinbuzzer = 6;
const byte pinmorse = 2;
const byte pinledexp = 1;

//################# FILS ##################
const byte pinfilrouge = 7;
const byte pinfiljaune = 8;
const byte pinfilvert = 9;
const byte pinfilgris = 10;

const byte pinfil1 = 11;
const byte pinfil2 = 12;
const byte pinfil3 = 13;
const byte pinfil4 = 14;
const byte pinfil5 = 15;
const char pinfil6 = A3; //ATTENTION, les pins analogiques sont définis sans les variables, ici juste pour mémoire
const char pinfil7 = A4; //ATTENTION, les pins analogiques sont définis sans les variables, ici juste pour mémoire
const char pinfil8 = A0; //ATTENTION, les pins analogiques sont définis sans les variables, ici juste pour mémoire
const char pinfil9 = A1;  //ATTENTION, les pins analogiques sont définis sans les variables, ici juste pour mémoire
const char pinfil10 = A2;  //ATTENTION, les pins analogiques sont définis sans les variables, ici juste pour mémoire


//########### CLAVIER MATRICIEL ###########
const byte C3 = 3; //declaration constante de broche
const byte C2 = 4; //declaration constante de broche
const byte C1 = 5; //declaration constante de broche
const byte L4 = 16; //declaration constante de broche
const byte L3 = 17; //declaration constante de broche
const byte L2 = 18; //declaration constante de broche
const byte L1 = 19; //declaration constante de broche



//#########################################
//######## VARIABLES FILS À COUPER ########
//#########################################

boolean bons_fils = 0;
boolean filrouge;
boolean filvert;
boolean filjaune;
boolean filgris;



//#########################################
//############ VARIABLES BUZZER ###########
//#########################################




//#########################################
//###### VARIABLES CLAVIER MATRICIEL ######
//#########################################

const byte LIGNES = 4; // 4 lignes
const byte COLONNES = 3; // 3 colonnes

char touches[LIGNES][COLONNES] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'7', '8', '9'},
  {'*', '0', '#'}
};

//#### TABLEAU DE LIGNES ET COLONNES ####
byte BrochesLignes[LIGNES] = {L1, L2, L3, L4}; //connexions utilisées pour les broches de lignes du clavier
byte BrochesColonnes[COLONNES] = {C1, C2, C3}; //connexions utilisées pour les broches de colonnes du clavier

char touche; // variable de stockage valeur touche appuyée

Keypad clavier = Keypad( makeKeymap(touches), BrochesLignes, BrochesColonnes, LIGNES, COLONNES );



//#########################################
//####### VARIABLES COMPTE À REBOURS ######
//#########################################

const int temps_restant = 300; // temps restant en secondes
byte minutes;
byte secondes;
boolean acceleration = 0;
int tps_acceleration; // temps à partir duquel a lieu l'accélération
char message[16] = ""; // variable de concaténation de message écran



//#########################################
//########## VARIABLE FIN DE JEU ##########
//#########################################

boolean game_over = 0;


//#########################################
//######### VARIABLES CODE CLAVIER ########
//#########################################

byte nb_touche = 0; //nombre de touches tapées
const char code1 = '3';
const char code2 = '3';
const char code3 = '3';
const char code4 = '3';
char touche1; //première touche tapée
char touche2; //deuxième touche tapée
char touche3; //troisième touche tapée
char touche4; //quatrième touche tapée
byte nb_essais = 3;


//#########################################
//########## VARIABLES CODE MORSE #########
//#########################################

const long intervalle = 500;
boolean debut_morse = 0;
unsigned long revolution = 0;
long temps_revolution = 135 * intervalle;




Je peux coller le reste demon code au besoin, mais il est quand même assez long (sans doute manque-t-il cruellement d'optimisation aussi ^^), et ce n'est peut-être pas nécessaire dans un premier temps, dites-moi si vous en avez besoin.

D'avance merci de vos éclairages :)

J-M-L

#18
Aug 24, 2019, 08:42 am Last Edit: Aug 25, 2019, 08:15 am by J-M-L
quel arduino utilisez vous ? Certains (pro-micros par exemple) ont un firmware qui attend environ 8 secondes pour essayer d'enumérer Ce qui est connecté au bus USB. Chargez le programme exemple blink, débranchez l'usb, mettez une alimentation externe. si le clignotement ne commence que 8s plus tard alors c'est votre cas... changez le bootloader ou prenez un autre arduino

Sinon Il n'y a aucune raison que ça prenne autant de temps... l'initialisation de variables se mesure généralement plutôt en micro ou quelques millisecondes  - vous devez avoir un truc louche dans la code ...
Hello - Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums.
Bonjour Pas de messages privés SVP, postez dans le forum directement pour que ça profite à tous

ababi

J'utilise un arduino mega, est-ce possible que ce soit ça ?
je n'ai pas compris quand vous dites "chargez le programme,à,e blink" :/
je n'ai pas encore reçu mes batteries pour l'alimenter, mais je ferais le test une fois que je les aurais reçues.

Mais, à mon avis, c'est sans doute plus un truc louche dans mon code, étant donné mon niveau, il doit y avoir des trucs codés avec les pieds ^^

J-M-L

#20
Aug 25, 2019, 08:17 am Last Edit: Aug 25, 2019, 08:18 am by J-M-L
Je voulais dire « chargez le Programme d'exemple Blink »

Postez le code en 2 post (appuyez avant sur ctrl-T pour indenter) et en utilisant les Balises de code 
Hello - Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums.
Bonjour Pas de messages privés SVP, postez dans le forum directement pour que ça profite à tous

ababi

J'ai chargé l'exemple blink, pour l'instant toujours avec alimentation USB depuis mon PC, et même souci, ça met 7-8s avant de clignoter.
je testerai avec mes batteries dès réception.

Du coup, j'attends avant de saturer le post avec le code, puisque ça n'a pas l'air forcément lié.

J-M-L

OK - oui dans ce cas vous devez avoir un Arduino avec un boot loader qui a besoin d'attendre...

-> jetez un oeil ici

vous devez pouvoir sans doute changer de boot loader ou le virer complètement en programmant par ISP.
Hello - Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums.
Bonjour Pas de messages privés SVP, postez dans le forum directement pour que ça profite à tous

ababi

J'ai jeté un oeil à ce que vous m'avez envoyé, et j'ai pris un peu peur...
puis j'ai reçu mes batteries et fait le test... et là, miracle, ça démarre sans délai !
ça semble donc être lié à l'alimentation USB par PC :(

Merci en tout cas de toute votre aide !!

Et si vous voulez voir le projet en action, il sera jouable gratuitement à l'occasion de l'anniversaire du Dé Botté à TOURNAI (Belgique), mi-septembre :)
venez nombreux ;)

J-M-L

#24
Sep 02, 2019, 08:44 am Last Edit: Sep 02, 2019, 08:45 am by J-M-L
Oui sans doute si l'USB est branché il essaye de lister les trucs au bout de l'USB. S'il n'est pas branché alors il ne doit pas le faire.

(Changer le boot loader n'est pas si compliqué)

Postez nous quelques photos !!
Hello - Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums.
Bonjour Pas de messages privés SVP, postez dans le forum directement pour que ça profite à tous

ababi

J'attends de mettre tout bien en place dans la mallette avant de poster les photos ^^

Par contre, je rencontre un nouveau problème :
Après les beta-tests, il a semblé nécessaire que les équipes puissent avoir des indices.
Je souhaite donc utiliser l'écran LCD pour les afficher, lorsqu'un code particulier est tapé sur le clavier matriciel.

Problème : les indices font plus de 16 caractères, et je souhaite donc les faire défiler à l'écran.
J'aimerai stocker l'indice dans une variable de type "char", et modifier le contenu de cette variable selon le code tapé, mais c'est là que je rencontre pas mal de messages d'erreur

j'ai essayé différentes syntaxes pour la définition de la variable :
char indice;
char indice = "";
char indice[] = "";
char indice [80] = ""; (j'avais cru lire que la longueur max du message "stockée" par un écran était de 80 caractères)

je "remplis" ma variable avec par exemple :
indice = "LE CHEMIN MENE A UNE SEULE COULEUR";

et je veux l'afficher avec :
lcd.print(indice);

Seulement, je me retrouve avec des message d'erreur du type
"invalid conversion from 'const char*' to 'char' [-fpermissive]"
"incompatible types in assignment of 'const char [34]' to 'char [1]' "
"invalide array"

Du coup, je ne comprends pas comment manipuler cette variable "char" avec un texte qui sera de différentes longueurs selon les indices.

J'arrive pourtant à le faire pour afficher mon compte à rebours comme décrit plus haut, avec sprintf() et lcd.print(), mais du coup avec une variable définie tel que :
char message[16] = ""; (et un texte qui est toujours de la même longueur)

A côté de quoi suis-je passé ?

Cordialement,

J-M-L

#26
Sep 07, 2019, 06:23 pm Last Edit: Sep 07, 2019, 07:29 pm by J-M-L
Un buffer de 80 caractère se déclare bien avec
Code: [Select]
char indice[80];
ensuite pour copier du texte dedans vous avez la fonction strcpy() par exemple. (on ne peut pas utiliser l'affectation directe avec un =)

voilà deux options:
Code: [Select]
/* données en mémoire programme, laisse de la RAM */
const char indice1[] PROGMEM = "LE CHEMIN MENE A UNE SEULE COULEUR";
const char indice2[] PROGMEM = "LA LUNE EST ROUSSE";
const char* const tableauIndicesMemoireFlash[] PROGMEM = {indice1, indice2};

/* données en mémoire  RAM */
const char* const tableauIndicesMemoireRAM[] = {
  "LE CHEMIN MENE A UNE SEULE COULEUR",
  "LA LUNE EST ROUSSE"
};

char monIndice [80] ;

void setup()
{
  Serial.begin(115200);

  /* données en mémoire programme, laisse de la RAM */
  strcpy_P(monIndice, tableauIndicesMemoireFlash[0]);
  Serial.println(monIndice);
 
  strcpy_P(monIndice, tableauIndicesMemoireFlash[1]);
  Serial.println(monIndice);

  Serial.println(F("-------------"));

  /* données en mémoire programme, laisse de la RAM */
  strcpy(monIndice, tableauIndicesMemoireRAM[0]);
  Serial.println(monIndice);
 
  strcpy(monIndice, tableauIndicesMemoireRAM[1]);
  Serial.println(monIndice);
 
  Serial.println(F("-------------"));

  /* bien sûr quand c'est déjà en RAM, on n'a pas besoin de dupliquer le contenu, on peut y accéder directement */
  Serial.println(tableauIndicesMemoireRAM[0]);
  Serial.println(tableauIndicesMemoireRAM[1]);
}

void loop() {}


la première stocke toutes les descriptions d'indices dans la mémoire programme (flash), ça vous permet de garder de la place en RAM pour les données de votre programme.

la seconde est plus simple à écrire, mais occupe de la RAM pour chacune des chaînes.

Notez que si la chaîne de caractère est en mémoire flash, il faut la ramener en RAM avant de les utiliser, c'est ce que fait la fonction strcpy_P() et donc la première série d'impressions.

Il existe la fonction strcpy() qui va copier de RAM vers RAM, le deuxième exemple fait cela puisque les indices sont déjà en RAM. (

mais puisqu'ils sont déjà en RAM, pourquoi s'ennuyer à dupliquer l'indice dans un buffer, autant utiliser directement l'entrée dans le tableau (3ème série d'impressions)


Notez qu'il existe aussi strncpy() qui permet de dire la taille de son buffer pour ne pas déborder. dans ce cas penser à rajouter un caractère null en fin de chaîne car strncpy() ne le mettra pas pour vous s'il a rempli le buffer.
Code: [Select]
  monIndice[79] = '\0'; // on force le dernier caractère en marque de fin de cString
...
  strncpy(monIndice, tableauIndicesMemoireRAM[0], 79); // max 79 caractères comme cela le 80ème est toujours un fin de chaîne
  Serial.println(monIndice);


et il existe de même pour la mémoire flash la fonction strncpy_P()

Hello - Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums.
Bonjour Pas de messages privés SVP, postez dans le forum directement pour que ça profite à tous

ababi

Comme promis, une petite photo pour teaser un peu ;)


SeverineMI

Bonsoir
Je suis en train de préparer un jeu d'énigmes. Seriez vous prêt à me vendre votre création ?

Go Up