Revision 6:32eb30d2410f, committed 2020-04-06

Comitter:

AlexisCollin

Date:

Mon Apr 06 15:11:29 2020 +0000

Parent:

5:1cfb8cd47e6d

Commit message:

Code final pour la carte de controle du SOMO II

Changed in this revision

--- a/SOMO.cpp	Wed Feb 26 16:23:48 2020 +0000
+++ b/SOMO.cpp	Mon Apr 06 15:11:29 2020 +0000
@@ -3,8 +3,8 @@
 #include "mbed.h"
 #include "SOMO.h"
 #include "CAN.h"
-#define CHKSUM 0xFFFF
-#define myID 0x261
+#define CHKSUM 0xFFFF               // CHKSUM par défaut
+//#define myID 0x4A0                  // id de départ du can en accord avec la librairie du CRAC
 
 Ticker ticker;
 CAN can(PA_11, PA_12);
@@ -13,14 +13,16 @@
 
 
 
-bool sendflag = 0;
-int data_can = 0;
-char commande = 0;
-char message1 = 0;
-char message2 = 0;
-int calc_chksum;
-char chksum[2]={0,0};
-unsigned char is_busy = 0x00;
+bool sendflag = 0;                  // flag permettant de réguler la communication de la carte par le can
+int data_can = 0;                   // variable qui récupère l'ensemble des informations reçues
+short commande = 0;                  // variable récupérant le premier octet de la partie DATA sur le can
+char message1 = 0;                  // variable récupérant le second octet de la partie DATA sur le can
+char message2 = 0;                  // variable récupérant le troisième octet de la partie DATA sur le can
+int calc_chksum;                    // variable qui récupère la valeur du chksum une fois ce dernier calculer
+char chksum[2]={0,0};               // tableau venant splitter en deux char les deux octets de chksum
+unsigned char is_busy = 0x00;       // état de la carte
+char tab_ident[3];
+short myID = 0x4A0;
         
 //construction
 SOMO::SOMO(PinName TXPin, PinName RXPin): _serialSOMO(TXPin,RXPin)
@@ -29,7 +31,7 @@
 }
 
 
-void SOMO::init()                               //configure mbed pour la SOMO-II   
+void SOMO::init()                               //configure la liaison avec le SOMO-II et le CAN 
 {
     _serialSOMO.baud(9600);
     can.frequency(1000000);
@@ -38,20 +40,21 @@
     can.filter(0x261, 0x261, CANAny, 0);
 }
 
-void SOMO::playTrackName(char name[])           //Permet de jouer une musique via son nom
-{          
-}
+/*
+les fichiers mp3 doivent commencer par 001 jusqu'a 254
+Les nom des dossier de repertoir pour le musique doivent être nommées par un nombre entre 01 et 99
+*/
+
+// **************************************************************************************************
+// Joue une musique via son numéro et son répertoire
 
-/*
-les fichiers mp3 doivent commencer par 001 jusqu'a 254 et ne doivent pas contenir plus de 5 lettres.
-The filenames should start with number between 001 and 099 
-followed by up to 5 characters (the freakin' datasheet says up to 32 characters, don't listen to it, it's a liar and a con artist!)
-exemple : root/01/001left.mp3, root/01/002right.mp3, root/01/099abcde.mp3
-*/
-void SOMO::playTrackNum(unsigned char repository, unsigned char track)    //Joue une musique via son identifiant
+void SOMO::playTrackNum(unsigned char repository, unsigned char track)    
 {  
-    calc_chksum=CHKSUM-(0x19+0x01)+1;
-    chksum[0]=0xFF&(calc_chksum>>8);
+    // calcule du CHKSUM
+    calc_chksum=CHKSUM-(0x19+0x01)+1;           
+    
+    // séparation des deux octets du chksum pour l'envois
+    chksum[0]=0xFF&(calc_chksum>>8);            
     chksum[1]=0xFF&(calc_chksum);
     unsigned char play2[8] = {0x7E, 0x19, 0x00, 0x00, 0x01, chksum[0], chksum[1], 0xEF}; 
     for (int i = 0; i <8; i++)
@@ -70,29 +73,50 @@
     wait(0.2);
 }
 
