Problème Arduino

International Français
1

Bonjour,
Je suis professeur de STI2D SIN, et je travaille en ce moment sur un TP, dans lequel mes élèves devront entrer une chaîne de caractère en morse via le moniteur série et il devra en ressortir la traduction dans le moniteur série en caractères alphanumériques.
Sauf que j'ai bien avancé dans mon code, mais j'ai pu faire un programme qui traduit les caractères alphanumériques en morse mais je n'arrive pas a faire l'inverse.
Pourriez vous m'aider, et si possible en reprenant ma présentation ?
Merci d'avance,
Didier

/*
 ********************************************************************
 * NOM			: morse.ino                                             *
 * TYPE			: APPLICATION                                           *
 * SUJET		: Traduire le code morse en caratère alphanumérique     *
 * AUTEUR 		:                                                     *
 * VERSION		: 1.0                                                 *
 * CREATION		: 2016                                                *
 * FABRICATION	: arduino                                           *
 ********************************************************************
*/

#include <stdio.h>

/*
************************************************************************
*                         CONSTANTES                                   *
************************************************************************
*/

#define MAX_ENTREE     39
#define MAX_MORSE 	    8
#define BLANC     	  ' '
#define CAR_DEFAUT	  '?'
#define IDEM			      0
#define FAUX			      1
#define EOM				    '@'

/*
************************************************************************
*                           PROTOTYPES                                 *
************************************************************************
*/
void setup();
void loop();
//int  Compare(char[],char[][MAX_MORSE],int);
void LireCodeMorse(char []);
char DecoderCodeMorse(char []);
void AfficherCode(char);

/*
************************************************************************
* initialisation de la liaison série                                   *
* Paramètre en E/S : aucun                                             *
* paramètres : aucun                                                   *
* retour : sans                                                        *
************************************************************************
*/
void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  while (!Serial) {
  // wait for serial port to connect. 
  }
  Serial.println("\nfin setup \n");
}


/*
************************************************************************
*                      PROGRAMME PRINCIPAL                             *
* Paramètre en E/S : aucun                                             *
************************************************************************
*/

void loop()
{
 char MorseClair;
 char CodeMorse[MAX_MORSE];

 Serial.println("debut programme principal\n");

LireCodeMorse(CodeMorse);            //Appel de la fonction LireCodeMorse avec commme paramètre CodeMorse
MorseClair=DecoderCodeMorse(CodeMorse);    //Affectation de MorseClair a la fonction DecoderCodeMorse
AfficherCode(MorseClair);                  //Affichage de MorseCla
while (MorseClair=EOM);          //Tant que MorseClair = EOM, ne rien fair
// traduction algorithme en C du programme principal ICI


 
 Serial.println("\t\t** fin du texte - programme principal terminé **");
 // do nothing while true:
 while (true); 
}

/*
************************************************************************
* Nom :                 LireCodeMorse                                  *
* Description :         Lit le code morse et le range dans un tableau  *
* Paramètre en sortie : Tableau de caractères                          *
* Nom de la sortie    :    CodeMorse[]                                 *
************************************************************************
*/
void AfficherCode(char morseAlpha)
{
if(morseAlpha != EOM) {
  Serial.print("  traduction : ");
  Serial.println(morseAlpha);
  }
}


/*
************************************************************************
* Nom :                 LireCodeMorse                                  *
* Description :         Lit le code morse et le range dans un tableau  *
* Paramètre en sortie : Tableau de caractères                          *
* Nom de la sortie    :    CodeMorse[]                                 *
************************************************************************
*/

void LireCodeMorse(char CodeMorse[])
{
 int  iCpt = 0, jCpt;
 char Car;
 do
	{
          int indice = 0;
         Car =Serial.read();
           if (Car =='.' || Car== '-' || Car == ' ')
           {
            CodeMorse[indice++]=Car;
             
           }
   	}
 while ((Car != BLANC)&&(iCpt<MAX_MORSE-1));

 // complement avec des caractères blancs pour comparaison
 for(jCpt = iCpt ; jCpt < MAX_MORSE ; jCpt++)
	 CodeMorse[jCpt] = BLANC;
}


