garder une constante dans la memoire flash

Bonsoir tout le monde,

Pour les besoin d'un projet j'aimerais appairer une telecommande (attiny) avec un systeme a base d'ATMEGA. je programme deja ca sur arduino.

Afin d'avoir une reconnaissance j'envoie un mot avec la telecommande via radio et si le mot recu par le systeme arduino correspond a la telecommande, celui ci fait l'action demandée.
le probleme c'est que je dois prevoire le fait que l'utilisateur change de telecommande, donc au bout d'un appuis long sur un bouton j'aimerais que l'arduino recoive le nom de la telecommande et l'enregistre dans une char, et que malgré un reset je garde quand meme cette telecommande en memoire.

aSi quelqu'un a une solution pour deja changer une char dans loop() je suis preneur, meme si cela saute apres un reset =) car si je fait : char const = *name
name = "un"
...
name = buf
j'ai une erreur de convertion entre uint8_t et char (GRRR)

merci d'avance tout le monde !!

Je ne vois pas comment l'insérer.

ma telecommande s'apelle bobo et l'arduino ne veux repondre que a blabla.
quand j'appuie sur la telecommande ca fait (BOBO) --- 5sec --- (APPAIRER) - BOBO BOBO BOBO (je ne suis pas arrivé a faire une boucle pour envoyer le message à l'infini a partir de cet endroit)

l'arduino est sencé recevoir (appairer) et donc ensuite copier le message d'apres, c'est a dire (BOBO) dans sa reference non ?

#include <VirtualWire.h> // inclusion de la librairie VirtualWire

char const *name;
unsigned char buf[VW_MAX_MESSAGE_LEN]; // Tableau qui va contenir le message reçu (de taille maximum VW_MAX_MESSAGE_LEN)
unsigned char buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau
int moteur = 2;
int temps = 820;
int tempsaj = 820;
void setup() // Fonction setup()
{
    name = "BLABLA";
    pinMode (moteur , OUTPUT);
    vw_setup(2000);	// initialisation de la librairie VirtualWire à 2000 bauds 
    vw_rx_start();  // Activation de la partie réception de la librairie VirtualWire
}

void loop() // Fonction loop()
{
  digitalWrite(moteur, HIGH);
    if (vw_wait_rx_max(200)) // Si un message est reçu dans les 200ms qui viennent
    {
		if (vw_get_message(buf, &buflen)) // On copie le message, qu'il soit corrompu ou non
		{
			
                
	       if(strcmp("APPAIRER", (char*)buf) == 0) // 
                {
                  vw_rx_stop();
                  delay (100);
                  vw_rx_start();
                  {
                    if (vw_get_message(buf, &buflen)) // On copie le message, qu'il soit corrompu ou non
               char const *name = ((char*)buf);
       
              }
                }
          else if(strcmp(name, (char*)buf) == 0) // Si le message recu est "blabla" 
                  {
                    vw_rx_stop();//on arrete la reception
                    digitalWrite(moteur, LOW); // On allume le moteur
               
                delay (temps); // On attend le temps necessaire
                digitalWrite(moteur, HIGH);//On éteint le moteur
                 temps = temps + tempsaj; // on ajuste le temps
                vw_rx_start();
                  }  
  }
}
}

Bin l'EEPROM est une mémoire morte donc elle même si on coupe le courant on qu'on écrit un autre programme ce qui y est écrit y reste à moins qu'on réécrive par dessus. Point faible ce pendant : elle a un nombre d'écriture limité de l'ordre de 100 000. Mais ici ça ne pose donc pas de problème.

L'idée c'est quoi : admettons que ton récepteur accepte 10 télécommandes et que tu as un bouton de synchronisation. Au démarrage, l'Atmega lit son EEPROM à partie de l'adresse 60 (au pif hein). Si tu n'as jamais rien n'écrit dessus, les bytes à chaque adresse valent 255. Admettons pour le moment que chaque télécommande est identifiée par un numéro compris en tre 0 et 254. Au démarrage donc, on va chargé un tableau de 10 byte avec chaque adresse à partir de 60. Ensuite quand tu reçois un message il suffit de comparer l'identificateur de télécommande et la list epour voir s'il en fait parti : si c'est le cas on traite le message, sinon on l'oubli. Et pour apprendre une télécommande, il suffit d'appuyer sur le bouton pour faire passer l'Arduino en mode "apprentissage" puis au premier identificateur reçu on l'enregistre dans la l'EEPROM + dans la liste en cours et on repasse en mode normal.