-void SOMO::start()    //Joue une musique via son identifiant
+// **************************************************************************************************
+// fonction de démarrage permettant l'émission d'un son au démarrage 
+// de la carte pour avertir de sa mise sous tension
+
+void SOMO::start()    
 {  
+    // calcule du CHKSUM
     calc_chksum=CHKSUM-(0x19+0x01)+1;
+    
+    // séparation des deux octets du chksum pour l'envois
     chksum[0]=0xFF&(calc_chksum>>8);
     chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
     unsigned char play2[8] = {0x7E, 0x19, 0x00, 0x00, 0x01, chksum[0], chksum[1], 0xEF}; 
     for (int i = 0; i <8; i++)
     {
         _serialSOMO.putc(play2[i]); 
     }
     wait(0.2);
+    
+    // calcule du CHKSUM
     calc_chksum=CHKSUM-(0x0F+0x63+0x01)+1;
+    
+    // séparation des deux octets du chksum pour l'envois
     chksum[0]=0xFF&(calc_chksum>>8);
     chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
     unsigned char play1[8] = {0x7E, 0x0F, 0x00, 0x63, 0x01, chksum[0], chksum[1], 0xEF}; 
     for (int i = 0; i <8; i++)
     {
         _serialSOMO.putc(play1[i]); 
     }
     wait(0.2);
+    
+    // calcule du CHKSUM
     calc_chksum=CHKSUM-(0x0D)+1;
+    
+    // séparation des deux octets du chksum pour l'envois
     chksum[0]=0xFF&(calc_chksum>>8);
     chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
     unsigned char play3[8] = {0x7E, 0x0D, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF}; 
     for (int i = 0; i <8; i++)
     {
@@ -101,11 +125,19 @@
     wait(0.2);
 }
 
-void SOMO::stopTrack()                          //stop la lecture de n'importe quelle musique
+// **************************************************************************************************
+// stop la lecture de n'importe quelle musique
+
+void SOMO::stopTrack()                         
 { 
+    // calcule du CHKSUM
     calc_chksum=CHKSUM-(0x16)+1;
+    
+    // séparation des deux octets du chksum pour l'envois
     chksum[0]=0xFF&(calc_chksum>>8);
     chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
     unsigned char  stop[8] = {0x7E, 0x16, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF};
     for (int i = 0; i <8; i++)
     {
@@ -113,13 +145,21 @@
     }
 }
 
-void SOMO::volume(unsigned char vol)            //change le volume (de 0 a 30)
+// **************************************************************************************************
+// change le volume (de 0 a 30)
+
+void SOMO::volume(unsigned char vol)            
 {
     if (vol>0 && vol<31)
     {
+        // calcule du CHKSUM
         calc_chksum=CHKSUM-(0x06 + vol)+1;
+        
+        // séparation des deux octets du chksum pour l'envois
         chksum[0]=0xFF&(calc_chksum>>8);
         chksum[1]=0xFF&(calc_chksum);   
+        
+        // envois des octets sur la liaison série du SOMO-II
         unsigned char  changeVol[8] = {0x7E, 0x06, 0x00, 0x00, vol, chksum[0], chksum[1], 0xEF};         
         for (int i = 0; i <8; i++)
         {
@@ -128,8 +168,12 @@
     }
 }   
 
-void SOMO::reset()                              //reset le module
+// **************************************************************************************************
+// remise a zéro du module
+
+void SOMO::reset()                              
 {
+    // envois des octets sur la liaison série du SOMO-II
     unsigned char reset[8] = {0x7E, 0x0C, 0x00, 0x00, 0x00, 0xFF, 0xF4, 0xEF};
     for (int i = 0; i <8; i++)
     {
@@ -137,11 +181,17 @@
     }    
 }
 
+// **************************************************************************************************
+// Fonction pour jouer tout les sons de la carte en continus en prennant pour point de départ
+// le répertoire et la chansons données
+
 void SOMO::continuous(unsigned char repository, unsigned char track)
 {
     calc_chksum=CHKSUM-(0x0F+repository+track)+1;
     chksum[0]=0xFF&(calc_chksum>>8);
     chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
     unsigned char play1[8] = {0x7E, 0x0F, 0x00, repository, track, chksum[0], chksum[1], 0xEF}; 
     for (int i = 0; i <8; i++)
     {
@@ -151,6 +201,8 @@
     calc_chksum=CHKSUM-(0x11+0x01)+1;
     chksum[0]=0xFF&(calc_chksum>>8);
     chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
     unsigned char play2[8] = {0x7E, 0x11, 0x00, 0x00, 0x01, chksum[0], chksum[1], 0xEF}; 
     for (int i = 0; i <8; i++)
     {
@@ -160,6 +212,44 @@
     calc_chksum=CHKSUM-(0x0D)+1;
     chksum[0]=0xFF&(calc_chksum>>8);
     chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
+    unsigned char  play[8] = {0x7E, 0x0D, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF}; 
+    for (int i = 0; i <8; i++)
+    {
+        _serialSOMO.putc(play[i]); 
+    }
+    wait(0.2);
+}
+
+// **************************************************************************************************
+// Mise en pause de la lecture
+
+void SOMO::pause()
+{
+    calc_chksum=CHKSUM-(0x0E)+1;
+    chksum[0]=0xFF&(calc_chksum>>8);
+    chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
+    unsigned char  play[8] = {0x7E, 0x0E, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF}; 
+    for (int i = 0; i <8; i++)
+    {
+        _serialSOMO.putc(play[i]); 
+    }
+    wait(0.2);
+}
+
+// **************************************************************************************************
+// Reprise de la lecture
+
+void SOMO::resume()
+{
+    calc_chksum=CHKSUM-(0x0D)+1;
+    chksum[0]=0xFF&(calc_chksum>>8);
+    chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
     unsigned char  play[8] = {0x7E, 0x0D, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF}; 
     for (int i = 0; i <8; i++)
     {
@@ -168,6 +258,121 @@
     wait(0.2);
 }
 
+// **************************************************************************************************
+// Réglage de l'equilizer
+
+void SOMO::set_EQ(unsigned char mod)
+{
+    calc_chksum=CHKSUM-(0x07+mod)+1;
+    chksum[0]=0xFF&(calc_chksum>>8);
+    chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
+    unsigned char  play[8] = {0x7E, 0x07, 0x00, 0x00, mod, chksum[0], chksum[1], 0xEF}; 
+    for (int i = 0; i <8; i++)
+    {
+        _serialSOMO.putc(play[i]); 
+    }
+    wait(0.2);
+}
+
+// **************************************************************************************************
+// Joue les piste aléatoirement
+
+void SOMO::play_random()
+{
+    calc_chksum=CHKSUM-(0x18)+1;
+    chksum[0]=0xFF&(calc_chksum>>8);
+    chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
+    unsigned char  play[8] = {0x7E, 0x18, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF}; 
+    for (int i = 0; i <8; i++)
+    {
+        _serialSOMO.putc(play[i]); 
+    }
+    wait(0.2);
+    calc_chksum=CHKSUM-(0x0D)+1;
+    chksum[0]=0xFF&(calc_chksum>>8);
+    chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
+    unsigned char  play1[8] = {0x7E, 0x0D, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF}; 
+    for (int i = 0; i <8; i++)
+    {
+        _serialSOMO.putc(play1[i]); 
+    }
+    wait(0.2);
+}
+
+// **************************************************************************************************
+// Joue la piste suivante de la liste
+
+void SOMO::next()
+{
+    calc_chksum=CHKSUM-(0x01)+1;
+    chksum[0]=0xFF&(calc_chksum>>8);
+    chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
+    unsigned char  play1[8] = {0x7E, 0x01, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF}; 
+    for (int i = 0; i <8; i++)
+    {
+        _serialSOMO.putc(play1[i]); 
+    }
+    wait(0.2);
+}
+
+// **************************************************************************************************
+// Joue la pise précédante de la liste
+
+void SOMO::previous()
+{
+    calc_chksum=CHKSUM-(0x02)+1;
+    chksum[0]=0xFF&(calc_chksum>>8);
+    chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
+    unsigned char  play1[8] = {0x7E, 0x02, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF}; 
+    for (int i = 0; i <8; i++)
+    {
+        _serialSOMO.putc(play1[i]); 
+    }
+    wait(0.2);
+}
+
+// **************************************************************************************************
+// Lecture en boucle de la dernière piste jouée
+
+void SOMO::repeat()
+{
+    calc_chksum=CHKSUM-(0x0D)+1;
+    chksum[0]=0xFF&(calc_chksum>>8);
+    chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
+    unsigned char  play[8] = {0x7E, 0x0D, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF}; 
+    for (int i = 0; i <8; i++)
+    {
+        _serialSOMO.putc(play[i]); 
+    }
+    wait(0.2);
+    calc_chksum=CHKSUM-(0x19)+1;
+    chksum[0]=0xFF&(calc_chksum>>8);
+    chksum[1]=0xFF&(calc_chksum);
+    
+    // envois des octets sur la liaison série du SOMO-II
+    unsigned char  play1[8] = {0x7E, 0x19, 0x00, 0x00, 0x00, chksum[0], chksum[1], 0xEF}; 
+    for (int i = 0; i <8; i++)
+    {
+        _serialSOMO.putc(play1[i]); 
+    }
+    wait(0.2);
+}
+
+// **************************************************************************************************
+// Fonction pour l'envois de message sur le can
+
 void Sender::send()
 {
     if(sendflag==1)
@@ -175,46 +380,41 @@
         char data_can_sender = is_busy;
         if(can.write(CANMessage(myID, reinterpret_cast<char*>(&data_can_sender), (sizeof(data_can_sender))))) 
         {
+            // mise a 0 du flag d'envois pour éviter les envois en boucle
             sendflag = 0;
         }
     }
 }
 
+// **************************************************************************************************
+// Fonction pour l'aquisition de message sur le can
+
 int comm()
 {
+    // Vérification de la réception d'un message
     if(can.read(msg)) 
     {
-        if(msg.id == 0x261)
+        commande = msg.id;
+        if((msg.id > 0x4A0) && (msg.id < 0x4AD))
         {
-            commande = msg.data[0];
-            message1 = msg.data[1];
-            message2 = msg.data[2];
-            data_can = (message2<<16)+(message1<<8)+(commande);
-            sendflag = 1;
-            if(((data_can)&0xFF)!=0x03)
+            // aquisition des données
+            if(msg.data[0]!=NULL)
             {
-                if(((data_can)&0xFF)!=0x02)
+                message1 = msg.data[0];
+                if(msg.data[1]!=NULL)
                 {
-                    if(((data_can)&0xFF)==0x01 || ((data_can)&0xFF)==0x04)
-                    {
-                        is_busy=0x01;
-                    }
-                    sender.send();
+                    message2 = msg.data[1];
                 }
             }
-            else sendflag = 0;
-            data_can = 0xFFFFFFFF & ((data_can << 8) + 0x01);
-            wait_ms(0.2);
+                
+            // regroupement des données sur un int qui sera renvoyer en fin de fonction
         }
-        else 
-        {
-            sendflag=0;
-            data_can = 0x00000000;
-        }
+        data_can = (message1)+(message2 << 8)+(commande << 16);
+        sendflag = 0;
     }
     else
     {
-        data_can = 0x00000000
+        data_can = data_can & 0x0000FFFF;
     }
     if(can.rderror() || can.tderror())
     {
@@ -224,9 +424,19 @@
     return data_can;
 }
 
+// **************************************************************************************************
+// changement de l'état de la carte et mise a 1 du flag d'envois pour transmettre cet état sur le CAN
+
 void not_busy()
 {
     is_busy = 0x00;
     sendflag=1;
     sender.send();
+}
+
+void busy()
+{
+    is_busy = 0x01;
+    sendflag=1;
+    sender.send();
 }
\ No newline at end of file

--- a/SOMO.h	Wed Feb 26 16:23:48 2020 +0000
+++ b/SOMO.h	Mon Apr 06 15:11:29 2020 +0000
@@ -7,8 +7,8 @@
 #include <mbed.h>
 
 //**************************************************************************
-// class SOMO SOMO.h
-// classe principale. exemple d'utilisation : SOMO audio(p13,p14);
+// class sender
+// classe servant pour le CAN contenant une fonction pour l'envois de données
 
 class Sender
 {
@@ -27,6 +27,10 @@
     
 };
 
+//**************************************************************************
+// class SOMO SOMO.h
+// classe principale. exemple d'utilisation : SOMO audio(p13,p14);
+
 class SOMO
 {
     
@@ -36,8 +40,6 @@
     
         void init();
     
-        void playTrackName(char[]); 
-    
         void playTrackNum(unsigned char, unsigned char);
         
         void start();
@@ -48,7 +50,21 @@
     
         void reset(); 
         
-        void continuous(unsigned char, unsigned char);      
+        void continuous(unsigned char, unsigned char);  
+        
+        void pause();
+        
+        void resume();
+        
+        void set_EQ(unsigned char);
+        
+        void play_random();
+        
+        void next();
+        
+        void previous();
+        
+        void repeat();
     
     
     protected :
@@ -57,8 +73,14 @@
     
 };
 
+//**************************************************************************
+// fonctions globales pour l'aquisition d'un message sur le can et l'envois
+// de l'état actuel de la carte (occupé ou non) par le bus can
+
 int comm(void);
 
 void not_busy(void);
 
+void busy(void);
+
 #endif