Olivier Nastorg / Mbed OS ARNSRS_testDFU

mbed-os github

Dependencies:   ADS1015 Faulhaber HTU21D_mod MS5837_potless Sensor_Head_RevB_3 USBDevice_dfu Utilsdfu beep

Fork of ARNSRS_testDFU by POTLESS

main.cpp@27:1b1fd20a2793, 2018-02-13 (annotated)

Committer:
POTLESS_2
Date:
Tue Feb 13 14:48:27 2018 +0000
Revision:
27:1b1fd20a2793
Parent:
26:a2fe19341f92
Child:
29:5b822d18bce6
suite

Who changed what in which revision?

UserRevisionLine numberNew contents of line
POTLESS_2 17:bef8abc445f2 1 /*
POTLESS_2 17:bef8abc445f2 2
POTLESS_2 17:bef8abc445f2 3 Câblage complet STM32L476RG :
POTLESS_2 17:bef8abc445f2 4
POTLESS_2 17:bef8abc445f2 5 - Port SPI carte SD :
POTLESS_2 17:bef8abc445f2 6
POTLESS_2 17:bef8abc445f2 7 MOSI -> PA_7
POTLESS_2 17:bef8abc445f2 8 MISO -> PA_6
POTLESS_2 17:bef8abc445f2 9 SCK -> PA_5
POTLESS_2 17:bef8abc445f2 10 CS -> PB_6
POTLESS_2 17:bef8abc445f2 11
POTLESS_2 17:bef8abc445f2 12 - Sensor Head :
POTLESS_2 17:bef8abc445f2 13
POTLESS_2 17:bef8abc445f2 14 Alim en 3.3v
POTLESS_2 17:bef8abc445f2 15
POTLESS_2 17:bef8abc445f2 16 SCL -> PB_8
POTLESS_2 17:bef8abc445f2 17 SDA -> PB_9
POTLESS_2 17:bef8abc445f2 18 TX -> PC_12
POTLESS_2 17:bef8abc445f2 19 RX -> PD_2
POTLESS_2 17:bef8abc445f2 20 AlertRdy -> PA_11
POTLESS_2 17:bef8abc445f2 21
POTLESS_2 17:bef8abc445f2 22
POTLESS_2 17:bef8abc445f2 23 - HC_06 :
POTLESS_2 17:bef8abc445f2 24
POTLESS_2 17:bef8abc445f2 25 Alim en 3.3v ou 5v
POTLESS_2 17:bef8abc445f2 26
POTLESS_2 17:bef8abc445f2 27 TX -> PC_10
POTLESS_2 17:bef8abc445f2 28 RX -> PC_11
POTLESS_2 17:bef8abc445f2 29
POTLESS_2 19:cac3761a5d0b 30 - STM32L476RG sur carte alim AQL :
POTLESS_2 17:bef8abc445f2 31
POTLESS_2 19:cac3761a5d0b 32 Reférence drv8839 : http://www.ti.com/lit/ds/symlink/drv8839.pdf
POTLESS_2 17:bef8abc445f2 33
POTLESS_2 19:cac3761a5d0b 34 Volet Fuite :
POTLESS_2 25:322ef9488e65 35 PWM -> PA_8 -> Jump_4 & Jump_5
POTLESS_2 25:322ef9488e65 36 FWD -> PB_4 -> Jump_2
POTLESS_2 25:322ef9488e65 37 REV -> PB_5 -> Jump_1
POTLESS_2 25:322ef9488e65 38 nSleep -> PC_5 -> Jump_3
POTLESS_2 25:322ef9488e65 39 Ch_A -> PB_9 -> Codeur1 2
POTLESS_2 25:322ef9488e65 40 Ch_B -> PB_8 -> Codeur1 1
POTLESS_2 17:bef8abc445f2 41
POTLESS_2 19:cac3761a5d0b 42 Volet Poumon :
POTLESS_2 25:322ef9488e65 43 PWM -> PB_1 -> Jump_4 & Jump_5
POTLESS_2 25:322ef9488e65 44 FWD -> PB_14 -> Jump_2
POTLESS_2 25:322ef9488e65 45 REV -> PB_13 -> Jump_1
POTLESS_2 25:322ef9488e65 46 nSleep -> PC_6 -> Jump_3
POTLESS_2 25:322ef9488e65 47 Ch_A -> PB_2 -> Codeur2 2
POTLESS_2 25:322ef9488e65 48 Ch_B -> PB_1 -> Codeur2 1
POTLESS_2 25:322ef9488e65 49
POTLESS_2 25:322ef9488e65 50 Test POWER :
POTLESS_2 25:322ef9488e65 51
POTLESS_2 25:322ef9488e65 52 V_usb -> PC_4 -> MCU 1
POTLESS_2 25:322ef9488e65 53 V_pile -> PA_10 -> MCU 2
POTLESS_2 17:bef8abc445f2 54
POTLESS_2 17:bef8abc445f2 55 */
POTLESS_2 18:bfd78c05b589 56
potless 1:bef7856b5c0a 57 #include "mbed.h"
potless 2:4a8bf1d53439 58 #include <string>
POTLESS_2 7:ad15c386e960 59 #include "Sensor_head_revB.h"
POTLESS_2 8:a750d531b381 60 #include "HTU21D.h"
POTLESS_2 12:7f3aadd79f89 61 #include "PID.h"
POTLESS_2 19:cac3761a5d0b 62 #include "Faulhaber.h"
POTLESS_2 4:d84250f67dec 63
POTLESS_2 17:bef8abc445f2 64 //Commandes des servos
POTLESS_2 19:cac3761a5d0b 65 #define PWM_SERVO_POUMON PB_15
POTLESS_2 19:cac3761a5d0b 66 #define nSleep_SERVO_POUMON PC_6
POTLESS_2 19:cac3761a5d0b 67 #define FWD_SERVO_POUMON PB_14
POTLESS_2 19:cac3761a5d0b 68 #define REV_SERVO_POUMON PB_13
POTLESS_2 19:cac3761a5d0b 69 #define Channel_A_SERVO_POUMON PB_1
POTLESS_2 19:cac3761a5d0b 70 #define Channel_B_SERVO_POUMON PB_2
POTLESS_2 19:cac3761a5d0b 71 #define HOME_SERVO_POUMON 0
POTLESS_2 17:bef8abc445f2 72
POTLESS_2 19:cac3761a5d0b 73 #define PWM_SERVO_FUITE PB_10
POTLESS_2 19:cac3761a5d0b 74 #define nSleep_SERVO_FUITE PC_5
POTLESS_2 19:cac3761a5d0b 75 #define FWD_SERVO_FUITE PB_4
POTLESS_2 19:cac3761a5d0b 76 #define REV_SERVO_FUITE PB_5
POTLESS_2 19:cac3761a5d0b 77 #define Channel_A_SERVO_FUITE PB_8
POTLESS_2 19:cac3761a5d0b 78 #define Channel_B_SERVO_FUITE PB_9
POTLESS_2 19:cac3761a5d0b 79 #define HOME_SERVO_FUITE 90
POTLESS_2 17:bef8abc445f2 80
POTLESS_2 17:bef8abc445f2 81 //Ecrit dans le moniteur série de la tablette à 115200 bds si sur 1, penser à mettre NEED_CONSOLE_OUTPUT à 0
POTLESS_2 9:04bfdfc029cb 82 #define NEED_ANDROID_OUTPUT 1
POTLESS_2 9:04bfdfc029cb 83
POTLESS_2 17:bef8abc445f2 84 //Mode PID, STD à commenter / décommenter
POTLESS_2 17:bef8abc445f2 85 #define STD_MODE
POTLESS_2 17:bef8abc445f2 86 //#define PID_MODE
POTLESS_2 11:b2feed92584a 87
POTLESS_2 12:7f3aadd79f89 88 #ifdef STD_MODE
POTLESS_2 12:7f3aadd79f89 89 int MODE_FLAG = 0;
POTLESS_2 11:b2feed92584a 90 #endif
POTLESS_2 11:b2feed92584a 91
POTLESS_2 12:7f3aadd79f89 92 #ifdef PID_MODE
POTLESS_2 12:7f3aadd79f89 93 int MODE_FLAG = 2;
POTLESS_2 11:b2feed92584a 94 #endif
POTLESS_2 11:b2feed92584a 95
POTLESS_2 9:04bfdfc029cb 96 #if NEED_ANDROID_OUTPUT
POTLESS_2 9:04bfdfc029cb 97 #define ANDROID(...) { android.printf(__VA_ARGS__); }
POTLESS_2 9:04bfdfc029cb 98 #else
POTLESS_2 9:04bfdfc029cb 99 #define ANDROID(...)
POTLESS_2 9:04bfdfc029cb 100 #endif
POTLESS_2 9:04bfdfc029cb 101
POTLESS_2 25:322ef9488e65 102 //PinName pwm, PinName nSleep, PinName fwd, PinName rev, PinName channelA, PinName channelB, int pulsesPerRev, int Rapport, Encoding encoding = X2_ENCODING
POTLESS_2 25:322ef9488e65 103 Faulhaber Servo_Poumon("Servo_Poumon", PWM_SERVO_POUMON, nSleep_SERVO_POUMON, FWD_SERVO_POUMON, REV_SERVO_POUMON, Channel_A_SERVO_POUMON, Channel_B_SERVO_POUMON, 16, 207, Faulhaber::X2_ENCODING);
POTLESS_2 22:555c2930e8e0 104 //Faulhaber Servo_Fuite("Servo_Fuite", PWM_SERVO_FUITE, nSleep_SERVO_FUITE, FWD_SERVO_FUITE, REV_SERVO_FUITE, 1, Channel_A_SERVO_FUITE, Channel_B_SERVO_FUITE, 16, 207, Faulhaber::X2_ENCODING);
POTLESS_2 17:bef8abc445f2 105
POTLESS_2 17:bef8abc445f2 106 //Moniteur série, Serial 2
POTLESS_2 17:bef8abc445f2 107 Serial serialMonit(USBTX,USBRX,115200);
POTLESS_2 10:aca745a66d51 108
POTLESS_2 9:04bfdfc029cb 109 //COM Série vers Android, Serial 3
POTLESS_2 17:bef8abc445f2 110 Serial android(PC_10,PC_11,115200);
POTLESS_2 4:d84250f67dec 111
POTLESS_2 7:ad15c386e960 112 //Init de la lib ARNSRS;
POTLESS_2 7:ad15c386e960 113 SENSOR_HEAD_REV_B sensors;
potless 2:4a8bf1d53439 114
POTLESS_2 6:ebed9093d661 115 //pour Param Cozir
POTLESS_2 9:04bfdfc029cb 116 const int sizeParam = 20;
POTLESS_2 11:b2feed92584a 117 char param[sizeParam];
POTLESS_2 11:b2feed92584a 118 volatile int indexParam = 0;
POTLESS_2 6:ebed9093d661 119 bool newParamFlag = false;
potless 2:4a8bf1d53439 120
POTLESS_2 9:04bfdfc029cb 121 //pour Commandes Android
POTLESS_2 9:04bfdfc029cb 122 const int sizeAndroid = 20;
POTLESS_2 11:b2feed92584a 123 char Android[sizeAndroid];
POTLESS_2 11:b2feed92584a 124 volatile int indexAndroid = 0;
POTLESS_2 9:04bfdfc029cb 125 bool newAndroidFlag = false;
POTLESS_2 12:7f3aadd79f89 126 char to_android[100];
POTLESS_2 9:04bfdfc029cb 127
POTLESS_2 25:322ef9488e65 128 //Flag pour interrompre l'affichage si on veut...
POTLESS_2 25:322ef9488e65 129 bool FLAG_AFF = true;
POTLESS_2 25:322ef9488e65 130
POTLESS_2 7:ad15c386e960 131 //Variables de stockage des infos capteurs
POTLESS_2 7:ad15c386e960 132 int co2 = 0;
POTLESS_2 7:ad15c386e960 133 float pression = 0;
POTLESS_2 9:04bfdfc029cb 134 float Temp1 = 0;
POTLESS_2 7:ad15c386e960 135 int ppO2 = 0;
POTLESS_2 7:ad15c386e960 136 int CellO2_1 = 0;
POTLESS_2 7:ad15c386e960 137 int CellO2_2 = 0;
POTLESS_2 7:ad15c386e960 138
POTLESS_2 18:bfd78c05b589 139 //Variables et constantes OTU
POTLESS_2 18:bfd78c05b589 140 float OTU = 0;
POTLESS_2 18:bfd78c05b589 141 float COEF_OTU = 0.83;
POTLESS_2 18:bfd78c05b589 142
POTLESS_2 17:bef8abc445f2 143 //Mesure du temps d'éxecution du loop
POTLESS_2 7:ad15c386e960 144 Timer REAL_RATE;
POTLESS_2 7:ad15c386e960 145 float RATE = 0;
POTLESS_2 11:b2feed92584a 146 float RATE_TRUE = 0;
POTLESS_2 12:7f3aadd79f89 147 float Ref_Time = 1.0; //La durée de la boucle désirée...
POTLESS_2 7:ad15c386e960 148
POTLESS_2 17:bef8abc445f2 149 //HTU21D sur l'I2C
POTLESS_2 8:a750d531b381 150 HTU21D temphumid(PB_9, PB_8); //Temp humid sensor || SDA, SCL
POTLESS_2 9:04bfdfc029cb 151 float Temp2;
POTLESS_2 9:04bfdfc029cb 152 int Humid;
POTLESS_2 9:04bfdfc029cb 153
POTLESS_2 9:04bfdfc029cb 154 //Data LOG
POTLESS_2 9:04bfdfc029cb 155 char to_store[50];
POTLESS_2 9:04bfdfc029cb 156 time_t seconds;
POTLESS_2 25:322ef9488e65 157 char Log_File_Name[] = " ";
POTLESS_2 8:a750d531b381 158
POTLESS_2 17:bef8abc445f2 159 //Thread d'intérogation des capteurs et de positionnement des volets
POTLESS_2 19:cac3761a5d0b 160 Thread thread_Sensors;
POTLESS_2 19:cac3761a5d0b 161 Thread thread_Volets;
POTLESS_2 20:5f79fb4565a7 162 Thread thread_Secu;
POTLESS_2 7:ad15c386e960 163
POTLESS_2 10:aca745a66d51 164 //Contrôle des servos
POTLESS_2 19:cac3761a5d0b 165 float Consigne_poumon = 0;
POTLESS_2 19:cac3761a5d0b 166 float volet_poumon_Position = 0;
POTLESS_2 19:cac3761a5d0b 167 float Consigne_fuite = 0;
POTLESS_2 19:cac3761a5d0b 168 float volet_fuite_Position = 0;
POTLESS_2 25:322ef9488e65 169 float Volets_Speed = 0.1;
POTLESS_2 26:a2fe19341f92 170 float Volet_DeadBand = 5;
POTLESS_2 10:aca745a66d51 171
POTLESS_2 12:7f3aadd79f89 172 #ifdef PID_MODE
POTLESS_2 12:7f3aadd79f89 173 //Paramètre du PID
POTLESS_2 12:7f3aadd79f89 174 float Kc = 40;
POTLESS_2 12:7f3aadd79f89 175 float Ti = 0;
POTLESS_2 12:7f3aadd79f89 176 float Td = 0;
POTLESS_2 12:7f3aadd79f89 177 float RATE_PID = Ref_Time;
POTLESS_2 12:7f3aadd79f89 178 float Commande_PID;
POTLESS_2 15:efd3b3bf3f37 179 float consigne = 210;
POTLESS_2 15:efd3b3bf3f37 180 float Max_Input = 1000;
POTLESS_2 15:efd3b3bf3f37 181 float Min_Input = 80;
POTLESS_2 19:cac3761a5d0b 182 float Max_Output = 85;//Vérifier la valeur pour angle à laisser ouvert...
POTLESS_2 19:cac3761a5d0b 183 float Min_Output = 5;
POTLESS_2 10:aca745a66d51 184
POTLESS_2 12:7f3aadd79f89 185 //Init PID
POTLESS_2 17:bef8abc445f2 186 PID control_Servo(Kc, Ti, Td, RATE_PID);
POTLESS_2 12:7f3aadd79f89 187 #endif
POTLESS_2 10:aca745a66d51 188
POTLESS_2 19:cac3761a5d0b 189 //Boolean du status de l'appareil, en mode SECU ou nominal
POTLESS_2 19:cac3761a5d0b 190 bool EN_MODE_SECU = false;
POTLESS_2 20:5f79fb4565a7 191 AnalogIn V_USB(PC_4);
POTLESS_2 20:5f79fb4565a7 192 float Vusb = 1;
POTLESS_2 18:bfd78c05b589 193
POTLESS_2 21:b8900130ca05 194 //Interruption user button
POTLESS_2 21:b8900130ca05 195 InterruptIn button(USER_BUTTON);
POTLESS_2 23:7477dc855fad 196 volatile int GO = 0;
POTLESS_2 21:b8900130ca05 197
POTLESS_2 21:b8900130ca05 198 void pressed() {
POTLESS_2 21:b8900130ca05 199
POTLESS_2 23:7477dc855fad 200 GO = GO + 1;
POTLESS_2 24:44ef919899c1 201 if (GO > 1) NVIC_SystemReset();
POTLESS_2 21:b8900130ca05 202 }
POTLESS_2 21:b8900130ca05 203
POTLESS_2 19:cac3761a5d0b 204 //Passage en mode SECU
POTLESS_2 19:cac3761a5d0b 205 void Mode_SECU()
POTLESS_2 18:bfd78c05b589 206 {
POTLESS_2 19:cac3761a5d0b 207 #ifdef PID_MODE
POTLESS_2 18:bfd78c05b589 208 //Mise du PID en mode manuel (desactivation...)
POTLESS_2 18:bfd78c05b589 209 control_Servo.setMode(MANUAL_MODE);
POTLESS_2 18:bfd78c05b589 210 #endif
POTLESS_2 19:cac3761a5d0b 211 Consigne_poumon = HOME_SERVO_POUMON;
POTLESS_2 19:cac3761a5d0b 212 Consigne_fuite = HOME_SERVO_FUITE;
POTLESS_2 25:322ef9488e65 213
POTLESS_2 25:322ef9488e65 214 Volets_Speed = 0.1;
POTLESS_2 25:322ef9488e65 215 Volet_DeadBand = 10;
POTLESS_2 25:322ef9488e65 216
POTLESS_2 19:cac3761a5d0b 217 while(1) {
POTLESS_2 25:322ef9488e65 218 wait_ms(100);
POTLESS_2 19:cac3761a5d0b 219 if (Servo_Poumon.Pos_OK() == true) break;
POTLESS_2 19:cac3761a5d0b 220 //if (Servo_Poumon.Pos_OK() == true && Servo_Fuite.Pos_OK() == true) break;
POTLESS_2 19:cac3761a5d0b 221 }
POTLESS_2 19:cac3761a5d0b 222 printf("-------------- Appareil en mode SECU ---------------\r\n");
POTLESS_2 25:322ef9488e65 223
POTLESS_2 25:322ef9488e65 224 wait_ms(100);
POTLESS_2 25:322ef9488e65 225 Consigne_poumon = 90;
POTLESS_2 25:322ef9488e65 226
POTLESS_2 25:322ef9488e65 227 while(1) {
POTLESS_2 25:322ef9488e65 228 wait_ms(100);
POTLESS_2 25:322ef9488e65 229 if (Servo_Poumon.Pos_OK() == true) break;
POTLESS_2 25:322ef9488e65 230 //if (Servo_Poumon.Pos_OK() == true && Servo_Fuite.Pos_OK() == true) break;
POTLESS_2 25:322ef9488e65 231 }
POTLESS_2 25:322ef9488e65 232 printf("-------------- Appareil en mode SECU ---------------\r\n");
POTLESS_2 25:322ef9488e65 233
POTLESS_2 25:322ef9488e65 234
POTLESS_2 19:cac3761a5d0b 235 EN_MODE_SECU = true;
POTLESS_2 25:322ef9488e65 236 wait_ms(100);
POTLESS_2 19:cac3761a5d0b 237 int Pos = Servo_Poumon.getPulses();
POTLESS_2 19:cac3761a5d0b 238 UTILS::Store_A_Val((float)Pos, "Servo_Poumon");
POTLESS_2 19:cac3761a5d0b 239 printf(" position volet poumon sauvegardée = %d pulse(s)\r\n", Pos);
POTLESS_2 19:cac3761a5d0b 240 //Pos = Servo_Fuite.getPulses();
POTLESS_2 19:cac3761a5d0b 241 //UTILS::Store_A_Val((float)Pos, "Servo_Fuite");
POTLESS_2 19:cac3761a5d0b 242 //printf(" position volet fuite sauvegardée = %d pulse(s)\r\n", Pos);
POTLESS_2 22:555c2930e8e0 243 UTILS::UnMount_SD();
POTLESS_2 23:7477dc855fad 244 Servo_Poumon.Sleep();
POTLESS_2 19:cac3761a5d0b 245 }
POTLESS_2 19:cac3761a5d0b 246
POTLESS_2 19:cac3761a5d0b 247 //Sequence d'arrêt
POTLESS_2 19:cac3761a5d0b 248 void Stop_Sequence()
POTLESS_2 19:cac3761a5d0b 249 {
POTLESS_2 26:a2fe19341f92 250 Mode_SECU();
POTLESS_2 20:5f79fb4565a7 251 printf("----------------ARRET DE L'APPAREIL--------------------\r\n");
POTLESS_2 19:cac3761a5d0b 252 deepsleep();
POTLESS_2 18:bfd78c05b589 253 }
POTLESS_2 18:bfd78c05b589 254
POTLESS_2 20:5f79fb4565a7 255 //Fonction test de valeur d'entrée convertie en Hight / Low
POTLESS_2 22:555c2930e8e0 256 float Power_Test(AnalogIn& pin)
POTLESS_2 20:5f79fb4565a7 257 {
POTLESS_2 20:5f79fb4565a7 258 float Val = pin.read();
POTLESS_2 25:322ef9488e65 259 if(Val < 0.2) Stop_Sequence();
POTLESS_2 22:555c2930e8e0 260 return Val;
POTLESS_2 20:5f79fb4565a7 261 }
POTLESS_2 20:5f79fb4565a7 262
POTLESS_2 18:bfd78c05b589 263 //Contrôle du status de l'appareil / des constantes
POTLESS_2 18:bfd78c05b589 264 bool Check()
POTLESS_2 18:bfd78c05b589 265 {
POTLESS_2 18:bfd78c05b589 266 if (ppO2 > 100)
POTLESS_2 19:cac3761a5d0b 267 return true;//Situation OK
POTLESS_2 18:bfd78c05b589 268 else
POTLESS_2 19:cac3761a5d0b 269 return false;//Situation dégradée
POTLESS_2 18:bfd78c05b589 270 }
POTLESS_2 18:bfd78c05b589 271
POTLESS_2 18:bfd78c05b589 272 //Calcul des OTU
POTLESS_2 18:bfd78c05b589 273 float Calcul_OTU()
POTLESS_2 18:bfd78c05b589 274 {
POTLESS_2 18:bfd78c05b589 275 /*
POTLESS_2 18:bfd78c05b589 276 La formule suivante permet de calculer la quantité d' OTU accumulée
POTLESS_2 18:bfd78c05b589 277 OTU = T * (2* PpO2 -1)0,83
POTLESS_2 18:bfd78c05b589 278 avec :
POTLESS_2 18:bfd78c05b589 279 T = temps de plongée en minutes
POTLESS_2 18:bfd78c05b589 280 PpO2 = pression partielle d’ oxygène en bars
POTLESS_2 18:bfd78c05b589 281 */
POTLESS_2 18:bfd78c05b589 282
POTLESS_2 19:cac3761a5d0b 283 if (ppO2 > 500) {
POTLESS_2 18:bfd78c05b589 284 float val = (2 * (float)ppO2/1000 - 1);//je divise par 1000 car la PP est en mb...
POTLESS_2 18:bfd78c05b589 285 OTU += Ref_Time * pow(val, COEF_OTU);
POTLESS_2 19:cac3761a5d0b 286 }
POTLESS_2 18:bfd78c05b589 287 }
POTLESS_2 10:aca745a66d51 288
POTLESS_2 17:bef8abc445f2 289 //Thread d'intérogation des capteurs, positions servo
POTLESS_2 10:aca745a66d51 290 void Get_Info_thread()
POTLESS_2 6:ebed9093d661 291 {
POTLESS_2 7:ad15c386e960 292 while (true) {
POTLESS_2 7:ad15c386e960 293
POTLESS_2 7:ad15c386e960 294 //CO2 sur Cozir
POTLESS_2 7:ad15c386e960 295 co2 = sensors.requestCO2();
POTLESS_2 7:ad15c386e960 296 //P / T sur MS5837
POTLESS_2 7:ad15c386e960 297 pression = sensors.requestPress();
POTLESS_2 9:04bfdfc029cb 298 Temp1 = sensors.requestTemp();
POTLESS_2 7:ad15c386e960 299 //PPO2 sur ADS1015
POTLESS_2 7:ad15c386e960 300 ppO2 = sensors.requestPpO2();
POTLESS_2 7:ad15c386e960 301 //Cell O2 en mV
POTLESS_2 7:ad15c386e960 302 CellO2_1 = sensors.requestCellO2_1();
POTLESS_2 7:ad15c386e960 303 CellO2_2 = sensors.requestCellO2_2();
POTLESS_2 9:04bfdfc029cb 304
POTLESS_2 8:a750d531b381 305 //HTU21D
POTLESS_2 9:04bfdfc029cb 306 Temp2 = temphumid.sample_ctemp();
POTLESS_2 9:04bfdfc029cb 307 Humid = temphumid.sample_humid();
POTLESS_2 9:04bfdfc029cb 308
POTLESS_2 10:aca745a66d51 309 //Retour position des servos
POTLESS_2 17:bef8abc445f2 310 volet_poumon_Position = Servo_Poumon.Get_Position();
POTLESS_2 20:5f79fb4565a7 311 //volet_fuite_Position = Servo_Fuite.Get_Position();
POTLESS_2 22:555c2930e8e0 312
POTLESS_2 19:cac3761a5d0b 313 }
POTLESS_2 19:cac3761a5d0b 314 }
POTLESS_2 12:7f3aadd79f89 315
POTLESS_2 19:cac3761a5d0b 316 void GO_TO_thread()
POTLESS_2 19:cac3761a5d0b 317 {
POTLESS_2 19:cac3761a5d0b 318 while (true) {
POTLESS_2 19:cac3761a5d0b 319 //Servo_Poumon.Go_To_Prop(Consigne_poumon);
POTLESS_2 26:a2fe19341f92 320 //Servo_Poumon.Go_To_PID(Consigne_poumon, Volet_DeadBand);
POTLESS_2 25:322ef9488e65 321 Servo_Poumon.Go_To(Consigne_poumon, Volets_Speed, Volet_DeadBand );
POTLESS_2 20:5f79fb4565a7 322
POTLESS_2 19:cac3761a5d0b 323 //Servo_Fuite.Go_To_Prop(Consigne_fuite);
POTLESS_2 19:cac3761a5d0b 324 //Servo_Fuite.Go_To_PID(Consigne_fuite);
POTLESS_2 15:efd3b3bf3f37 325 }
potless 2:4a8bf1d53439 326 }
POTLESS_2 4:d84250f67dec 327
POTLESS_2 20:5f79fb4565a7 328 void SECU_thread()
POTLESS_2 20:5f79fb4565a7 329 {
POTLESS_2 20:5f79fb4565a7 330 while (true) {
POTLESS_2 20:5f79fb4565a7 331 //Alim USB
POTLESS_2 22:555c2930e8e0 332 Vusb = Power_Test(V_USB);
POTLESS_2 20:5f79fb4565a7 333 //Divers problèmes à implémenter
POTLESS_2 20:5f79fb4565a7 334 //if(!Check()) Mode_SECU();
POTLESS_2 20:5f79fb4565a7 335 }
POTLESS_2 20:5f79fb4565a7 336 }
POTLESS_2 20:5f79fb4565a7 337
POTLESS_2 7:ad15c386e960 338 void Affichage_moniteur()
POTLESS_2 4:d84250f67dec 339 {
POTLESS_2 19:cac3761a5d0b 340
POTLESS_2 9:04bfdfc029cb 341 printf("\r\n");
POTLESS_2 9:04bfdfc029cb 342 printf(" CO2 = %d ppm\r\n" , co2);
POTLESS_2 9:04bfdfc029cb 343 printf(" PPO2 = %d mb\r\n", ppO2);
POTLESS_2 18:bfd78c05b589 344 printf(" OTU = %d \r\n", OTU);
POTLESS_2 9:04bfdfc029cb 345 printf(" Pression = %f msw\r\n", pression);
POTLESS_2 10:aca745a66d51 346 printf(" Temp MS5837 = %f C\r\n", Temp1);
POTLESS_2 10:aca745a66d51 347 printf(" Temp HTU21D = %f C\n\r", Temp2);
POTLESS_2 9:04bfdfc029cb 348 printf(" Humidity = %d %%\n\r", Humid);
POTLESS_2 8:a750d531b381 349 printf("\n\r");
POTLESS_2 8:a750d531b381 350 printf(" Cell O2 n 1 = %d\r\n" , CellO2_1);
POTLESS_2 8:a750d531b381 351 printf(" Cell O2 n 2 = %d\r\n" , CellO2_2);
POTLESS_2 7:ad15c386e960 352 printf("\r\n");
POTLESS_2 9:04bfdfc029cb 353 printf("\n");
POTLESS_2 17:bef8abc445f2 354 printf(" Volet Poumon = %f\r\n" , volet_poumon_Position);
POTLESS_2 17:bef8abc445f2 355 printf(" Volet Fuite = %f\r\n" , volet_fuite_Position);
POTLESS_2 10:aca745a66d51 356 printf("\r\n");
POTLESS_2 12:7f3aadd79f89 357 printf("Temps d execution de la boucle = %f seconde(s)\n", (RATE + RATE_TRUE / 1000));
POTLESS_2 17:bef8abc445f2 358 printf("\r\n");
POTLESS_2 9:04bfdfc029cb 359 printf("A enregistrer = %s\n", to_store);
POTLESS_2 9:04bfdfc029cb 360 printf("\r\n");
POTLESS_2 20:5f79fb4565a7 361 printf("V_USB = %f", Vusb);
POTLESS_2 20:5f79fb4565a7 362 printf("\r\n");
POTLESS_2 25:322ef9488e65 363
POTLESS_2 4:d84250f67dec 364 }
POTLESS_2 4:d84250f67dec 365
POTLESS_2 11:b2feed92584a 366 //Callback de l'intérruption des envois de commandes depuis le terminal
POTLESS_2 6:ebed9093d661 367 void callbackParam()
POTLESS_2 4:d84250f67dec 368 {
POTLESS_2 6:ebed9093d661 369 while(serialMonit.readable()) {
POTLESS_2 6:ebed9093d661 370 if (indexParam == sizeParam) //éviter la saturation du buffer
POTLESS_2 6:ebed9093d661 371 serialMonit.getc();
POTLESS_2 6:ebed9093d661 372 else
POTLESS_2 6:ebed9093d661 373 param [indexParam++] = serialMonit.getc();//chargement du buffer dans le message
POTLESS_2 6:ebed9093d661 374 if ((indexParam == sizeParam) || (param[indexParam -1] == '\n')) {//le message est complet ou nouvelle ligne ou autre si on veut...
POTLESS_2 6:ebed9093d661 375 param[indexParam] = 0;
POTLESS_2 6:ebed9093d661 376 newParamFlag = true;
POTLESS_2 6:ebed9093d661 377 }
POTLESS_2 4:d84250f67dec 378 }
POTLESS_2 6:ebed9093d661 379 }
POTLESS_2 4:d84250f67dec 380
POTLESS_2 9:04bfdfc029cb 381 //Callback de l'intérruption des envois de commandes depuis Android
POTLESS_2 9:04bfdfc029cb 382 void callbackAndroid()
POTLESS_2 9:04bfdfc029cb 383 {
POTLESS_2 9:04bfdfc029cb 384 while(android.readable()) {
POTLESS_2 9:04bfdfc029cb 385 if (indexAndroid == sizeAndroid) //éviter la saturation du buffer
POTLESS_2 9:04bfdfc029cb 386 android.getc();
POTLESS_2 9:04bfdfc029cb 387 else
POTLESS_2 9:04bfdfc029cb 388 Android [indexAndroid++] = android.getc();//chargement du buffer dans le message
POTLESS_2 9:04bfdfc029cb 389 if ((indexAndroid == sizeAndroid) || (Android[indexAndroid -1] == '\n')) {//le message est complet ou nouvelle ligne ou autre si on veut...
POTLESS_2 9:04bfdfc029cb 390 Android[indexAndroid] = 0;
POTLESS_2 9:04bfdfc029cb 391 newAndroidFlag = true;
POTLESS_2 9:04bfdfc029cb 392 }
POTLESS_2 9:04bfdfc029cb 393 }
POTLESS_2 9:04bfdfc029cb 394 }
POTLESS_2 11:b2feed92584a 395
POTLESS_2 9:04bfdfc029cb 396 void Decoding_Message(char message [])
POTLESS_2 9:04bfdfc029cb 397 {
POTLESS_2 9:04bfdfc029cb 398 char *commande = 0;
POTLESS_2 14:b5e0e882205e 399 float valeur = 0;
POTLESS_2 9:04bfdfc029cb 400
POTLESS_2 14:b5e0e882205e 401 sscanf(message,"%s %f",&commande , &valeur);
POTLESS_2 9:04bfdfc029cb 402
POTLESS_2 19:cac3761a5d0b 403 if ((char)commande == 'S') {
POTLESS_2 19:cac3761a5d0b 404 Mode_SECU();
POTLESS_2 26:a2fe19341f92 405 }else if ((char)commande == 'D') {
POTLESS_2 27:1b1fd20a2793 406 UTILS::Dir_SD();
POTLESS_2 26:a2fe19341f92 407 }else if ((char)commande == 'U') {
POTLESS_2 26:a2fe19341f92 408 char filename[20];
POTLESS_2 26:a2fe19341f92 409 sprintf(filename, "LOG_%d.txt", (int)valeur);
POTLESS_2 26:a2fe19341f92 410 UTILS::Read_SD_File(filename);
POTLESS_2 20:5f79fb4565a7 411 } else if ((char)commande == 'r') {
POTLESS_2 20:5f79fb4565a7 412 Consigne_poumon = 0;
POTLESS_2 20:5f79fb4565a7 413 volet_poumon_Position = 0;
POTLESS_2 19:cac3761a5d0b 414 Servo_Poumon.reset();
POTLESS_2 19:cac3761a5d0b 415 } else if ((char)commande == 'Q') {
POTLESS_2 19:cac3761a5d0b 416 Stop_Sequence();
POTLESS_2 19:cac3761a5d0b 417 } else if ((char)commande == 'T') {
POTLESS_2 9:04bfdfc029cb 418 set_time(valeur);
POTLESS_2 12:7f3aadd79f89 419 } else if ((char)commande == 'I') {
POTLESS_2 17:bef8abc445f2 420 Consigne_poumon = (float)valeur;
POTLESS_2 17:bef8abc445f2 421 printf(" Servo Poumon = %f\r\n", Consigne_poumon);
POTLESS_2 12:7f3aadd79f89 422 } else if ((char)commande == 'O') {
POTLESS_2 17:bef8abc445f2 423 Consigne_fuite = (float)valeur;
POTLESS_2 17:bef8abc445f2 424 printf(" Servo Fuite = %f\r\n", Consigne_fuite);
POTLESS_2 10:aca745a66d51 425 } else if ((char)commande == 'R') {
POTLESS_2 10:aca745a66d51 426 NVIC_SystemReset();
POTLESS_2 12:7f3aadd79f89 427 /////////////////////////////////////////
POTLESS_2 12:7f3aadd79f89 428 //Pour rajouter une commande
POTLESS_2 12:7f3aadd79f89 429 //} else if ((char)commande == 'X') {
POTLESS_2 12:7f3aadd79f89 430 // attribuer à une VARIABLE = valeur;
POTLESS_2 12:7f3aadd79f89 431 // ou une action, avec ou sans valeur
POTLESS_2 12:7f3aadd79f89 432 /////////////////////////////////////////
POTLESS_2 12:7f3aadd79f89 433 } else {
POTLESS_2 9:04bfdfc029cb 434 sensors.cozirSend(message);
POTLESS_2 9:04bfdfc029cb 435 }
POTLESS_2 9:04bfdfc029cb 436
POTLESS_2 9:04bfdfc029cb 437 strcpy(param," ");
POTLESS_2 9:04bfdfc029cb 438 indexParam = 0;
POTLESS_2 9:04bfdfc029cb 439 newParamFlag = false;
POTLESS_2 9:04bfdfc029cb 440 }
POTLESS_2 9:04bfdfc029cb 441
POTLESS_2 9:04bfdfc029cb 442 void Decoding_Message_Android(char message [])
POTLESS_2 9:04bfdfc029cb 443 {
POTLESS_2 9:04bfdfc029cb 444 char *commande = 0;
POTLESS_2 14:b5e0e882205e 445 float valeur = 0;
POTLESS_2 9:04bfdfc029cb 446
POTLESS_2 14:b5e0e882205e 447 sscanf(message,"%s %f",&commande , &valeur);
POTLESS_2 9:04bfdfc029cb 448
POTLESS_2 9:04bfdfc029cb 449 if ((char)commande == 'T') {
POTLESS_2 9:04bfdfc029cb 450 set_time(valeur);
POTLESS_2 12:7f3aadd79f89 451 } else if ((char)commande == 'I') {
POTLESS_2 17:bef8abc445f2 452 Consigne_poumon = (float)valeur;
POTLESS_2 17:bef8abc445f2 453 printf(" Servo Poumon = %f\r\n", Consigne_poumon);
POTLESS_2 12:7f3aadd79f89 454 } else if ((char)commande == 'O') {
POTLESS_2 17:bef8abc445f2 455 Consigne_fuite = (float)valeur;
POTLESS_2 17:bef8abc445f2 456 printf(" Servo Fuite = %f\r\n", Consigne_fuite);
POTLESS_2 12:7f3aadd79f89 457 /////////////////////////////////////////
POTLESS_2 12:7f3aadd79f89 458 //Pour rajouter une commande
POTLESS_2 12:7f3aadd79f89 459 //} else if ((char)commande == 'X') {
POTLESS_2 12:7f3aadd79f89 460 // attribuer à une VARIABLE = valeur;
POTLESS_2 12:7f3aadd79f89 461 // ou une action, avec ou sans valeur
POTLESS_2 12:7f3aadd79f89 462 /////////////////////////////////////////
POTLESS_2 9:04bfdfc029cb 463 } else if ((char)commande == 'R') {
POTLESS_2 9:04bfdfc029cb 464 NVIC_SystemReset();
POTLESS_2 9:04bfdfc029cb 465 }
POTLESS_2 12:7f3aadd79f89 466 #ifdef PID_MODE
POTLESS_2 12:7f3aadd79f89 467 else if ((char)commande == 'p') {
POTLESS_2 12:7f3aadd79f89 468 Kc = (float)valeur;
POTLESS_2 16:917656586772 469 control_Servo.reset();
POTLESS_2 12:7f3aadd79f89 470 control_Servo.setTunings(Kc, Ti, Td);
POTLESS_2 14:b5e0e882205e 471 printf(" UPDATE PID --> Kc = %f Ti = %f Td = %f\r\n\n", Kc, Ti, Td);
POTLESS_2 15:efd3b3bf3f37 472 } else if ((char)commande == 'i') {
POTLESS_2 12:7f3aadd79f89 473 Ti = (float)valeur;
POTLESS_2 16:917656586772 474 control_Servo.reset();
POTLESS_2 12:7f3aadd79f89 475 control_Servo.setTunings(Kc, Ti, Td);
POTLESS_2 14:b5e0e882205e 476 printf(" UPDATE PID --> Kc = %f Ti = %f Td = %f\r\n\n", Kc, Ti, Td);
POTLESS_2 15:efd3b3bf3f37 477 } else if ((char)commande == 'd') {
POTLESS_2 12:7f3aadd79f89 478 Td = (float)valeur;
POTLESS_2 16:917656586772 479 control_Servo.reset();
POTLESS_2 12:7f3aadd79f89 480 control_Servo.setTunings(Kc, Ti, Td);
POTLESS_2 14:b5e0e882205e 481 printf(" UPDATE PID --> Kc = %f Ti = %f Td = %f\r\n\n", Kc, Ti, Td);
POTLESS_2 15:efd3b3bf3f37 482 } else if ((char)commande == 'c') {
POTLESS_2 12:7f3aadd79f89 483 consigne = valeur;
POTLESS_2 15:efd3b3bf3f37 484 control_Servo.setSetPoint(consigne);
POTLESS_2 14:b5e0e882205e 485 printf(" UPDATE CONSIGNE PID --> Consigne = %d\r\n\n", consigne);
POTLESS_2 12:7f3aadd79f89 486 }
POTLESS_2 15:efd3b3bf3f37 487 #endif
POTLESS_2 18:bfd78c05b589 488
POTLESS_2 9:04bfdfc029cb 489 strcpy(Android," ");
POTLESS_2 9:04bfdfc029cb 490 indexAndroid = 0;
POTLESS_2 9:04bfdfc029cb 491 newAndroidFlag = false;
POTLESS_2 9:04bfdfc029cb 492 }
POTLESS_2 9:04bfdfc029cb 493
POTLESS_2 26:a2fe19341f92 494 void Create_File_Name_Date()
POTLESS_2 25:322ef9488e65 495 {
POTLESS_2 25:322ef9488e65 496 //Du nom du fichier Date / heure
POTLESS_2 25:322ef9488e65 497 seconds = time(NULL);
POTLESS_2 25:322ef9488e65 498 char Time[40];
POTLESS_2 25:322ef9488e65 499 strftime(Time, 40, "%a_%d_%m_%Y_%H%M", localtime(&seconds));
POTLESS_2 25:322ef9488e65 500 sprintf(Log_File_Name, "%s_LOG.txt", Time);
POTLESS_2 25:322ef9488e65 501 printf("Nouveau fichier LOG = %s \r\n", Log_File_Name);
POTLESS_2 25:322ef9488e65 502
POTLESS_2 25:322ef9488e65 503 }
POTLESS_2 25:322ef9488e65 504
POTLESS_2 26:a2fe19341f92 505 void Create_File_Name_Index()
POTLESS_2 26:a2fe19341f92 506 {
POTLESS_2 26:a2fe19341f92 507 //Du nom du fichier par Index
POTLESS_2 26:a2fe19341f92 508 sprintf(Log_File_Name, "LOG_%d.txt", UTILS::File_Index());
POTLESS_2 26:a2fe19341f92 509 printf(" Nouveau fichier LOG = %s \r\n", Log_File_Name);
POTLESS_2 26:a2fe19341f92 510 }
POTLESS_2 26:a2fe19341f92 511
POTLESS_2 4:d84250f67dec 512 int main()
POTLESS_2 12:7f3aadd79f89 513 {
POTLESS_2 21:b8900130ca05 514 button.fall(&pressed);
POTLESS_2 21:b8900130ca05 515 int count = 0;
POTLESS_2 25:322ef9488e65 516
POTLESS_2 21:b8900130ca05 517 while (1) {
POTLESS_2 21:b8900130ca05 518
POTLESS_2 25:322ef9488e65 519 if (count == 0) serialMonit.printf("\r\nAppuyez sur le User Button pour commencer...\r\n");
POTLESS_2 21:b8900130ca05 520
POTLESS_2 21:b8900130ca05 521 count = 1;
POTLESS_2 21:b8900130ca05 522
POTLESS_2 24:44ef919899c1 523 if (GO == 1) {
POTLESS_2 21:b8900130ca05 524
POTLESS_2 21:b8900130ca05 525 wait(1);
POTLESS_2 21:b8900130ca05 526
POTLESS_2 19:cac3761a5d0b 527 serialMonit.attach(&callbackParam, Serial::RxIrq);
POTLESS_2 12:7f3aadd79f89 528
POTLESS_2 19:cac3761a5d0b 529 android.attach(&callbackAndroid, Serial::RxIrq);
POTLESS_2 12:7f3aadd79f89 530
POTLESS_2 26:a2fe19341f92 531 //Ci-dessous commande pour formater une nouvelle carte
POTLESS_2 27:1b1fd20a2793 532 UTILS::Format_SD();
POTLESS_2 26:a2fe19341f92 533
POTLESS_2 26:a2fe19341f92 534 //Montage carte SD
POTLESS_2 26:a2fe19341f92 535 UTILS::Mount_SD();
POTLESS_2 26:a2fe19341f92 536
POTLESS_2 26:a2fe19341f92 537 //Liste des fichiers sur la carte sd
POTLESS_2 26:a2fe19341f92 538 UTILS::Dir_SD();
POTLESS_2 26:a2fe19341f92 539
POTLESS_2 26:a2fe19341f92 540 bool calib_O2 = false;
POTLESS_2 26:a2fe19341f92 541 bool calib_CO2 = false;
POTLESS_2 26:a2fe19341f92 542
POTLESS_2 18:bfd78c05b589 543 /*
POTLESS_2 18:bfd78c05b589 544 Par défaut les valeur en cas de calibration sur true sont les suivant
POTLESS_2 18:bfd78c05b589 545
POTLESS_2 19:cac3761a5d0b 546 nbCalibO2 = 5
POTLESS_2 19:cac3761a5d0b 547 Mode = SPOOLING
POTLESS_2 19:cac3761a5d0b 548 Filtre = DIGI_FILTER32
POTLESS_2 19:cac3761a5d0b 549 CalibrationCO2 = "CALIB_AIR"
POTLESS_2 18:bfd78c05b589 550
POTLESS_2 19:cac3761a5d0b 551 Parfois la calibration du Cozir coince...faire reset et relancer...
POTLESS_2 6:ebed9093d661 552
POTLESS_2 19:cac3761a5d0b 553 Pour calibrer avec ces paramètres :
POTLESS_2 18:bfd78c05b589 554
POTLESS_2 19:cac3761a5d0b 555 sensors.Sensors_INIT(true, true);
POTLESS_2 18:bfd78c05b589 556
POTLESS_2 19:cac3761a5d0b 557 Pour changer utiliser la syntaxe suivante :
POTLESS_2 18:bfd78c05b589 558
POTLESS_2 19:cac3761a5d0b 559 sensors.Sensors_INIT(true, true, true, 5, SPOOLING, DIGI_FILTER32, CALIB_AIR);
POTLESS_2 18:bfd78c05b589 560
POTLESS_2 19:cac3761a5d0b 561 */
POTLESS_2 26:a2fe19341f92 562
POTLESS_2 26:a2fe19341f92 563 sensors.Sensors_INIT(calib_O2, calib_CO2);
POTLESS_2 18:bfd78c05b589 564
POTLESS_2 19:cac3761a5d0b 565 wait(1);
POTLESS_2 25:322ef9488e65 566
POTLESS_2 27:1b1fd20a2793 567 Servo_Poumon.Init("Servo_Poumon");
POTLESS_2 27:1b1fd20a2793 568 //Servo_Fuite.Init();
POTLESS_2 27:1b1fd20a2793 569
POTLESS_2 26:a2fe19341f92 570 //Création du nouveau fichier LOG par index / par date.
POTLESS_2 26:a2fe19341f92 571 Create_File_Name_Index();
POTLESS_2 26:a2fe19341f92 572 //Create_File_Name_Date()
POTLESS_2 26:a2fe19341f92 573
POTLESS_2 25:322ef9488e65 574 serialMonit.printf(" Demarrage des threads...\r\n\r\n");
POTLESS_2 6:ebed9093d661 575
POTLESS_2 18:bfd78c05b589 576 /*
POTLESS_2 15:efd3b3bf3f37 577
POTLESS_2 18:bfd78c05b589 578 Pour mémoire, les réglage de priorité des thread
POTLESS_2 15:efd3b3bf3f37 579
POTLESS_2 18:bfd78c05b589 580 osPriorityIdle = -3, ///< priority: idle (lowest)
POTLESS_2 18:bfd78c05b589 581 osPriorityLow = -2, ///< priority: low
POTLESS_2 18:bfd78c05b589 582 osPriorityBelowNormal = -1, ///< priority: below normal
POTLESS_2 18:bfd78c05b589 583 osPriorityNormal = 0, ///< priority: normal (default)
POTLESS_2 18:bfd78c05b589 584 osPriorityAboveNormal = +1, ///< priority: above normal
POTLESS_2 18:bfd78c05b589 585 osPriorityHigh = +2, ///< priority: high
POTLESS_2 18:bfd78c05b589 586 osPriorityRealtime = +3, ///< priority: realtime (highest)
POTLESS_2 18:bfd78c05b589 587 osPriorityError = 0x84 ///< system cannot determine priority or thread has illegal priority
POTLESS_2 18:bfd78c05b589 588 */
POTLESS_2 18:bfd78c05b589 589
POTLESS_2 19:cac3761a5d0b 590 thread_Sensors.start(Get_Info_thread);
POTLESS_2 19:cac3761a5d0b 591
POTLESS_2 19:cac3761a5d0b 592 thread_Sensors.set_priority(osPriorityNormal);
POTLESS_2 21:b8900130ca05 593
POTLESS_2 21:b8900130ca05 594 wait_ms(300);
POTLESS_2 9:04bfdfc029cb 595
POTLESS_2 19:cac3761a5d0b 596 thread_Volets.start(GO_TO_thread);
POTLESS_2 19:cac3761a5d0b 597
POTLESS_2 19:cac3761a5d0b 598 thread_Volets.set_priority(osPriorityNormal);
POTLESS_2 20:5f79fb4565a7 599
POTLESS_2 21:b8900130ca05 600 wait_ms(300);
POTLESS_2 21:b8900130ca05 601
POTLESS_2 20:5f79fb4565a7 602 thread_Secu.start(SECU_thread);
POTLESS_2 20:5f79fb4565a7 603
POTLESS_2 20:5f79fb4565a7 604 thread_Secu.set_priority(osPriorityNormal);
POTLESS_2 21:b8900130ca05 605
POTLESS_2 21:b8900130ca05 606 wait_ms(300);
POTLESS_2 12:7f3aadd79f89 607
POTLESS_2 12:7f3aadd79f89 608 #ifdef PID_MODE
POTLESS_2 12:7f3aadd79f89 609 //Init PID
POTLESS_2 12:7f3aadd79f89 610 //Entrée PPO2 entre 100 et 1000 mb
POTLESS_2 12:7f3aadd79f89 611 control_Servo.setInputLimits(Min_Input, Max_Input);
POTLESS_2 12:7f3aadd79f89 612 //Sortie servo entre 0 et 100 %
POTLESS_2 12:7f3aadd79f89 613 control_Servo.setOutputLimits(Min_Output, Max_Output);
POTLESS_2 15:efd3b3bf3f37 614 //Mode auto au démarrage
POTLESS_2 12:7f3aadd79f89 615 control_Servo.setMode(AUTO_MODE);
POTLESS_2 12:7f3aadd79f89 616 //Consigne à x mb
POTLESS_2 12:7f3aadd79f89 617 control_Servo.setSetPoint(consigne);
POTLESS_2 15:efd3b3bf3f37 618 #endif
POTLESS_2 25:322ef9488e65 619
POTLESS_2 25:322ef9488e65 620 serialMonit.printf(" Threads démmarés.....Entrez les comandes COZIR si besoin :\r\n");
POTLESS_2 25:322ef9488e65 621
POTLESS_2 7:ad15c386e960 622 while (true) {
POTLESS_2 25:322ef9488e65 623
POTLESS_2 7:ad15c386e960 624 //Démarrage du Timer mesurant le temps d'éxecution du code
POTLESS_2 7:ad15c386e960 625 REAL_RATE.start();
POTLESS_2 7:ad15c386e960 626
POTLESS_2 6:ebed9093d661 627 if (newParamFlag) {
POTLESS_2 6:ebed9093d661 628 serialMonit.printf("Param = %s\r\n", param);
POTLESS_2 9:04bfdfc029cb 629 Decoding_Message(param);
POTLESS_2 9:04bfdfc029cb 630 }
POTLESS_2 9:04bfdfc029cb 631
POTLESS_2 9:04bfdfc029cb 632 if (newAndroidFlag) {
POTLESS_2 9:04bfdfc029cb 633 serialMonit.printf("Android = %s\r\n", Android);
POTLESS_2 9:04bfdfc029cb 634 Decoding_Message_Android(Android);
POTLESS_2 6:ebed9093d661 635 }
POTLESS_2 7:ad15c386e960 636
POTLESS_2 15:efd3b3bf3f37 637 //Fabrication de la chaine Date / heure
POTLESS_2 15:efd3b3bf3f37 638 seconds = time(NULL);
POTLESS_2 15:efd3b3bf3f37 639 char Time_buf[32];
POTLESS_2 15:efd3b3bf3f37 640 strftime(Time_buf, 32, "%D %I-%M-%S ", localtime(&seconds));
POTLESS_2 25:322ef9488e65 641
POTLESS_2 17:bef8abc445f2 642 #ifdef PID_MODE
POTLESS_2 15:efd3b3bf3f37 643 //Fabrication de la chaine à enregistrer
POTLESS_2 17:bef8abc445f2 644 sprintf(to_store,"%s:%d:%d:%.2f:%.2f:%.2f:%d:%d:%d:%.2f:%.2f:%d:%.3f:%.3f:%.3f:%d",
POTLESS_2 15:efd3b3bf3f37 645 Time_buf,
POTLESS_2 15:efd3b3bf3f37 646 co2,
POTLESS_2 15:efd3b3bf3f37 647 ppO2,
POTLESS_2 15:efd3b3bf3f37 648 pression,
POTLESS_2 15:efd3b3bf3f37 649 Temp1,
POTLESS_2 15:efd3b3bf3f37 650 Temp2,
POTLESS_2 15:efd3b3bf3f37 651 Humid,
POTLESS_2 15:efd3b3bf3f37 652 CellO2_1,
POTLESS_2 15:efd3b3bf3f37 653 CellO2_2,
POTLESS_2 15:efd3b3bf3f37 654 volet_poumon_Position,
POTLESS_2 15:efd3b3bf3f37 655 volet_fuite_Position,
POTLESS_2 15:efd3b3bf3f37 656 MODE_FLAG,
POTLESS_2 15:efd3b3bf3f37 657 Kc,
POTLESS_2 15:efd3b3bf3f37 658 Ti,
POTLESS_2 18:bfd78c05b589 659 Td,
POTLESS_2 17:bef8abc445f2 660 (int)consigne
POTLESS_2 18:bfd78c05b589 661 );
POTLESS_2 17:bef8abc445f2 662 #endif
POTLESS_2 17:bef8abc445f2 663 #ifndef PID_MODE
POTLESS_2 17:bef8abc445f2 664 //Fabrication de la chaine à enregistrer sans les variables du PID
POTLESS_2 17:bef8abc445f2 665 sprintf(to_store,"%s:%d:%d:%.2f:%.2f:%.2f:%d:%d:%d:%.2f:%.2f:%d:%.3f:%.3f:%.3f:%d",
POTLESS_2 17:bef8abc445f2 666 Time_buf,
POTLESS_2 17:bef8abc445f2 667 co2,
POTLESS_2 17:bef8abc445f2 668 ppO2,
POTLESS_2 17:bef8abc445f2 669 pression,
POTLESS_2 17:bef8abc445f2 670 Temp1,
POTLESS_2 17:bef8abc445f2 671 Temp2,
POTLESS_2 17:bef8abc445f2 672 Humid,
POTLESS_2 17:bef8abc445f2 673 CellO2_1,
POTLESS_2 17:bef8abc445f2 674 CellO2_2,
POTLESS_2 17:bef8abc445f2 675 volet_poumon_Position,
POTLESS_2 17:bef8abc445f2 676 volet_fuite_Position,
POTLESS_2 17:bef8abc445f2 677 MODE_FLAG,
POTLESS_2 20:5f79fb4565a7 678 0.0,
POTLESS_2 20:5f79fb4565a7 679 0.0,
POTLESS_2 20:5f79fb4565a7 680 0.0,
POTLESS_2 17:bef8abc445f2 681 0
POTLESS_2 18:bfd78c05b589 682 );
POTLESS_2 17:bef8abc445f2 683 #endif
POTLESS_2 15:efd3b3bf3f37 684
POTLESS_2 15:efd3b3bf3f37 685 //Enregistrement de la chaine
POTLESS_2 25:322ef9488e65 686 UTILS::Write_SD_File(to_store, Log_File_Name);
POTLESS_2 15:efd3b3bf3f37 687
POTLESS_2 15:efd3b3bf3f37 688 //Pour Android on ajoute < et > pour décoder l'arrivée du message
POTLESS_2 9:04bfdfc029cb 689 if (NEED_ANDROID_OUTPUT == 1) {
POTLESS_2 25:322ef9488e65 690 //sprintf(to_android,"<%s>",to_store);
POTLESS_2 12:7f3aadd79f89 691 ANDROID(to_android);
POTLESS_2 9:04bfdfc029cb 692 }
POTLESS_2 15:efd3b3bf3f37 693
POTLESS_2 18:bfd78c05b589 694 //Calcul des OTU
POTLESS_2 18:bfd78c05b589 695 Calcul_OTU();
POTLESS_2 19:cac3761a5d0b 696
POTLESS_2 20:5f79fb4565a7 697 //Vers le moniteur série
POTLESS_2 25:322ef9488e65 698 if (FLAG_AFF) Affichage_moniteur();
POTLESS_2 15:efd3b3bf3f37 699
POTLESS_2 15:efd3b3bf3f37 700
POTLESS_2 15:efd3b3bf3f37 701 #ifdef PID_MODE
POTLESS_2 15:efd3b3bf3f37 702 //Update du PID
POTLESS_2 15:efd3b3bf3f37 703 control_Servo.setProcessValue(ppO2);
POTLESS_2 19:cac3761a5d0b 704 //Nouvelle sortie servo fuite si on est pas en mode SECU
POTLESS_2 19:cac3761a5d0b 705 if(!EN_MODE_SECU) Consigne_fuite = control_Servo.compute();
POTLESS_2 12:7f3aadd79f89 706 #endif
POTLESS_2 15:efd3b3bf3f37 707
POTLESS_2 7:ad15c386e960 708 //Arrêt du Timer mesurant le temps d'éxecution du code
POTLESS_2 7:ad15c386e960 709 REAL_RATE.stop();
POTLESS_2 7:ad15c386e960 710 //Définition de la nouvelle valeur du temps d'échantillonage du PID.
POTLESS_2 7:ad15c386e960 711 RATE = REAL_RATE.read();
POTLESS_2 7:ad15c386e960 712 //Reset du Timer
POTLESS_2 7:ad15c386e960 713 REAL_RATE.reset();
POTLESS_2 12:7f3aadd79f89 714
POTLESS_2 16:917656586772 715 //Pour ralentir le code à Ref_Time seconde fixe quelque soit les intéruptions du loop....
POTLESS_2 18:bfd78c05b589 716 if (Ref_Time > RATE) {
POTLESS_2 18:bfd78c05b589 717 RATE_TRUE = (Ref_Time - RATE) * 1000;
POTLESS_2 18:bfd78c05b589 718 } else {
POTLESS_2 18:bfd78c05b589 719 RATE_TRUE = 0;
POTLESS_2 16:917656586772 720 #ifdef PID_MODE
POTLESS_2 18:bfd78c05b589 721 control_Servo.setInterval(RATE);
POTLESS_2 18:bfd78c05b589 722 #endif
POTLESS_2 18:bfd78c05b589 723 printf("Pour ralentir le code, Ref_Time doit être supérieur à %f seconde(s)\r\n\n", RATE);
POTLESS_2 16:917656586772 724 }
POTLESS_2 18:bfd78c05b589 725
POTLESS_2 11:b2feed92584a 726 wait_ms(RATE_TRUE);
POTLESS_2 21:b8900130ca05 727 }
POTLESS_2 27:1b1fd20a2793 728 }
POTLESS_2 21:b8900130ca05 729 }
POTLESS_2 4:d84250f67dec 730 }