En fait je suis limité en nombre de boutons.

Premierement ma telecommande c'est un ATtiny 85 . le bouton c'est le bouton d'alimentation.

j'appuie sur le bouton, la premiere chose que fait l'ATtiny c'est envoyer son nom (ou adresse je sais pas comment dire =) )
logiquement l'utilisateur ne fait que des appuis brefs pour declencher son syteme.

mais apres mon envoi de nom, j'ai un delay() de plusieurs secondes. a terme j'envoie le mot "APPAIRER" puis plein de fois son nom.

c'est ensuite du coté du systeme qui recois d'interpreter cette info.
normalement si il recois un truc il le compare au nom auquel il est appairé (PAUL = PAUL ? oui) si c'est le cas le systeme reagis
si c'est autre chose il fait rien, mais dans la meme boucle j'ai
else if -> buf = APPAIRER
si c'est le cas on attend le mot d'apres (logiquement un nom de telecommande comme programmé sur l'attiny)
supposont que JAQUES soit dans le buf j'ai fait : name = (char*(buff))

je debute vraiment et je galere la, je me suis frotté a trop dur et je dois rentre un rapport pour apres demain (je dois encore le rediger --')

PS : si je met les 2 PAUL ca marche, cependant si le systeme est associé a un autre nom j'ai l'impression que "appairer" j'arrive jamais en reception oO j'ai mis une led pour tester l'avancement et j'ai rien du tout

cf les codes :

EMMISSION :

#include <VirtualWire.h> // inclusion de la librairie VirtualWire

const char *msg = "PAUL"; // Tableau qui contient notre message
const char *msg2 = "CHANGE";
void setup() // Fonction setup()
{
  vw_setup(2000);		// initialisation de la librairie VirtualWire à 2000 bauds (note: je n'utilise pas la broche PTT)
  vw_set_tx_pin(3);
}

void loop() // Fonction loop()
{
          vw_send((uint8_t *)msg, strlen(msg)); // On envoie le message 
        vw_wait_tx(); // On attend la fin de l'envoi
      delay (3000);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
      vw_send((uint8_t *)msg2, strlen(msg));
      vw_wait_tx ();
      delay (500);
   
  }

RECEPTION

#include <VirtualWire.h> // inclusion de la librairie VirtualWire

const char *name;
char const *change;
unsigned char buf[VW_MAX_MESSAGE_LEN]; // Tableau qui va contenir le message reçu (de taille maximum VW_MAX_MESSAGE_LEN)
unsigned char buflen = VW_MAX_MESSAGE_LEN; // Taille maximum de notre tableau
int moteur = 2;
int led = 4;
int temps = 820;
int tempsaj = 820;
void setup() // Fonction setup()
{
    name = "PIERRE";
    change = "CHANGE";
    pinMode (moteur , OUTPUT);
    pinMode (led , OUTPUT);
    vw_setup(2000);	// initialisation de la librairie VirtualWire à 2000 bauds (note: je n'utilise pas la broche PTT)
    vw_rx_start();  // Activation de la partie réception de la librairie VirtualWire
}

void loop() // Fonction loop()
{
  digitalWrite(moteur, HIGH);
  digitalWrite(led, HIGH);

    if (vw_wait_rx_max(200)) // Si un message est reçu dans les 200ms qui viennent
    {
	if (vw_get_message(buf, &buflen)) // On copie le message, qu'il soit corrompu ou non
		{
			if(strcmp(name, (char*)buf) == 0) // Si le message recu est "ROLL OFF" 
                            {
                              vw_rx_stop();//on arrete la reception
                              digitalWrite(moteur, LOW); // On allume le moteur
                              delay (temps); // On attend le temps necessaire
                              digitalWrite(moteur, HIGH);//On éteint le moteur
                              temps = temps + tempsaj; // on ajuste le temps
                              vw_rx_start();
                            }
                
	               if(strcmp(change, (char*)buf) == 0) // Si le message recu est "ROLL OFF" 
                            {
                              digitalWrite (led, LOW);
                              vw_rx_stop();
                              delay (100);
                              vw_rx_start();
                  
                              if (vw_get_message(buf, &buflen)) // On copie le message, qu'il soit corrompu ou non
                                 {
                                  digitalWrite (led, LOW);
                                  vw_rx_stop();
                                  delay (100);
                                  vw_rx_start();
                                  name = ((char*)buf);
                                  } 
       
              }
                }
           
  }
}