Go Down

Topic: Erreur fantôme.... unqualified-id before '[' :D (Read 1 time) previous topic - next topic

M.Psyco

Je voulais utiliser mon clavier (qwerty) avec le Arduino... J'ai chercher un peu, j'ai copier ce que quelqu'un avait fait puis j'ai commencer à modifier.

Voilà ce que j'ai pour l'instant:

scancode1 c'est pour les Scancode à un seul byte
alors que scancode2 et 3 corresponde à l'un l'autre
ex:  Appuie sur Delete; Scancode = E0 71
71 se trouve dans la 9e case de scancode3 et ce que je veux qu'il (le Arduino) est alors dans la 9e case de scancode2....
(au fait, j'ai mit des [n/c] au cas où il y aurait une touche que j'aurais oublier...)

et mon problème c'est que quand je compile pour savoir si j'ai une erreur en quelque part, ça me donne cette erreur:

error: expected unqualified-id before '[' token

et ça me revoie à la ligne juste avant char* scancode1[] = {

Je vous remercie d'avance et je vous pris de tenir compte de ma fatigue de ce moment et aussi du fait que j'ai pas fini (et de loin) mon programme.. et bla, bla, bla  :D


#define dataPin 5
#define clockPin 3
#define ledPin 13

/*
TODO:

Pour l'instant c'est unidirectionnel, faudrait pouvoir l'avoir en bidirectionnel.

Il reste à finir la fonction qui traduit ce qu'il y a dans le buffer en string.

et à faire la fonction qui afficher le buffer (ou plutôt sa traduction).

Ajouter les touche multimedia.

*/

l'erreur est sur cette ligne....  :o
char* scancode1[] = {

 "[F9]",  "N/C",  "[F5]",  "[F3]",  "[F1]",  "[F2]",  "[F12]",  "[N/C]",
 "[F10]", "[F8]", "[F6]",  "[F4]",  "[TAB]", "#", "[N/C]",  "[N/C]",
 "[L ALT]",  "[L SHIFT]",  "[N/C]",  "[L CTRL]",  "Q",  "1",  "[N/C]",  "[N/C]",
 "[N/C]",   "Z",  "S",  "A",  "W",  "2",  "[N/C]",  "[N/C]",  
 "C",       "X",  "D",  "E",  "4",  "3",  "[N/C]",  "[N/C]",  
 "[SPACE]", "V",  "F",  "T",  "R",  "5",  "[N/C]",  "[N/C]",  
 "N", "B",  "H",  "G",  "Y",  "6",  "[N/C]",  "[N/C]",  
 "[N/C]",  "M",  "J",  "U",  "7",  "8",  "[N/C]",  ",",  
 /* 40 */
 "[N/C]",  "K",  "I",  "0",  "0",  "9",  "[N/C]",  "[N/C]",  
 ".",  "/",  "L",  ";",  "P",  "-",  "[N/C]",  "[N/C]",  
 "[N/C]",  "`",  "[N/C]",  "[",  "=",  "[N/C]",  "[N/C]",  "[CAPS]",  
 "[R SHIFT]",  "[ENTER]",  "]",  "[N/C]",  "\\",  "[N/C]",  "[N/C]",  "[N/C]",  
 "[N/C]",  "[N/C]",  "[N/C]",  "[N/C]",  "[N/C]",  "[BKSP]",  "[N/C]",  "[N/C]",
 /* 68 */
 "[KP 1]","[N/C]",  "[KP 4]",  "[KP 7]",  "[N/C]",  "[N/C]",  "[N/C]",  "[KP 0]",  
 "[KP .]",  "[KP 0]",  "[KP 5]",  "[KP 6]",  "[KP 8]",  "[ESC]",  "[NUM]",  "[F11]",  
 "[KP +]",  "[KP 3]",  "[KP -]",  "[KP *]",  "[KP 9]",  "[SCROLL]",  "[N/C]",  "[N/C]",  
 "[N/C]",  "[N/C]",  "[F7]" };

char* scancode2[] = {
 "[L GUI]",  "[R CTRL]",  "[R GUI]",  "[R ALT]",  "[APPS]",  "[INSERT]",  "[HOME]",  "[PG UP]",  
 "[DELETE]",  "[END]",  "[PG DN]",  "[U ARROW]",  "[L ARROW]",  "[D ARROW]",  "[R ARROW]",  "[KP /]",  
 "[KP EN]" };

char* scancode3[] = {
 0x1F,  0x14,  0x27,  0x11,  0x2F,  0x70,  0x6C,  0x7D,  0x71,  0x69,  0x7A,  0x75,  0x6B,  0x72,  0x74,  0x4A,  0x5A };

#define scancode2count 17

#define SCAN_BREAK 0xF0
#define SCAN_E0    0xE0
int clockValue = 0;
byte data;

#define bufferLength 32
byte buffer[bufferLength] = {
};      // This saves the characters (for now only numbers)
byte bufferPos = 0;

byte breakActive = 0;


void setup() {
 pinMode(dataPin, INPUT);                                              
 pinMode(clockPin, INPUT);                                              
 pinMode(ledPin, OUTPUT);                                              
 Serial.begin(9600);                                                    
}

void loop() {
 data = dataRead();                                                

 if(data != SCAN_BREAK){
   buffer[bufferPos] = data;
   ++bufferPos;
 }          

 /*if(dataValue == SCAN_ENTER){                                          
              Serial.print("\nbuffer: ");                                          
              // Read the buffer                                                  
              int i=0;                                                                                                                                    
              if (buffer != 0) {                                                
                    while(buffer != 0) {                                            
                          Serial.print( buffer );                                      
                          buffer = 0;                                                  
                          i++;                                                            
                    }                                                                  
              }                                                                    
              Serial.println(" [Enter]");                                          
              bufferPos = 0;                                                      
              // Blink the LED                                                        
              digitalWrite(ledPin, HIGH);                                          
              delay(300);                                                          
              digitalWrite(ledPin, LOW);                                          
        }*/

 // Reset the SCAN_BREAK state if the byte was a normal one            
 if(data != SCAN_BREAK){                                          
   breakActive = 0;                                                    
 }                                                                      
 data = 0;                                                        
}

int dataRead() {
 byte val = 0;                                                          
 // Skip start state and start bit                                      
 while (digitalRead(clockPin));// Wait for LOW.                      
 // clock is high when idle                                            
 while (!digitalRead(clockPin)); // Wait for HIGH.                      
 while (digitalRead(clockPin));  // Wait for LOW.                      
 for (int offset = 0; offset < 8; offset++) {                          
   while (digitalRead(clockPin));         // Wait for LOW              
   val |= digitalRead(dataPin) << offset; // Add to byte                
   while (!digitalRead(clockPin));        // Wait for HIGH              
 }                                                                      
 // Skipping parity and stop bits down here.                            
 while (digitalRead(clockPin));           // Wait for LOW.              
 while (!digitalRead(clockPin));          // Wait for HIGH.            
 while (digitalRead(clockPin));           // Wait for LOW.              
 while (!digitalRead(clockPin));          // Wait for HIGH.            
 return val;                                                            
}

char[] scan2char ( byte pos ){
 if ( buffer[pos] == 0x0 ) {
   return "";
 }  
 if ( buffer[pos] == SCAN_E0 ){
   byte tmp = buffer[pos+1];
   for( byte i=0; i<scancode2count; ++i){
     if( tmp == scancode3 ){
       return scancode2
     }  
   }
 }
 else {
   return scancode1[buffer[pos]];    
 }

}

           

M.Psyco

Bon, c'est résolue, mais je n'ai pas trouvé le c'était quoi le problème.
J'ai juste enlevé plein de chose au fur et à mesure jusqu'à ce qu'il me donne plus d'erreur, puis j'ai refait le stricte minimum.
voici le code maintenant pour ceux que ça interresse:

#define SCAN_BREAK 0xF0
int clockValue = 0;
byte data;

#define bufferLength 32
byte buffer[bufferLength] = {};
byte bufferPos = 0;
byte breakActive=0;

#define dataPin 5
#define clockPin 3
#define ledPin 13

char* scancode1[] = { "[ERROR]",
 "[F9]",  "N/C",  "[F5]",  "[F3]",  "[F1]",  "[F2]",  "[F12]",  "[N/C]",
 "[F10]", "[F8]", "[F6]",  "[F4]",  "[TAB]", "#", "[N/C]",  "[N/C]",
 "[L ALT]",  "[L SHIFT]",  "[N/C]",  "[L CTRL]",  "Q",  "1",  "[N/C]",  "[N/C]",
 "[N/C]",   "Z",  "S",  "A",  "W",  "2",  "[N/C]",  "[N/C]",  
 "C",       "X",  "D",  "E",  "4",  "3",  "[N/C]",  "[N/C]",  
 "[SPACE]", "V",  "F",  "T",  "R",  "5",  "[N/C]",  "[N/C]",  
 "N", "B",  "H",  "G",  "Y",  "6",  "[N/C]",  "[N/C]",  
 "[N/C]",  "M",  "J",  "U",  "7",  "8",  "[N/C]",  ",",  

 "[N/C]",  "K",  "I",  "0",  "0",  "9",  "[N/C]",  "[N/C]",  
 ".",  "/",  "L",  ";",  "P",  "-",  "[N/C]",  "[N/C]",  
 "[N/C]",  "`",  "[N/C]",  "[",  "=",  "[N/C]",  "[N/C]",  "[CAPS]",  
 "[R SHIFT]",  "[ENTER]",  "]",  "[N/C]",  "\\",  "[N/C]",  "[N/C]",  "[N/C]",  
 "[N/C]",  "[N/C]",  "[N/C]",  "[N/C]",  "[N/C]",  "[BKSP]",  "[N/C]",  "[N/C]",

 "[KP 1]","[N/C]",  "[KP 4]",  "[KP 7]",  "[N/C]",  "[N/C]",  "[N/C]",  "[KP 0]",  
 "[KP .]",  "[KP 0]",  "[KP 5]",  "[KP 6]",  "[KP 8]",  "[ESC]",  "[NUM]",  "[F11]",  
 "[KP +]",  "[KP 3]",  "[KP -]",  "[KP *]",  "[KP 9]",  "[SCROLL]",  "[N/C]",  "[N/C]",  
 "[N/C]",  "[N/C]",  "[F7]" };

void setup() {
 pinMode(dataPin, INPUT);                                              
 pinMode(clockPin, INPUT);                                              
 pinMode(ledPin, OUTPUT);                                              
 Serial.begin(9600);                                                    
}

void loop() {
 data = dataRead();  

 if( !breakActive ){
   if(data != SCAN_BREAK){
     buffer[bufferPos] = data;
     ++bufferPos;
     if( data != 0xE0 ){
       Serial.print(scancode1[data]);
     }
   } else {
       breakActive=1;
   }
 }
 
 if( breakActive && data != SCAN_BREAK ){
   breakActive = 0;  
 }
 data = 0;                                                        
}

int dataRead() {
 byte val = 0;                                                          
 // Skip start state and start bit                                      
 while (digitalRead(clockPin));// Wait for LOW.                      
 // clock is high when idle                                            
 while (!digitalRead(clockPin)); // Wait for HIGH.                      
 while (digitalRead(clockPin));  // Wait for LOW.                      
 for (int offset = 0; offset < 8; offset++) {                          
   while (digitalRead(clockPin));         // Wait for LOW              
   val |= digitalRead(dataPin) << offset; // Add to byte                
   while (!digitalRead(clockPin));        // Wait for HIGH              
 }                                                                      
 // Skipping parity and stop bits down here.                            
 while (digitalRead(clockPin));           // Wait for LOW.              
 while (!digitalRead(clockPin));          // Wait for HIGH.            
 while (digitalRead(clockPin));           // Wait for LOW.              
 while (!digitalRead(clockPin));          // Wait for HIGH.            
 return val;                                                            
}

mikalhart

Bonjour M.Psyco!  Je ne parle pas bien Français.  Desolée!

L'Arduino IDE n'aime pas les fonctionnes comme ça:

Code: [Select]
char [] scan2char (byte pos)

Voici:

Code: [Select]
char * scan2char (byte pos)

C'est la meme chose.

regards,

Mikal

M.Psyco

#3
Oct 15, 2008, 03:06 am Last Edit: Oct 15, 2008, 03:36 am by M.Psyco Reason: 1
Merci bien d'avoir répondu, mais je n'ai pas garder cette fonction dans le code final.

De plus, en c/c++  ceci:  []  est exactement la même chose que : *.

Quand tu crés un tableau, tu alloue X * (taille du type de variable) byte.
Par ex:  char[100] allouera 100 byte puisque un char c'est un byte (il est seulement interprété comme une lettre en général).

Deuxièmement, quand tu écris x[0] ça revient à écrire *x, puisque x[0] représente le début du tableau dans la mémoire (x représente l'adresse du début du tableau... )

Espérant que je ne t'ai pas mélangé plus qu'autre chose  :D.

EDIT: j'avais pas lu que tu avait des difficultés en français.
Tu peux me parler en anglais au pire.

Et ce n'est pas "fonctionne", c'est "fonction"  ;)

mikalhart

#4
Oct 15, 2008, 05:43 am Last Edit: Oct 15, 2008, 05:44 am by mikalhart Reason: 1
Je refuse de parler en anglais ici, entonces ma femme m'aide avec ce reponse.  :D

Je comprens bien que [] est exactement la même chose que *.  Je suis professeur de C++!  Le problème est que chaque programme d'Arduino est lancé par un programme qui produit des prototypes de fonction, et ce processus a des problèmes avec des déclarations de fonction complexe comme le "char [] f();"  Voici <http://www.arduino.cc/en/Guide/Troubleshooting>, "The Arduino environment attempts to automatically generate prototypes for your functions, so that you can order them as you like in your sketch. This process, however, isn't perfect, and sometimes leads to obscure error messages."


Votre code C++ était parfaitement bon, mais il ne compilera pas toujours dans l'environnement d'Arduino !
Bonne nuit!

Mikal (et Tina) :)

M.Psyco

Si j'avais su que tu étais professeur de C++, je n'aurais même pas pris la peine de tout expliquer cela!!!  :P

C'est vrai qu'il y a quelque problème "d'incompréhension de syntaxe", qui ne devrais pas avoir lieu (selon les standard).

Par exemple, au début j'avais écrit
char** scancode1 = { ... };

Mais Processing ne le le prenait pas, j'ai été obligé de l'écrire like this:
char* scancode1[] = { ... };

Alors que les deux syntaxe aurais dû être bonne et techniquement pareil.




Aurais-tu d'autre information là-dessus, des sites et autres. Pour l'instant je n'ai pas le temps de chercher et je te serais très reconnaissant de m'aider.

Il serait bon que je connaisse les limite du arduino et du compilateur qui vient avec avant de l'utiliser pour tout  ;D

mikalhart

Ah, mais dans C++ il est illégal de définir un tableau comme ceci

char ** scancodes = {"Error", "F9"};

Ceci ne fonctionnera avec AUCUN compilateur de C++.  Vous devez définir le tableau avec []:

char *scancodes[] = {"Error", "F9"};

J'ai pu avoir mal compris certains de vos commentaires postérieurs.

Mikal

Go Up