/*
************************************************************************
* Nom :                 DecoderCodeMorse                               *
* Description :         Traduit le morse en caractére ASCII            *
* Paramétre en entrée : Tableau de caractères                          *
* Retour : 			    		Caractère                                      *
* Nom de l'entrée :     tabEntreeDecoder[]                             *
************************************************************************
*/

char DecoderCodeMorse(char tabEntreeDecoder[])
{
 int  iCpt=0, iComp;
 char CarDecoder;

 char TABMORSE[MAX_ENTREE][MAX_MORSE]={{'.','-',' ',' ',' ',' ',' ',' '},
	  {'-','.','.','.',' ',' ',' ',' '},{'-','.','-','.',' ',' ',' ',' '},
	  {'-','.','.',' ',' ',' ',' ',' '},{'.',' ',' ',' ',' ',' ',' ',' '},
	  {'.','.','-','.',' ',' ',' ',' '},{'-','-','.',' ',' ',' ',' ',' '},
	  {'.','.','.','.',' ',' ',' ',' '},{'.','.',' ',' ',' ',' ',' ',' '},
	  {'.','-','-','-',' ',' ',' ',' '},{'-','.','-',' ',' ',' ',' ',' '},
	  {'.','-','.','.',' ',' ',' ',' '},{'-','-',' ',' ',' ',' ',' ',' '},
	  {'-','.',' ',' ',' ',' ',' ',' '},{'-','-','-',' ',' ',' ',' ',' '},
	  {'.','-','-','.',' ',' ',' ',' '},{'-','-','.','-',' ',' ',' ',' '},
	  {'.','-','.',' ',' ',' ',' ',' '},{'.','.','.',' ',' ',' ',' ',' '},
	  {'-',' ',' ',' ',' ',' ',' ',' '},{'.','.','-',' ',' ',' ',' ',' '},
	  {'.','.','.','-',' ',' ',' ',' '},{'.','-','-',' ',' ',' ',' ',' '},
	  {'-','.','.','-',' ',' ',' ',' '},{'-','.','-','-',' ',' ',' ',' '},
	  {'-','-','.','.',' ',' ',' ',' '},{' ',' ',' ',' ',' ',' ',' ',' '},
	  {'.','-','.','-','.',' ',' ',' '},{'.','-','.','-','.','-',' ',' '},
	  {'-','-','-','-','-',' ',' ',' '},{'.','-','-','-','-',' ',' ',' '},
	  {'.','.','-','-','-',' ',' ',' '},{'.','.','.','-','-',' ',' ',' '},
	  {'.','.','.','.','-',' ',' ',' '},{'.','.','.','.','.',' ',' ',' '},
	  {'-','.','.','.','.',' ',' ',' '},{'-','-','.','.','.',' ',' ',' '},
	  {'-','-','-','.','.',' ',' ',' '},{'-','-','-','-','.',' ',' ',' '}};

 char TABCLAIR[MAX_ENTREE]={'A','B','C','D','E','F','G','H','I','J',
									          'K','L','M','N','O','P','Q','R','S','T',
								          	'U','V','W','X','Y','Z',' ',EOM,'.','0',
									          '1','2','3','4','5','6','7','8','9'};

 // EOM = .-.-.  code morse de fin de saisie

 do
	{
Compare();
// appel ici de la fonction compare


	}
 while(iComp != IDEM && iCpt < MAX_ENTREE);

 if(iComp == IDEM) CarDecoder = TABCLAIR[iCpt-1];
 else		           CarDecoder = CAR_DEFAUT;

 return( CarDecoder );
}


