richard misi / Mbed 2 deprecated STM32F303-ESSAI-DS3231-16102018

Dependencies:   ds3231 mbed

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers objet.h Source File

objet.h

00001 
00002 #include <string>
00003 
00004 //1- Definition/ Constantes 
00005 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
00006 
00007 #define   wBUFFER        300                                                    // Processus principal/ Trame/ Profondeur MAX du buffer de donnees  (exprimé en caracteres)
00008 #define   wDTRAME          6                                                    // Processus principal/ Trame/ Nombre de donnees MAX par trame
00009 // Definition/ Constante/ Nombre d'objet Event MAX
00010 #define nbEVENTMAX        12
00011 
00012 // Definition/ Constante/ Nombre de LED  intégrées MAX
00013 #define nbLEDMAX          4                                                     // Carte/ nombre Max LED
00014 
00015 // Definition/ Constante/ Nombre de Moteurs MAX
00016 #define nbMOTORMAX        2 
00017 
00018 // Definition/ Constante/ Nombre de SERVO MAX
00019 #define nbSERVOMAX        2
00020 
00021 //Definition/ Parametrage/ GPS/ Parcours/ Nombre maximal de WP
00022 #define nbWPMAX         100                                                     // Parcours GPS/ Nombre de Way Point Maximum enregistrés
00023 
00024 //Definition/ Constante/ Nombre d'objet PID MAX
00025 #define nbPIDMAX         2        
00026                                              
00027 //Definition/ Constante/ Nombre d'objet commande.axe
00028 #define nbAXEMAX          2         
00029 
00030 //Definition/ Constante/ ojet PAD/ nb axe MAX et nb SW MAX
00031 #define padNBAXEMAX       2
00032 #define padNBSWMAX        4
00033                                             
00034 //Definition/ Constante/ Nombre Parametres MAX
00035 #define nbPARAMAX        11         
00036 
00037 
00038 // Definition/ Protocole/  Constantes/ Mode
00039 #define mSTB              0                                                     // Mode/ STANDBY
00040 #define mSTP              1                                                     // Mode/ STOP
00041 #define mMAN              2                                                     // Mode/ MANUAL
00042 #define mPA               4                                                     // Mode/ Pilote Automatique
00043 #define mWP               8                                                     // Mode/ Enregistrement WP
00044 #define mRAZ             64                                                     // Mode/ Remise à 0 des commandes   
00045 #define mCHG            128                                                     // Mode/ recharge Accumulateurs
00046 
00047 
00048 
00049 //2- Definition/ Type de donnees
00050 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
00051 
00052 //2.1- Definition/ Type/ global/ data/ objet GLOBAL
00053 typedef struct{
00054                bool fValid;                                                     // Validation module
00055                string designation;                                              // Identification produit
00056                string version;                                                  // Version produit (v.xx/yy , xx: annee, yy: semaine dans l'annee)
00057                bool   debug;                                                    // Activation du mode DEBUG
00058                int    nbLED;                                                    // Nombre LED integrées
00059                int    tBATT;                                                    // Batterie/ Structure Chimique 
00060                int    NbElement;                                                // Batterie/ Nombre Elements
00061                int    Dynmin;                                                   // Variables/ dynamique minimum
00062                int    DynMAX;                                                   // Variables/ dynamique MAXIMUM
00063                float  TSample;                                                  // Periode d'echantillonnage du processus (exprimée en secondes)
00064                int    TPWM;                                                     // periode PWM (exprimée en micro secondes)
00065                int    USBBaud;                                                  // UART sur USB BaudRate
00066                int    UART1Baud;                                                // UART 1 BaudRate
00067                int    UART2Baud;                                                // UART 2 BaudRate
00068                int    I2CBaud;                                                  // Frequence bus I2C
00069                int    CANBaud;                                                  // Frequence bus CAN
00070                struct{                                                          // Event
00071                      bool fValid;                                              // Event/ Validité
00072                      bool fPeriode;                                             // Event/ Periodicité
00073                      int wdt;                                                   // Event/ WatchDog
00074                      int wdtMAX;                                                // Event/ WatchDog MAX
00075                      }event[nbEVENTMAX];                                                  
00076               } GLOBAL_t;
00077 
00078 
00079 //2.2- Definition/ Type/ objet TRAME 
00080 typedef struct{
00081                bool fValid;                                                     // Validation module
00082                int  wdtTX;                                                      // WatchDog Emission 
00083                int  wdtRX;                                                      // WatchDog Reception
00084                int  pcar;                                                       // Pointeur de caracteres
00085                char sb;                                                         // Protocole communication/ Start Beacon: 
00086                char dlb;                                                        // Protocole communication/ Delimiter Beacon
00087                char eb;                                                         // Protocole communication/ End Beacon
00088                int  id;                                                         // Mot identificateur de trame 
00089                char rx[wBUFFER];                                                // tableau des caracteres recus
00090                char tx[wBUFFER];                                                // tableau des caracteres envoyés
00091                bool fSB, fEB;                                                   // status startB et endB  
00092                int  c[wDTRAME];                                                 // Data Consigne
00093                int  r[wDTRAME];                                                 // Data Reponse
00094                int nbdata;                                                      // Nombre de Data sur la Trame
00095               } TRAME_t;
00096 
00097 
00098 
00099 //2.3- Definition/ Type/ objet COMMANDE
00100 typedef struct{
00101                struct{
00102                       bool    fValid;                                           // Validation Module
00103                       float   in;                                               // Variable Entree
00104                       float   out;                                              // Variable Sortie
00105                       float   dzm;                                              // Valeur Dead Zone inferieure (0..1)
00106                       float   dzM;                                              // Valeur Dead Zone supérieure (0..1)
00107                       float   cti;                                              // Valeur Constante de temps Integrale (0..1)
00108                       float   ctf;                                              // Valeur Constante de temps Proportionnelle  (0..1)
00109                       float   ctg;                                              // Valeur Constante de Temps Filtre de sortie
00110                       float   cgg;                                              // Valeur Gain Filtre de sortie
00111                       float     l;                                              // Valeur calcul loi non lineaire
00112                       float i, i0;                                              // Valeur calcul integral
00113                       float     p;                                              // Valeur calcul proportionnelle  
00114                       float     c;                                              // Valeur calcul proportionnelle - integrale   
00115                       float x, dx;                                              // Valeur filtre passe bas 
00116                      }axe[nbAXEMAX]; 
00117               } COMMANDE_t;
00118 
00119 
00120 
00121 
00122 
00123 //2.4- Definition/ Type/ objet MUX (multiplexeur)
00124 typedef struct{
00125                bool  fValid;                                                    // Validation Module
00126                float in0x, in0y, in1x, in1y, in2x, in2y,                              // Variables d'état d'entree  du module: variables d'entree
00127                      outx, outy;                                                    // Variables d'état de sortie du module: variables de sortie
00128                unsigned char sel;                                               // Variables d'état d'entree  du module: selection de la variable d'entrée
00129                unsigned char Status;                                            //  Variables Status du module s0:, s1:, s2:, s3:, s4:, s5:, s6:, s7: 
00130               }MUX_t; 
00131 
00132 
00133          
00134 //2.5- Definition/ Type/ objet ENERGIE
00135 typedef struct{ 
00136                bool fValid, fCHARGE, fVhigh, fVlow, fIhigh, fIlow, fFailed;
00137                unsigned char tBATT;                                             // Type de batterie (1: LEAD, 2: NIMH, 2: LION, 3: LIPO)   // Definition/ Parametres/ Type de batterie
00138                unsigned char NbElement;                                         // Nombre Element en Serie
00139                int seqPointer;                                                  // Sequenceur du processus de charge
00140                float tension, courant;                                          // Variables differentielles Energie, Tension, Courant Acquisition     
00141                float dE,dV,dI;                                                  // Variables differentielles Energie, Tension, Courant Filtrage
00142                float  E, E0, V, I;                                              // Variables Energie, Tension, Courant              
00143                float VMax, Vmin, IMax, Imin;                                    // Parametres internes   
00144                int wPWM, pPWM;                                                  // Largeur Impulsion, Periode PWM (chargeur)
00145                unsigned char     Status;                                        // Variables Status du module s0: fValid, s1: fCharge, s2:fVlow, s3:fVhigh, s4:fIlow, s5:fIhigh, s6: NA, s7: fFailed
00146               } ENERGY_t; 
00147        
00148        
00149 //2.6- Definition/ Type/ objet GPS
00150 typedef struct{
00151                 bool fValid, fLocked, fFailed;                                  // Validation Module, Trame Valide
00152                 int baud;                                                       // BaudRate
00153                 int TSample;                                                    // Periode rafraichissement des trames
00154                 int dop;                                                        // Variable Indice Dilution Satellites
00155                 double utc, lng, lat, hdg, spd;                                 // Variables: Temps Universel (UTC), Longitude (LNG), Latitude (LAT), Cap (HDG), Vitesse Air (SPD)
00156                 int speedmin;
00157                 unsigned char Status;                                           //Variables Status du module s0:fValid, s1:fLocked, s2:na, s3:na, s4:na, s5:na, s6:na, s7:fFailed
00158               } GPS_t; 
00159    
00160    
00161 //2.7- Definition/ Type/ objet IMU
00162 typedef struct{ 
00163                bool  fValid, fFailed;                                           // Validation module
00164                float roll, pitch, yaw, temp;                                    // Variables attitude; Roulis, Tangage, Lacet, Temperature
00165                float q0, q1, q2, q3;                                            // Variables attitude/ Quarternions
00166                float liax, liay, liaz;                                          // Variables acceleration lineaire x, y, z 
00167                float grvx, grvy, grvz;                                          // Variables gravité
00168                float gyrox, gyroy, gyroz;                                       // Variables gyroscopiques x, y, z
00169                float magx, magy, magz;                                          // Variables magnetometriques x, y, z
00170                unsigned char Status;                                            // Variables Status module.  s0:fValid, s1:fLocked, s2:na, s3:na, s4:na, s5:na, s6:na, s7:fFailed
00171               } IMU_t; 
00172     
00173                    
00174 //2.8- Definition/ Type/ objet PA (pilote automatique)
00175 typedef struct{ 
00176                bool fValid, fGPSLocked, fWPLocked, fDmin, fDMax, fFailed;
00177                double wLNG, wLAT,                                               // Variables d'état d'entree du module: Coordonnnees Consigne (WayPoint à rejoindre)
00178                       mLNG, mLAT;                                               // Variables d'état d'entree du module: Coordonnees reponse   (mesure GPS)
00179                float  mSPD,                                                     // Variables d'état d'entree du module: Vitesse (km/h)   (mesure GPS) 
00180                       mHDG,                                                     // Variables d'état d'entree du module: Cap     (deg)    (mesure GPS)
00181                       CtG,                                                      // Cap à suivre au WP  (calculé)
00182                       DtG,                                                      // Distance à parcourir au WP (calculée)
00183                       cPowerMax,                                                // Niveau de puissance Max (0 .. 1)
00184                       Dmin, DMax,                                               // Distance Max et minau WP 
00185                       Kp,                                                       // Correction/ Gain Proportionnel (exprimé en % 0..300)
00186                       outx, outy;                                               // Variables d'état de sortie du module
00187                unsigned char  Status;                                           // Variables Status du module s0: fValid, s1: fGPSLocked, s2: fWPLocked, s3:fDmin, s4:fDMax, s5: NA, s6: NA,s7: fFailed                    
00188               } PA_t; 
00189 
00190        
00191 //2.9- Definition/ Type/ objet DIGITAL (Accessoire)       
00192 typedef struct{ 
00193                bool fValid;                                                     // Validation Module
00194                unsigned int cDigital;                                           // Variables d'état d'entree du module  (c0: Klaxon, c1: Phare)
00195                unsigned int rDigital;                                           // Variables d'état de sortie du module (c0: Klaxon, c1: Phare)        
00196                unsigned char Status;                                            // Variable Status du module s0:, s1:, s2:, s3:, s4:, s5:, s6:, s7:
00197               }DIGITAL_t; 
00198 
00199 
00200 //2.10- Definition/ Type/ objet SERVO      
00201 typedef struct{ 
00202                bool fValid;                                                     // Validation Module
00203                int c;                                                           // Variables d'état d'entree  du module/ Variable (0 .. 1)
00204                float x, dx, tSERVO;                                             // Variables d'état Filtre  x, dx/ constante de temps du filtre
00205                int r;                                                           // Variables d'état de sortie du module/ Variable (0 .. 1)
00206                int pmin;                                                        // Constante/ valeur position minimum
00207                int pmax;                                                        // Constante/ valeur position maximum
00208                unsigned char Status;                                            // Variable Status du module s0:, s1:, s2:, s3:, s4:, s5:, s6:, s7:
00209               } SERVO_t; 
00210  
00211 //2.11- Definition/ Type/ objet LOI
00212  typedef struct{ 
00213                bool  fValid;                                                    // Validation Module
00214                float inx;                                                       // Variable/ Entree/ Power
00215                float iny;                                                       // Variable/ Entree/ Teta
00216                float outx;                                                      // Variable/ Sortie/ Gauche
00217                float outy;                                                      // Variable/ Sortie/ Droit
00218                unsigned char Status;                                            // Variable Status du module s0:, s1:, s2:, s3:, s4:, s5:, s6:, s7:
00219               } LAW_t; 
00220 
00221                      
00222        
00223 //2.12- Definition/ Type/ objet filtre PID
00224 typedef struct{  
00225                bool   fValid;                                                   // Filtre PID/ Validite
00226                 float inc;                                                      // Filtre PID/ Variable/ Consigne
00227                 float inr;                                                      // Filtre PID/ Variable/ FeedBack
00228                 float eM;                                                       // Filtre PID/ Variable/ Erreur (Consigne- Feedback)
00229                 float eMp;
00230                 float eMd; 
00231                 float eMd0;
00232                 float uMi;
00233                 float uMi0;
00234                 float uMd;
00235                 float uMd0;
00236                 float out;                                                      // Filtre PID/ Variable/ Sortie
00237                 float cPID1;                                                    // Filtre PID/ Constante/1/       
00238                 float cPID2;                                                    // Filtre PID/ Constante/2/       
00239                 float cPID3;                                                    // Filtre PID/ Constante/3/       
00240                 float cPID4;                                                    // Filtre PID/ Constante/4/       
00241                 float cPID5;                                                    // Filtre PID/ Constante/5/        
00242                 float cPID6;                                                    // Filtre PID/ Constante/6/
00243                 unsigned char Status;                                           // Filtre PID/ Variable Status du module s0:, s1:, s2:, s3:, s4:, s5:, s6:, s7:
00244               } PID_t;
00245  
00246                    
00247 //2.13- Definition/ Type/ objet MOTEUR
00248 typedef struct{
00249                 bool fValid;                                                    // Validite Module 
00250                 float in;                                                       // Variable d'état/ entrée/ puissance (0..1)
00251                 float dx, x;                                                    // Variables d'etat/ interne / Filtre Passe Bas
00252                 float out;                                                      // Variables d'état/ sortie / puissance (0.. 1)
00253                 float tMOTOR;                                                   // Constante de temps/ Filtre Passe Bas
00254                 float gMOTOR;                                                   // Constante/ Gain/ Filtre Passe Bas
00255                 unsigned char Status;                                           // Variable Status du module s0:, s1:, s2:, s3:, s4:, s5:, s6:, s7:
00256                 } MOTOR_t;
00257 
00258 
00259         
00260 //2.14- Definition/ Type/ objet TRACK
00261 typedef struct{ 
00262                bool fValid;                                                     // TRACK/ validite/ module
00263                bool fRecord;                                                    // TRACK/ Acquisition/ En cours
00264                int  nbWP;                                                       // TRACK/ nombre WP
00265                int  pWP;                                                        // TRACK/ pointeur WP
00266                struct{                                                          // TRACK/ structure WP
00267                       bool fValid;                                              // wp/ valide
00268                       double lat, lng;                                          // wp/ Coordonnees Geographiques 
00269                      }wp[nbWPMAX];
00270                int Status;                                                      // wp/ status
00271                } TRACK_t; 
00272     
00273     
00274     
00275 //2.15- Definition/ Type/ objet MOBILE             
00276 typedef struct{
00277                bool   fValid;                                                   // Mobile/ Validite 
00278                int    cWDTRX;                                                   // Mobile/ Contante/ WatchDog RX
00279                float  inx, iny, outx, outy;                                     // Mobile/ Commande: Niveau de puissance vectorielle: Amplidude/ Phase exprimé de 0 à 100%
00280                int    cMODE, rMODE;                                             // Mobile/ Mode de Fonctionnement
00281                double lng, lat, alt, speed, head;                               // Mobile/ Variables localisation (GPS)
00282                float  roll, pitch, yaw, altitude;                               // Mobile/ Variables attitude (IMU)
00283                int    Status;                                                      // Mobile/ Status Module 
00284               } MOBILE_t; 
00285  
00286  
00287 //2.16- Definition/ objet PAD
00288 typedef struct{
00289                bool  fValid;
00290                struct{
00291                       float   in;   // Variable Entree
00292                       float   out;  // Variable Sortie
00293                       int     scB;  // Pourcentage Proportionnal- Integral (0..100) sc=0: Commande Integrale pure .... sc= 100: Commande Proportionnelle pure   
00294                       int     dzB;  // Pourcentage Dead Zone (0..100)
00295                       int    znlB; // Pourcentage Zone Non Lineaire (0..100)
00296                       float  ctiB;  // Pourcentage Constante de temps loi integrale (0..100)
00297                       float  gainI; // Gain Integrale deuxieme zone lineaire 
00298                       float  ctfB;  // Pourcentage Constante de temps loi proportionnelle (0..100)
00299                       float    sc;  // Valeur Proportionnel Integral
00300                       float     dzm;  // Valeur Dead Zone inferieure
00301                       float     dzM;  // Valeur Dead Zone supérieure
00302                       float    znlm;  // Valeur Non Linearite inferieure
00303                       float    znlM;  // Valeur Non Linearite supérieure
00304                       float   cti;   // Valeur Constante de temps Integrale
00305                       float   ctf;  // Valeur Constante de temps Proportionnelle  
00306                       float     l;  // Valeur calcul loi non lineaire
00307                       float i, i0;  // Valeur calcul integral
00308                       float     p;  // Valeur calcul proportionnelle     
00309 //                     float fm[5];  // Valeur filtre moyenneur
00310                       float x, dX, X; // Valeur filtre passe bas          
00311                      }axe[padNBAXEMAX]; 
00312                struct{
00313                      bool   value; 
00314                      }sw[padNBSWMAX];
00315                      
00316 //               float roulis, tangage;      
00317 } PAD_t;