/*
************************************************************************
* Nom :                 Compare                                        *
* Description :         Compare deux tableaux de caractères            *
* Paramétre en entrée : Tableaux de caractères,entier                  *
* Retour : 					    entier                                         *
* Nom des entrées :     tabEntree[],tabCode[][MAX_MORSE],iVal          *
************************************************************************
*/

boolean Compare(char tabEntree[],char tabCode[][MAX_MORSE], int iVal)
{
  int i;
  boolean retour;
  retour = true;
  for(i=0;i<MAX_MORSE;i++)
  {
    if (tabEntree[i]!= tabCode[iVal][i])
    {
      return(false);
    }
    Serial.write(retour);
return(true);  
}
}
2

Dans LireCodeMorse() iCpt n'est pas utilisé dans la boucle do...while c'est indice qui est utilisé à la place.
Du coup, en sortant du do..while iCpt vaut toujours 0 et la boucle for qui suit remplit le tableau de BLANC.

3

J'ai mis dans la boucle iCpt=iCpt +1 mais je me retrouve avec une erreur " too few arguments to function 'boolean Compare(char*, char (*)[8], int)' "

4

Vous êtes vraiment le prof ou vous êtes un élève??

(est-ce lié à ce post? - à titre de curiosité intellectuelle je me suis amusé à faire un bout de code qui va bien pour décoder mais je ne l'ai pas posté car je ne veux pas aider des élèves à tricher sans apprendre)

5

DidierSTI2D:
J'ai mis dans la boucle iCpt=iCpt +1 mais je me retrouve avec une erreur " too few arguments to function 'boolean Compare(char*, char (*)[8], int)' "

Pas surprenant puisque tu appelles Compare() sans arguments. D'ailleurs dans le message d'erreur, il y a même le numéro de la ligne où est situé le problème ce sera facile de la trouver. Entre nous, le message d'erreur sortait déjà avant avec le code originale.

6

Quelques commentaires:

dans la lecture des entrées, la bonne pratique avant d'appeler read c'est de regarder s'il y a quelque chose de disponible à lire avec Serial.available(). sinon le Serial.read() retourne -1 mais comme vous stockez cela dans un char vous perdez l'information que c'était -1 et ne pouvez pas différencier avec la caractère ASCII étendu 0xFF.

Comme mentionné plus haut vous testez dans le do/while (iCpt < MAX_MORSE - 1) mais iCpt n'est pas maintenu à jour.

allouer à chaque passage de la boucle le tableau de code morse et de l'alphabet sur la pile n'est pas une super idée. autant les déclarer en global une fois pour toutes ou alors en static dans la fonction.

remplir avec des blancs pour la comparaison, c'est pas non plus optimal pour la mémoire. si vous déclariez un tableau de chaîne de caractères genre

const char * morsecode[] = {
  "-----",  // 0
  ".----",  // 1
  "..---",  // 2
  "...--",  // 3
  "....-",  // 4
  ".....",  // 5
  "-....",  // 6
// etc

alors vous auriez un '\0' marquant la fin d'un token morse pour la comparaison.

la fonction compare() est appelée sans paramètres... dans cette fonction vous avez un boolean retour; qui n'est pas vraiment utilisé

la fonction LireCodeMorse et DecoderCodeMorse prennent un paramètre mais c'est une variable globale... autant ne pas s'embêter à la passer en paramètre (ou alors ne pas la rendre globale)

7

Autre remarque, si vous êtes le prof.
Une manière de décoder plus élégante et certainement plus intéressante serait d'utiliser un arbre (vu le nombre de symbole utilisés ce n'est pas très complexe). Cela permettrait de faire un décodage à la volée.

8

fdufnews:
Autre remarque, si vous êtes le prof.
Une manière de décoder plus élégante et certainement plus intéressante serait d'utiliser un arbre (vu le nombre de symbole utilisés ce n'est pas très complexe). Cela permettrait de faire un décodage à la volée.

oui c'est une méthode d'ailleurs d'apprentissage du décodage morse pour ceux qui ont une mémoire visuelle

836×362 20.5 KB