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@61:c3391376ca21, 2018-07-05 (annotated)

Committer:
potless
Date:
Thu Jul 05 08:47:11 2018 +0000
Revision:
61:c3391376ca21
Parent:
60:e2922f9e309c 
4juillet effacement ne marche pas

Who changed what in which revision?

UserRevisionLine numberNew contents of line
potless 1:bef7856b5c0a 1 #include "mbed.h"
potless 2:4a8bf1d53439 2 #include <string>
POTLESS_2 7:ad15c386e960 3 #include "Sensor_head_revB.h"
POTLESS_2 8:a750d531b381 4 #include "HTU21D.h"
POTLESS_2 12:7f3aadd79f89 5 #include "PID.h"
POTLESS_2 19:cac3761a5d0b 6 #include "Faulhaber.h"
POTLESS_2 29:5b822d18bce6 7 #include "Utils.h"
POTLESS_2 47:89a088bc8866 8 #include "beep.h"
POTLESS_2 47:89a088bc8866 9 #include "USBSerial.h"
POTLESS_2 4:d84250f67dec 10
potless 48:9ceb095f397a 11
POTLESS_2 17:bef8abc445f2 12 //Commandes des servos
POTLESS_2 19:cac3761a5d0b 13 #define PWM_SERVO_POUMON PB_15
POTLESS_2 19:cac3761a5d0b 14 #define nSleep_SERVO_POUMON PC_6
POTLESS_2 19:cac3761a5d0b 15 #define FWD_SERVO_POUMON PB_14
POTLESS_2 19:cac3761a5d0b 16 #define REV_SERVO_POUMON PB_13
POTLESS_2 55:6536e02d729e 17 #define Channel_A_SERVO_POUMON PB_1
POTLESS_2 55:6536e02d729e 18 #define Channel_B_SERVO_POUMON PB_2
POTLESS_2 19:cac3761a5d0b 19 #define HOME_SERVO_POUMON 0
POTLESS_2 17:bef8abc445f2 20
POTLESS_2 19:cac3761a5d0b 21 #define PWM_SERVO_FUITE PB_10
POTLESS_2 43:5ae8baf28e32 22 #define nSleep_SERVO_FUITE PB_0
POTLESS_2 55:6536e02d729e 23 #define FWD_SERVO_FUITE PB_5
POTLESS_2 55:6536e02d729e 24 #define REV_SERVO_FUITE PB_4
POTLESS_2 43:5ae8baf28e32 25 #define Channel_A_SERVO_FUITE PC_9
POTLESS_2 43:5ae8baf28e32 26 #define Channel_B_SERVO_FUITE PA_8
POTLESS_2 19:cac3761a5d0b 27 #define HOME_SERVO_FUITE 90
POTLESS_2 17:bef8abc445f2 28
POTLESS_2 43:5ae8baf28e32 29 //Pin de test des alims
POTLESS_2 43:5ae8baf28e32 30 #define PIN_V_PILES_ANALOG PA_1
POTLESS_2 59:fd64ca9dae27 31 #define PIN_V_PILES_DIGI PC_3
POTLESS_2 43:5ae8baf28e32 32 #define PIN_V_USB_DIGI PA_0
POTLESS_2 11:b2feed92584a 33
potless 44:5cd6f84a62ec 34 //#define OUTPUT(...) { NVIC_DisableIRQ(USART3_IRQn); serialMonit.printf(__VA_ARGS__); fflush(stdout);NVIC_EnableIRQ(USART3_IRQn);}
POTLESS_2 56:61b0f4d6a890 35 //#define OUTPUT(...) { NVIC_DisableIRQ(USART2_IRQn); serialMonit.printf(__VA_ARGS__); fflush(stdout);NVIC_EnableIRQ(USART2_IRQn);}
POTLESS_2 57:a0827fa46b03 36 //#define OUTPUT(...) { NVIC_DisableIRQ(OTG_FS_IRQn);serialMonit.printf(__VA_ARGS__); fflush(stdout);NVIC_EnableIRQ(OTG_FS_IRQn);}
POTLESS_2 56:61b0f4d6a890 37 #define OUTPUT(...) { serialMonit.printf(__VA_ARGS__); fflush(stdout);}
POTLESS_2 46:28298df0ac55 38 #define IHM(...) { NVIC_DisableIRQ(USART3_IRQn); display.printf(__VA_ARGS__); fflush(stdout);NVIC_EnableIRQ(USART3_IRQn);}
POTLESS_2 34:26f6e3dbefb9 39
POTLESS_2 25:322ef9488e65 40 //PinName pwm, PinName nSleep, PinName fwd, PinName rev, PinName channelA, PinName channelB, int pulsesPerRev, int Rapport, Encoding encoding = X2_ENCODING
POTLESS_2 56:61b0f4d6a890 41 //Angle 0 -> tuyau fermé, Angle 90 -> tuyau ouvert
POTLESS_2 58:694d4d00407c 42 Faulhaber Servo_Poumon(VOLET_POUMON_ADDR, PWM_SERVO_POUMON, nSleep_SERVO_POUMON, FWD_SERVO_POUMON, REV_SERVO_POUMON, Channel_A_SERVO_POUMON, Channel_B_SERVO_POUMON, 16, 1257, Faulhaber::X2_ENCODING);
POTLESS_2 58:694d4d00407c 43 Faulhaber Servo_Fuite(VOLET_FUITE_ADDR, PWM_SERVO_FUITE, nSleep_SERVO_FUITE, FWD_SERVO_FUITE, REV_SERVO_FUITE, Channel_A_SERVO_FUITE, Channel_B_SERVO_FUITE, 16, 207, Faulhaber::X2_ENCODING);
POTLESS_2 17:bef8abc445f2 44
POTLESS_2 57:a0827fa46b03 45 //Communication USB, OTG_FS
POTLESS_2 57:a0827fa46b03 46 USBSerial serialMonit(0x0483, 0x5740, 0x0001, false);
POTLESS_2 57:a0827fa46b03 47 //USBSerial serialMonit;//Pour pilotes windows Olivier
POTLESS_2 10:aca745a66d51 48
POTLESS_2 57:a0827fa46b03 49 //Moniteur série debug, Serial 2
POTLESS_2 57:a0827fa46b03 50 Serial serial(PA_2, PA_3,115200); // UART2 à décommenter / commenter pour DEBUG et Deep DEBUG
POTLESS_2 43:5ae8baf28e32 51
POTLESS_2 57:a0827fa46b03 52 //Communication avec l'IHM, Serial 3
POTLESS_2 57:a0827fa46b03 53 Serial display(PC_4, PC_5, 115200);
POTLESS_2 4:d84250f67dec 54
POTLESS_2 7:ad15c386e960 55 //Init de la lib ARNSRS;
POTLESS_2 7:ad15c386e960 56 SENSOR_HEAD_REV_B sensors;
potless 2:4a8bf1d53439 57
POTLESS_2 34:26f6e3dbefb9 58 //pour Param Venant du PV
POTLESS_2 42:3591ec9903b4 59 const int sizeParam = 50;
POTLESS_2 11:b2feed92584a 60 char param[sizeParam];
POTLESS_2 11:b2feed92584a 61 volatile int indexParam = 0;
POTLESS_2 6:ebed9093d661 62 bool newParamFlag = false;
potless 2:4a8bf1d53439 63
POTLESS_2 56:61b0f4d6a890 64 //pour Param Venant de l'IHM
POTLESS_2 56:61b0f4d6a890 65 const int sizeIHM = 50;
POTLESS_2 56:61b0f4d6a890 66 char IHM[sizeIHM];
POTLESS_2 56:61b0f4d6a890 67 volatile int indexIHM = 0;
POTLESS_2 56:61b0f4d6a890 68 bool newIHMFlag = false;
POTLESS_2 56:61b0f4d6a890 69
POTLESS_2 43:5ae8baf28e32 70 //Flag PID ON / OFF
POTLESS_2 43:5ae8baf28e32 71 int FLAG_PID = 0;
POTLESS_2 42:3591ec9903b4 72
POTLESS_2 42:3591ec9903b4 73 //Flag pour interrompre l'affichage si on veut...
POTLESS_2 42:3591ec9903b4 74 bool FLAG_AFF = false;
POTLESS_2 25:322ef9488e65 75
POTLESS_2 40:32d89e04ead1 76 //Flag pour envoyer à l'app windev...
POTLESS_2 40:32d89e04ead1 77 bool FLAG_WINDEV = false;
POTLESS_2 40:32d89e04ead1 78
POTLESS_2 43:5ae8baf28e32 79 //Flag pour envoyer à l'IHM...
POTLESS_2 46:28298df0ac55 80 bool FLAG_DISPLAY = true;
POTLESS_2 43:5ae8baf28e32 81
POTLESS_2 29:5b822d18bce6 82 //Flag pour interrompre l'enregistrement si on veut...
POTLESS_2 29:5b822d18bce6 83 bool FLAG_REC = true;
POTLESS_2 29:5b822d18bce6 84
POTLESS_2 33:f5d4bae05f16 85 //Flag pour interrompre les demandes O2 en cours ed calibration...
POTLESS_2 33:f5d4bae05f16 86 bool FLAG_O2 = true;
POTLESS_2 33:f5d4bae05f16 87
POTLESS_2 7:ad15c386e960 88 //Variables de stockage des infos capteurs
POTLESS_2 7:ad15c386e960 89 int co2 = 0;
POTLESS_2 7:ad15c386e960 90 float pression = 0;
POTLESS_2 9:04bfdfc029cb 91 float Temp1 = 0;
POTLESS_2 7:ad15c386e960 92 int ppO2 = 0;
POTLESS_2 7:ad15c386e960 93 int CellO2_1 = 0;
POTLESS_2 7:ad15c386e960 94 int CellO2_2 = 0;
POTLESS_2 36:1f5e2247b073 95
POTLESS_2 18:bfd78c05b589 96 //Variables et constantes OTU
POTLESS_2 58:694d4d00407c 97 Ticker OTU_Ticker;
POTLESS_2 18:bfd78c05b589 98 float OTU = 0;
POTLESS_2 58:694d4d00407c 99 float EXP_OTU = 0.83;
POTLESS_2 18:bfd78c05b589 100
POTLESS_2 17:bef8abc445f2 101 //Mesure du temps d'éxecution du loop
POTLESS_2 7:ad15c386e960 102 Timer REAL_RATE;
POTLESS_2 7:ad15c386e960 103 float RATE = 0;
POTLESS_2 11:b2feed92584a 104 float RATE_TRUE = 0;
POTLESS_2 29:5b822d18bce6 105 float Ref_Time = 2.0; //La durée de la boucle désirée...
POTLESS_2 7:ad15c386e960 106
POTLESS_2 17:bef8abc445f2 107 //HTU21D sur l'I2C
POTLESS_2 8:a750d531b381 108 HTU21D temphumid(PB_9, PB_8); //Temp humid sensor || SDA, SCL
POTLESS_2 9:04bfdfc029cb 109 float Temp2;
POTLESS_2 9:04bfdfc029cb 110 int Humid;
POTLESS_2 9:04bfdfc029cb 111
POTLESS_2 9:04bfdfc029cb 112 //Data LOG
POTLESS_2 9:04bfdfc029cb 113 char to_store[50];
POTLESS_2 9:04bfdfc029cb 114 time_t seconds;
POTLESS_2 25:322ef9488e65 115 char Log_File_Name[] = " ";
POTLESS_2 42:3591ec9903b4 116 int count = 0;
POTLESS_2 42:3591ec9903b4 117 int Max_Log_Size = 1800;//1 heure, 1800 lignes donc à multiplier par la fréquence d'enregistrement, Ref_Time, pour voir combien de temps représente un Log...
POTLESS_2 8:a750d531b381 118
POTLESS_2 10:aca745a66d51 119 //Contrôle des servos
POTLESS_2 56:61b0f4d6a890 120 float Consigne_poumon = HOME_SERVO_POUMON;
POTLESS_2 56:61b0f4d6a890 121 float volet_poumon_Position;
POTLESS_2 56:61b0f4d6a890 122 float Consigne_fuite = HOME_SERVO_FUITE;
POTLESS_2 56:61b0f4d6a890 123 float volet_fuite_Position;
potless 45:61ba3cc4fc55 124 float Volets_Speed = 1;
POTLESS_2 58:694d4d00407c 125 float Volet_DeadBand = 10;
POTLESS_2 10:aca745a66d51 126
POTLESS_2 12:7f3aadd79f89 127 //Paramètre du PID
POTLESS_2 12:7f3aadd79f89 128 float Kc = 40;
POTLESS_2 12:7f3aadd79f89 129 float Ti = 0;
POTLESS_2 12:7f3aadd79f89 130 float Td = 0;
POTLESS_2 12:7f3aadd79f89 131 float RATE_PID = Ref_Time;
POTLESS_2 12:7f3aadd79f89 132 float Commande_PID;
POTLESS_2 43:5ae8baf28e32 133 int consigne = 210;
POTLESS_2 15:efd3b3bf3f37 134 float Max_Input = 1000;
POTLESS_2 15:efd3b3bf3f37 135 float Min_Input = 80;
POTLESS_2 19:cac3761a5d0b 136 float Max_Output = 85;//Vérifier la valeur pour angle à laisser ouvert...
POTLESS_2 19:cac3761a5d0b 137 float Min_Output = 5;
POTLESS_2 10:aca745a66d51 138
POTLESS_2 12:7f3aadd79f89 139 //Init PID
POTLESS_2 17:bef8abc445f2 140 PID control_Servo(Kc, Ti, Td, RATE_PID);
POTLESS_2 10:aca745a66d51 141
POTLESS_2 19:cac3761a5d0b 142 //Boolean du status de l'appareil, en mode SECU ou nominal
POTLESS_2 19:cac3761a5d0b 143 bool EN_MODE_SECU = false;
POTLESS_2 31:231a96d1d1c8 144
POTLESS_2 43:5ae8baf28e32 145 //Test voltage piles
POTLESS_2 43:5ae8baf28e32 146 AnalogIn V_PILES_ANALOG(PIN_V_PILES_ANALOG);
POTLESS_2 31:231a96d1d1c8 147
POTLESS_2 31:231a96d1d1c8 148 int Vusb = 1;
POTLESS_2 31:231a96d1d1c8 149 int VPiles = 1;
POTLESS_2 43:5ae8baf28e32 150 float VPiles_val = 1;
POTLESS_2 18:bfd78c05b589 151
POTLESS_2 58:694d4d00407c 152 bool flag_USB = false;
POTLESS_2 59:fd64ca9dae27 153 bool flag_Piles = false;
POTLESS_2 58:694d4d00407c 154
POTLESS_2 56:61b0f4d6a890 155 //Commande à envoyer à l'IHM
POTLESS_2 56:61b0f4d6a890 156 //0 -> Marche
POTLESS_2 56:61b0f4d6a890 157 //1 -> Au dodo
POTLESS_2 56:61b0f4d6a890 158 //3 -> Big problème
POTLESS_2 56:61b0f4d6a890 159 int Commande_IHM = 0;
potless 48:9ceb095f397a 160
POTLESS_2 43:5ae8baf28e32 161 //Interruption pin
POTLESS_2 59:fd64ca9dae27 162 InterruptIn vpiles_off_on(PIN_V_PILES_DIGI);
POTLESS_2 43:5ae8baf28e32 163 InterruptIn vusb_off_on(PIN_V_USB_DIGI);
POTLESS_2 21:b8900130ca05 164
POTLESS_2 57:a0827fa46b03 165 //Pin enable du régulateur 5 v
POTLESS_2 57:a0827fa46b03 166 DigitalOut E5V(PA_4);
POTLESS_2 57:a0827fa46b03 167
POTLESS_2 57:a0827fa46b03 168 //Pin enable du régulateur 3.3 v
POTLESS_2 58:694d4d00407c 169 DigitalOut E3V(PB_11, PullDown);
POTLESS_2 57:a0827fa46b03 170
POTLESS_2 57:a0827fa46b03 171 //Pin du Buzzer
POTLESS_2 57:a0827fa46b03 172 Beep buzzer(PC_8);
POTLESS_2 57:a0827fa46b03 173
POTLESS_2 57:a0827fa46b03 174
POTLESS_2 58:694d4d00407c 175 /*
POTLESS_2 57:a0827fa46b03 176
POTLESS_2 58:694d4d00407c 177 Pour mémoire, les réglage de priorité des thread
POTLESS_2 56:61b0f4d6a890 178
POTLESS_2 58:694d4d00407c 179 osPriorityIdle = -3, ///< priority: idle (lowest)
POTLESS_2 58:694d4d00407c 180 osPriorityLow = -2, ///< priority: low
POTLESS_2 58:694d4d00407c 181 osPriorityBelowNormal = -1, ///< priority: below normal
POTLESS_2 58:694d4d00407c 182 osPriorityNormal = 0, ///< priority: normal (default)
POTLESS_2 58:694d4d00407c 183 osPriorityAboveNormal = +1, ///< priority: above normal
POTLESS_2 58:694d4d00407c 184 osPriorityHigh = +2, ///< priority: high
POTLESS_2 58:694d4d00407c 185 osPriorityRealtime = +3, ///< priority: realtime (highest)
POTLESS_2 58:694d4d00407c 186 osPriorityError = 0x84 ///< system cannot determine priority or thread has illegal priority
POTLESS_2 58:694d4d00407c 187 */
POTLESS_2 58:694d4d00407c 188
POTLESS_2 58:694d4d00407c 189 //Déclaration des Threads
POTLESS_2 57:a0827fa46b03 190 Thread thread_Secu(osPriorityLow);
POTLESS_2 57:a0827fa46b03 191 Thread thread_Head(osPriorityLow);
POTLESS_2 57:a0827fa46b03 192 Thread thread_Volets_POUMON(osPriorityLow);
POTLESS_2 57:a0827fa46b03 193 Thread thread_Volets_FUITE(osPriorityLow);
POTLESS_2 47:89a088bc8866 194
potless 60:e2922f9e309c 195 void sleepDemande()
POTLESS_2 56:61b0f4d6a890 196 {
potless 61:c3391376ca21 197
potless 61:c3391376ca21 198 OUTPUT("tentative effacage \r\n");
potless 61:c3391376ca21 199 UTILS::EffacePage(2, 30, 1);
potless 61:c3391376ca21 200 OUTPUT("effacage termine \r\n");
potless 61:c3391376ca21 201
potless 61:c3391376ca21 202 UTILS::Write(DFU_ADDR, 0xBABEFACE);
potless 61:c3391376ca21 203 OUTPUT("ecriture babeface realisee\r\n");
potless 61:c3391376ca21 204 while(1);
potless 61:c3391376ca21 205 wait(2);
potless 61:c3391376ca21 206 //debug
potless 61:c3391376ca21 207
potless 61:c3391376ca21 208
potless 60:e2922f9e309c 209 buzzer.beep(1000,0.1);
potless 61:c3391376ca21 210 /*
potless 60:e2922f9e309c 211 wait_ms(100);
potless 60:e2922f9e309c 212 buzzer.beep(1000,0.1);
potless 60:e2922f9e309c 213 wait_ms(100);
potless 60:e2922f9e309c 214 buzzer.beep(1000,0.1);
potless 60:e2922f9e309c 215 wait_ms(100);
potless 60:e2922f9e309c 216 buzzer.beep(1000,0.1);
potless 60:e2922f9e309c 217 wait(1);
potless 61:c3391376ca21 218 */
potless 61:c3391376ca21 219
potless 61:c3391376ca21 220 OUTPUT("sleep demande\r\n");
potless 60:e2922f9e309c 221
potless 60:e2922f9e309c 222 Commande_IHM = 1;
potless 60:e2922f9e309c 223 IHM("<0 0 ;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;%d>\r\n", Commande_IHM);
potless 60:e2922f9e309c 224 FLAG_DISPLAY = false;
potless 60:e2922f9e309c 225 Commande_IHM = 0;
potless 61:c3391376ca21 226 wait(1);
potless 61:c3391376ca21 227 OUTPUT("extinction ecran demande\r\n");
POTLESS_2 59:fd64ca9dae27 228
potless 61:c3391376ca21 229 // mise à zero UART IHM pour éviter son redémarrage intempestif (le tx suffirait)
potless 61:c3391376ca21 230 HAL_PWREx_EnablePullUpPullDownConfig() ;
potless 61:c3391376ca21 231 OUTPUT("Enable pulldownconfig fait \r\n");
potless 61:c3391376ca21 232 HAL_PWREx_EnableGPIOPullDown(PWR_GPIO_C, PWR_GPIO_BIT_4);
potless 61:c3391376ca21 233 OUTPUT("bit 4 pulldown fait \r\n");
potless 61:c3391376ca21 234 HAL_PWREx_EnableGPIOPullDown(PWR_GPIO_C, PWR_GPIO_BIT_5);
potless 61:c3391376ca21 235 OUTPUT("bit 5 pulldown fait \r\n");
potless 61:c3391376ca21 236
POTLESS_2 59:fd64ca9dae27 237
POTLESS_2 59:fd64ca9dae27 238 //Mise en veille
POTLESS_2 59:fd64ca9dae27 239 HAL_PWREx_EnablePullUpPullDownConfig() ;
POTLESS_2 59:fd64ca9dae27 240 HAL_PWREx_EnableGPIOPullDown(PWR_GPIO_A, PWR_GPIO_BIT_0);
potless 60:e2922f9e309c 241 HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1_LOW); // pour PA_0
POTLESS_2 59:fd64ca9dae27 242 // Clear wake up Flag
POTLESS_2 59:fd64ca9dae27 243 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WUF1);
POTLESS_2 59:fd64ca9dae27 244 // Enable wakeup pin WKUP2
potless 60:e2922f9e309c 245 HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1_LOW); // high est la valeur par défaut
POTLESS_2 59:fd64ca9dae27 246 // Set RTC back-up register RTC_BKP31R to indicate
POTLESS_2 59:fd64ca9dae27 247 //later on that system has entered shutdown mode
POTLESS_2 59:fd64ca9dae27 248 WRITE_REG( RTC->BKP31R, 0x1 );
POTLESS_2 59:fd64ca9dae27 249 //Enter shutdown mode
POTLESS_2 59:fd64ca9dae27 250 HAL_PWREx_EnterSHUTDOWNMode();
potless 61:c3391376ca21 251
POTLESS_2 56:61b0f4d6a890 252 }
POTLESS_2 58:694d4d00407c 253
potless 60:e2922f9e309c 254
potless 60:e2922f9e309c 255 // gestion du cas où le sleep est demandé volontairement
potless 60:e2922f9e309c 256 // et où l'utilisateur coupe ensuite l'alimentation en débranchant ou interrupteur sur off
potless 61:c3391376ca21 257 // on refait un shutdown mais avec un wake up HIGH sur le branchement du cable + interrupteur sur ON
potless 60:e2922f9e309c 258 void flagSleep(){
potless 60:e2922f9e309c 259
potless 60:e2922f9e309c 260 if ((int) UTILS::Read(DFU_ADDR) == 0xBABEFACE ) {
potless 60:e2922f9e309c 261 Commande_IHM = 1;
potless 60:e2922f9e309c 262 IHM("<0 0 ;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;%d>\r\n", Commande_IHM);
potless 60:e2922f9e309c 263 FLAG_DISPLAY = false;
potless 60:e2922f9e309c 264 Commande_IHM = 0;
potless 60:e2922f9e309c 265
potless 61:c3391376ca21 266 // on tire vers le bas le RX / TX de l'écran pour ne pas qu'il redémarre
potless 60:e2922f9e309c 267 HAL_PWREx_EnableGPIOPullDown(PWR_GPIO_C, PWR_GPIO_BIT_4);
potless 60:e2922f9e309c 268 HAL_PWREx_EnableGPIOPullDown(PWR_GPIO_C, PWR_GPIO_BIT_5);
potless 61:c3391376ca21 269
potless 61:c3391376ca21 270 //debug
potless 61:c3391376ca21 271 while(1);
potless 61:c3391376ca21 272
potless 61:c3391376ca21 273 // on efface le BABEFACE
potless 60:e2922f9e309c 274 UTILS::EffacePage(2, 29, 1);
potless 61:c3391376ca21 275
potless 61:c3391376ca21 276 // on reconfigure le wake up sur HIGH pour un redémarrage normal en rebranchant le cable
potless 60:e2922f9e309c 277 HAL_PWREx_EnablePullUpPullDownConfig() ;
potless 60:e2922f9e309c 278 HAL_PWREx_EnableGPIOPullDown(PWR_GPIO_A, PWR_GPIO_BIT_0);
potless 60:e2922f9e309c 279 HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1); // pour PA_0
potless 60:e2922f9e309c 280 // Clear wake up Flag
potless 60:e2922f9e309c 281 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WUF1);
potless 60:e2922f9e309c 282 // Enable wakeup pin WKUP2
potless 60:e2922f9e309c 283 HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1); // high est la valeur par défaut
potless 60:e2922f9e309c 284 // Set RTC back-up register RTC_BKP31R to indicate
potless 60:e2922f9e309c 285 //later on that system has entered shutdown mode
potless 60:e2922f9e309c 286 WRITE_REG( RTC->BKP31R, 0x1 );
potless 60:e2922f9e309c 287
potless 60:e2922f9e309c 288 //Enter shutdown mode
potless 61:c3391376ca21 289 E3V=0;
potless 60:e2922f9e309c 290 //HAL_PWREx_EnterSHUTDOWNMode();
potless 60:e2922f9e309c 291 }
potless 60:e2922f9e309c 292
potless 60:e2922f9e309c 293 }
potless 60:e2922f9e309c 294
potless 60:e2922f9e309c 295 void USB_unplugged()
POTLESS_2 56:61b0f4d6a890 296 {
POTLESS_2 56:61b0f4d6a890 297 DEBUG(" La prise USB a été débranchée.\n");
potless 61:c3391376ca21 298
potless 61:c3391376ca21 299 //buzzer.beep(1000,0.3); // ce beep semble etrangement long
potless 61:c3391376ca21 300
POTLESS_2 56:61b0f4d6a890 301 //Arrêt des enregistrements
POTLESS_2 56:61b0f4d6a890 302 FLAG_REC = false;
POTLESS_2 58:694d4d00407c 303
POTLESS_2 59:fd64ca9dae27 304 UTILS::UnMount_Flash();
POTLESS_2 59:fd64ca9dae27 305
POTLESS_2 56:61b0f4d6a890 306 //Enregistrement position des servos sans mettre en sécu
POTLESS_2 58:694d4d00407c 307 UTILS::EffacePage(2, 31, 1);
POTLESS_2 59:fd64ca9dae27 308
POTLESS_2 58:694d4d00407c 309 uint64_t Pos_P = Servo_Poumon.getPulses();
POTLESS_2 58:694d4d00407c 310 UTILS::Write(VOLET_POUMON_ADDR, Pos_P);
POTLESS_2 58:694d4d00407c 311 DEBUG(" position volet poumon sauvegardée = %d pulse(s)\r\n", (int) Pos_P);
POTLESS_2 57:a0827fa46b03 312
POTLESS_2 58:694d4d00407c 313 uint64_t Pos_F = Servo_Fuite.getPulses();
POTLESS_2 58:694d4d00407c 314 UTILS::Write(VOLET_FUITE_ADDR, Pos_F);
POTLESS_2 58:694d4d00407c 315 DEBUG(" position volet fuite sauvegardée = %d pulse(s)\r\n", (int) Pos_F);
POTLESS_2 59:fd64ca9dae27 316
POTLESS_2 59:fd64ca9dae27 317 //Mise en veille de l'IHM
POTLESS_2 59:fd64ca9dae27 318 Commande_IHM = 1;
POTLESS_2 59:fd64ca9dae27 319 IHM("<0 0 ;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;%d>\r\n", Commande_IHM);
POTLESS_2 59:fd64ca9dae27 320 FLAG_DISPLAY = false;
POTLESS_2 59:fd64ca9dae27 321 Commande_IHM = 0;
potless 60:e2922f9e309c 322
potless 60:e2922f9e309c 323 // mise à zero UART IHM pour éviter son redémarrage intempestif (le tx suffirait)
potless 60:e2922f9e309c 324 HAL_PWREx_EnableGPIOPullDown(PWR_GPIO_C, PWR_GPIO_BIT_4);
potless 60:e2922f9e309c 325 HAL_PWREx_EnableGPIOPullDown(PWR_GPIO_C, PWR_GPIO_BIT_5);
POTLESS_2 59:fd64ca9dae27 326
potless 60:e2922f9e309c 327 //Mise en veille version cable arraché
potless 61:c3391376ca21 328 DEBUG(" Mise en veille, suite coupure alimentation...\r\n");
POTLESS_2 59:fd64ca9dae27 329 //wait(1);
potless 60:e2922f9e309c 330 //Mise en veille
potless 60:e2922f9e309c 331 HAL_PWREx_EnablePullUpPullDownConfig() ;
potless 60:e2922f9e309c 332 HAL_PWREx_EnableGPIOPullDown(PWR_GPIO_A, PWR_GPIO_BIT_0);
potless 60:e2922f9e309c 333 HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1); // pour PA_0
potless 60:e2922f9e309c 334 // Clear wake up Flag
potless 60:e2922f9e309c 335 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WUF1);
potless 60:e2922f9e309c 336 // Enable wakeup pin WKUP2
potless 60:e2922f9e309c 337 HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1); // high est la valeur par défaut
potless 60:e2922f9e309c 338 // Set RTC back-up register RTC_BKP31R to indicate
potless 60:e2922f9e309c 339 //later on that system has entered shutdown mode
potless 60:e2922f9e309c 340 WRITE_REG( RTC->BKP31R, 0x1 );
potless 60:e2922f9e309c 341 //Enter shutdown mode
potless 60:e2922f9e309c 342 HAL_PWREx_EnterSHUTDOWNMode();
POTLESS_2 56:61b0f4d6a890 343 }
POTLESS_2 58:694d4d00407c 344
potless 61:c3391376ca21 345 void PILES_unplugged()
POTLESS_2 52:4e36a88711d6 346 {
POTLESS_2 59:fd64ca9dae27 347 DEBUG(" Les piles ont été débranchées.\n");
potless 61:c3391376ca21 348 E5V=1;
POTLESS_2 59:fd64ca9dae27 349 buzzer.beep(1000,0.3);
POTLESS_2 59:fd64ca9dae27 350 wait_ms(500);
POTLESS_2 59:fd64ca9dae27 351 buzzer.beep(1000,0.3);
potless 54:2062e5786a66 352 wait(1);
potless 61:c3391376ca21 353 E5V=0;
POTLESS_2 59:fd64ca9dae27 354 //Arrêt des enregistrements
POTLESS_2 59:fd64ca9dae27 355 FLAG_REC = false;
POTLESS_2 59:fd64ca9dae27 356
POTLESS_2 59:fd64ca9dae27 357 UTILS::UnMount_Flash();
POTLESS_2 59:fd64ca9dae27 358
POTLESS_2 59:fd64ca9dae27 359 //Enregistrement position des servos sans mettre en sécu
POTLESS_2 59:fd64ca9dae27 360 UTILS::EffacePage(2, 31, 1);
POTLESS_2 59:fd64ca9dae27 361
POTLESS_2 59:fd64ca9dae27 362 uint64_t Pos_P = Servo_Poumon.getPulses();
POTLESS_2 59:fd64ca9dae27 363 UTILS::Write(VOLET_POUMON_ADDR, Pos_P);
POTLESS_2 59:fd64ca9dae27 364 DEBUG(" position volet poumon sauvegardée = %d pulse(s)\r\n", (int) Pos_P);
POTLESS_2 52:4e36a88711d6 365
POTLESS_2 59:fd64ca9dae27 366 uint64_t Pos_F = Servo_Fuite.getPulses();
POTLESS_2 59:fd64ca9dae27 367 UTILS::Write(VOLET_FUITE_ADDR, Pos_F);
POTLESS_2 59:fd64ca9dae27 368 DEBUG(" position volet fuite sauvegardée = %d pulse(s)\r\n", (int) Pos_F);
POTLESS_2 59:fd64ca9dae27 369
POTLESS_2 59:fd64ca9dae27 370 //Mise en veille de l'IHM
POTLESS_2 59:fd64ca9dae27 371 Commande_IHM = 1;
POTLESS_2 59:fd64ca9dae27 372 IHM("<0 0 ;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;%d>\r\n", Commande_IHM);
POTLESS_2 59:fd64ca9dae27 373 FLAG_DISPLAY = false;
POTLESS_2 59:fd64ca9dae27 374 Commande_IHM = 0;
POTLESS_2 59:fd64ca9dae27 375
POTLESS_2 59:fd64ca9dae27 376 //Mise en veille
POTLESS_2 59:fd64ca9dae27 377 DEBUG(" Mise en veille...\r\n");
POTLESS_2 59:fd64ca9dae27 378 //wait(1);
potless 61:c3391376ca21 379 //Mise en veille
potless 61:c3391376ca21 380 HAL_PWREx_EnablePullUpPullDownConfig() ;
potless 61:c3391376ca21 381 HAL_PWREx_EnableGPIOPullDown(PWR_GPIO_A, PWR_GPIO_BIT_0);
potless 61:c3391376ca21 382 HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1); // pour PA_0
potless 61:c3391376ca21 383 // Clear wake up Flag
potless 61:c3391376ca21 384 __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WUF1);
potless 61:c3391376ca21 385 // Enable wakeup pin WKUP2
potless 61:c3391376ca21 386 HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1); // high est la valeur par défaut
potless 61:c3391376ca21 387 // Set RTC back-up register RTC_BKP31R to indicate
potless 61:c3391376ca21 388 //later on that system has entered shutdown mode
potless 61:c3391376ca21 389 WRITE_REG( RTC->BKP31R, 0x1 );
potless 61:c3391376ca21 390 //Enter shutdown mode
potless 61:c3391376ca21 391 HAL_PWREx_EnterSHUTDOWNMode();
POTLESS_2 52:4e36a88711d6 392 }
POTLESS_2 47:89a088bc8866 393
POTLESS_2 29:5b822d18bce6 394 void Affichage()
POTLESS_2 53:84571a5e2cda 395 {
POTLESS_2 42:3591ec9903b4 396 //serialMonit.printf("\r\n");
POTLESS_2 29:5b822d18bce6 397 serialMonit.printf(" CO2 = %d ppm\r\n" , co2);
POTLESS_2 29:5b822d18bce6 398 serialMonit.printf(" PPO2 = %d mb\r\n", ppO2);
POTLESS_2 31:231a96d1d1c8 399 serialMonit.printf(" OTU = %d \r\n", (int)OTU);
POTLESS_2 29:5b822d18bce6 400 serialMonit.printf(" Pression = %f msw\r\n", pression);
POTLESS_2 29:5b822d18bce6 401 serialMonit.printf(" Temp MS5837 = %f C\r\n", Temp1);
POTLESS_2 29:5b822d18bce6 402 serialMonit.printf(" Temp HTU21D = %f C\n\r", Temp2);
POTLESS_2 29:5b822d18bce6 403 serialMonit.printf(" Humidity = %d %%\n\r", Humid);
POTLESS_2 42:3591ec9903b4 404 //serialMonit.printf("\n\r");
POTLESS_2 29:5b822d18bce6 405 serialMonit.printf(" Cell O2 n 1 = %d\r\n" , CellO2_1);
POTLESS_2 29:5b822d18bce6 406 serialMonit.printf(" Cell O2 n 2 = %d\r\n" , CellO2_2);
POTLESS_2 42:3591ec9903b4 407 //serialMonit.printf("\r\n");
POTLESS_2 29:5b822d18bce6 408 serialMonit.printf(" Volet Poumon = %f\r\n" , volet_poumon_Position);
POTLESS_2 29:5b822d18bce6 409 serialMonit.printf(" Volet Fuite = %f\r\n" , volet_fuite_Position);
POTLESS_2 42:3591ec9903b4 410 //serialMonit.printf("\r\n");
POTLESS_2 42:3591ec9903b4 411 serialMonit.printf(" Temps d execution de la boucle = %f seconde(s)\r\n", (RATE + RATE_TRUE / 1000));
POTLESS_2 42:3591ec9903b4 412 //serialMonit.printf("\r\n");
POTLESS_2 42:3591ec9903b4 413 if (FLAG_REC) serialMonit.printf(" Chaine enregistrée = %s\r\n", to_store);
POTLESS_2 30:7a16a66d76f3 414 else serialMonit.printf(" Pas d'enregistrement en cours.");
POTLESS_2 42:3591ec9903b4 415 //serialMonit.printf("\r\n");
POTLESS_2 42:3591ec9903b4 416 serialMonit.printf(" V_USB = %f\r\n", Vusb);
POTLESS_2 42:3591ec9903b4 417 //serialMonit.printf("\r\n\r\n");
POTLESS_2 29:5b822d18bce6 418 fflush(stdout);
POTLESS_2 29:5b822d18bce6 419 }
POTLESS_2 29:5b822d18bce6 420
potless 38:fe77b68eec37 421
POTLESS_2 19:cac3761a5d0b 422 //Passage en mode SECU
POTLESS_2 19:cac3761a5d0b 423 void Mode_SECU()
POTLESS_2 18:bfd78c05b589 424 {
POTLESS_2 43:5ae8baf28e32 425
POTLESS_2 18:bfd78c05b589 426 //Mise du PID en mode manuel (desactivation...)
POTLESS_2 18:bfd78c05b589 427 control_Servo.setMode(MANUAL_MODE);
POTLESS_2 43:5ae8baf28e32 428
POTLESS_2 19:cac3761a5d0b 429 Consigne_poumon = HOME_SERVO_POUMON;
POTLESS_2 19:cac3761a5d0b 430 Consigne_fuite = HOME_SERVO_FUITE;
POTLESS_2 34:26f6e3dbefb9 431
POTLESS_2 57:a0827fa46b03 432 Volets_Speed = 1;
POTLESS_2 25:322ef9488e65 433 Volet_DeadBand = 10;
POTLESS_2 25:322ef9488e65 434
potless 61:c3391376ca21 435 //todo a decommenter
potless 61:c3391376ca21 436 /*
POTLESS_2 58:694d4d00407c 437 while(1) {
POTLESS_2 58:694d4d00407c 438 wait_ms(100);
POTLESS_2 58:694d4d00407c 439 if (Servo_Poumon.Pos_OK() == true && Servo_Fuite.Pos_OK() == true) break;
POTLESS_2 58:694d4d00407c 440 }
potless 61:c3391376ca21 441 */
POTLESS_2 43:5ae8baf28e32 442
POTLESS_2 43:5ae8baf28e32 443 OUTPUT(" Appareil en mode SECU\r\n");
POTLESS_2 34:26f6e3dbefb9 444
POTLESS_2 25:322ef9488e65 445 wait_ms(100);
POTLESS_2 34:26f6e3dbefb9 446
POTLESS_2 19:cac3761a5d0b 447 EN_MODE_SECU = true;
POTLESS_2 43:5ae8baf28e32 448
POTLESS_2 25:322ef9488e65 449 wait_ms(100);
POTLESS_2 58:694d4d00407c 450
POTLESS_2 58:694d4d00407c 451 /*
POTLESS_2 43:5ae8baf28e32 452 int Pos_P = Servo_Poumon.getPulses();
POTLESS_2 43:5ae8baf28e32 453 UTILS::Store_A_Val((float)Pos_P, "Servo_Poumon.sys");
POTLESS_2 43:5ae8baf28e32 454 DEBUG(" position volet poumon sauvegardée = %d pulse(s)\r\n", Pos_P);
POTLESS_2 47:89a088bc8866 455 OUTPUT(" Volet poumon en sécu\r\n");
POTLESS_2 53:84571a5e2cda 456
POTLESS_2 43:5ae8baf28e32 457 int Pos_F = Servo_Fuite.getPulses();
POTLESS_2 43:5ae8baf28e32 458 UTILS::Store_A_Val((float)Pos_F, "Servo_Fuite.sys");
POTLESS_2 43:5ae8baf28e32 459 DEBUG(" position volet fuite sauvegardée = %d pulse(s)\r\n", Pos_F);
POTLESS_2 47:89a088bc8866 460 OUTPUT(" Volet fuite en sécu\r\n");
POTLESS_2 58:694d4d00407c 461 */
potless 61:c3391376ca21 462
potless 61:c3391376ca21 463 /*
potless 61:c3391376ca21 464 TODO à remettre si servo présents
POTLESS_2 58:694d4d00407c 465 UTILS::EffacePage(2, 31, 1);
POTLESS_2 58:694d4d00407c 466 //Enregistrement position des servos en sécu pour plus de précision
POTLESS_2 58:694d4d00407c 467 uint64_t Pos_P = Servo_Poumon.getPulses();
POTLESS_2 58:694d4d00407c 468 UTILS::Write(VOLET_POUMON_ADDR, Pos_P);
POTLESS_2 58:694d4d00407c 469 DEBUG(" position volet poumon sauvegardée = %d pulse(s)\r\n", (int) Pos_P);
POTLESS_2 58:694d4d00407c 470 OUTPUT(" Volet poumon en sécu\r\n");
POTLESS_2 58:694d4d00407c 471
POTLESS_2 58:694d4d00407c 472 uint64_t Pos_F = Servo_Fuite.getPulses();
POTLESS_2 58:694d4d00407c 473 UTILS::Write(VOLET_FUITE_ADDR, Pos_F);
POTLESS_2 58:694d4d00407c 474 DEBUG(" position volet fuite sauvegardée = %d pulse(s)\r\n",(int) Pos_F);
POTLESS_2 58:694d4d00407c 475 OUTPUT(" Volet fuite en sécu\r\n");
potless 61:c3391376ca21 476
POTLESS_2 23:7477dc855fad 477 Servo_Poumon.Sleep();
POTLESS_2 43:5ae8baf28e32 478 Servo_Fuite.Sleep();
potless 61:c3391376ca21 479 */
POTLESS_2 19:cac3761a5d0b 480 }
POTLESS_2 19:cac3761a5d0b 481
POTLESS_2 19:cac3761a5d0b 482 //Sequence d'arrêt
POTLESS_2 19:cac3761a5d0b 483 void Stop_Sequence()
POTLESS_2 34:26f6e3dbefb9 484 {
POTLESS_2 43:5ae8baf28e32 485 OUTPUT(" Mise en veille de l'appareil.\r\n");
POTLESS_2 43:5ae8baf28e32 486
POTLESS_2 43:5ae8baf28e32 487 wait(1);
potless 61:c3391376ca21 488
POTLESS_2 34:26f6e3dbefb9 489 Mode_SECU();
potless 61:c3391376ca21 490
potless 61:c3391376ca21 491 OUTPUT(" retour Mise en veille de l'appareil.\r\n");
POTLESS_2 53:84571a5e2cda 492
POTLESS_2 47:89a088bc8866 493 wait(1);
POTLESS_2 58:694d4d00407c 494
POTLESS_2 39:65ff3c4f9675 495 //ejection de la flash pour pas crasher le system de fichiers
POTLESS_2 39:65ff3c4f9675 496 UTILS::UnMount_Flash();
POTLESS_2 53:84571a5e2cda 497
POTLESS_2 47:89a088bc8866 498 OUTPUT(" Ejection de la Flash\r\n");
POTLESS_2 56:61b0f4d6a890 499
POTLESS_2 47:89a088bc8866 500 wait(1);
POTLESS_2 58:694d4d00407c 501
potless 60:e2922f9e309c 502 sleepDemande();
POTLESS_2 18:bfd78c05b589 503 }
POTLESS_2 18:bfd78c05b589 504
POTLESS_2 31:231a96d1d1c8 505 //Fonction test de valeur d'entrée digitale
POTLESS_2 29:5b822d18bce6 506 int Power_Test(DigitalIn& pin)
POTLESS_2 20:5f79fb4565a7 507 {
POTLESS_2 29:5b822d18bce6 508 pin.mode(PullDown);
POTLESS_2 34:26f6e3dbefb9 509
POTLESS_2 34:26f6e3dbefb9 510 if(!pin) {
POTLESS_2 34:26f6e3dbefb9 511 Stop_Sequence();
POTLESS_2 34:26f6e3dbefb9 512 return 0;
POTLESS_2 34:26f6e3dbefb9 513 } else {
POTLESS_2 34:26f6e3dbefb9 514 return 1;
POTLESS_2 34:26f6e3dbefb9 515 }
POTLESS_2 20:5f79fb4565a7 516 }
POTLESS_2 20:5f79fb4565a7 517
POTLESS_2 31:231a96d1d1c8 518 //Fonction test de valeur d'entrée analogique
POTLESS_2 31:231a96d1d1c8 519 float Power_Test(AnalogIn& pin)
POTLESS_2 31:231a96d1d1c8 520 {
POTLESS_2 31:231a96d1d1c8 521 float Val = pin.read();
POTLESS_2 31:231a96d1d1c8 522 return Val;
POTLESS_2 31:231a96d1d1c8 523 }
POTLESS_2 31:231a96d1d1c8 524
POTLESS_2 18:bfd78c05b589 525 //Contrôle du status de l'appareil / des constantes
POTLESS_2 18:bfd78c05b589 526 bool Check()
POTLESS_2 18:bfd78c05b589 527 {
POTLESS_2 18:bfd78c05b589 528 if (ppO2 > 100)
POTLESS_2 19:cac3761a5d0b 529 return true;//Situation OK
POTLESS_2 18:bfd78c05b589 530 else
POTLESS_2 19:cac3761a5d0b 531 return false;//Situation dégradée
POTLESS_2 18:bfd78c05b589 532 }
POTLESS_2 18:bfd78c05b589 533
POTLESS_2 18:bfd78c05b589 534 //Calcul des OTU
POTLESS_2 58:694d4d00407c 535 void Calcul_OTU()
POTLESS_2 18:bfd78c05b589 536 {
POTLESS_2 18:bfd78c05b589 537 /*
POTLESS_2 18:bfd78c05b589 538 La formule suivante permet de calculer la quantité d' OTU accumulée
POTLESS_2 18:bfd78c05b589 539 OTU = T * (2* PpO2 -1)0,83
POTLESS_2 18:bfd78c05b589 540 avec :
POTLESS_2 18:bfd78c05b589 541 T = temps de plongée en minutes
POTLESS_2 18:bfd78c05b589 542 PpO2 = pression partielle d’ oxygène en bars
POTLESS_2 18:bfd78c05b589 543 */
POTLESS_2 18:bfd78c05b589 544
POTLESS_2 19:cac3761a5d0b 545 if (ppO2 > 500) {
POTLESS_2 18:bfd78c05b589 546 float val = (2 * (float)ppO2/1000 - 1);//je divise par 1000 car la PP est en mb...
POTLESS_2 58:694d4d00407c 547 OTU += pow(val, EXP_OTU);//T = 1 car le ticker est executé toutes les 60 secondes, 1 minute....
POTLESS_2 19:cac3761a5d0b 548 }
POTLESS_2 18:bfd78c05b589 549 }
POTLESS_2 10:aca745a66d51 550
POTLESS_2 17:bef8abc445f2 551 //Thread d'intérogation des capteurs, positions servo
POTLESS_2 34:26f6e3dbefb9 552 void SENSORS_thread()
POTLESS_2 6:ebed9093d661 553 {
POTLESS_2 7:ad15c386e960 554 while (true) {
POTLESS_2 36:1f5e2247b073 555 //DEEP_DEBUG(" SENSORS_thread\r\n");
POTLESS_2 7:ad15c386e960 556
POTLESS_2 7:ad15c386e960 557 //CO2 sur Cozir
POTLESS_2 7:ad15c386e960 558 co2 = sensors.requestCO2();
POTLESS_2 7:ad15c386e960 559 //P / T sur MS5837
POTLESS_2 7:ad15c386e960 560 pression = sensors.requestPress();
POTLESS_2 9:04bfdfc029cb 561 Temp1 = sensors.requestTemp();
POTLESS_2 7:ad15c386e960 562 //PPO2 sur ADS1015
POTLESS_2 33:f5d4bae05f16 563 if (FLAG_O2) ppO2 = sensors.requestPpO2();
POTLESS_2 7:ad15c386e960 564 //Cell O2 en mV
POTLESS_2 33:f5d4bae05f16 565 if (FLAG_O2) CellO2_1 = sensors.requestCellO2_1();
POTLESS_2 33:f5d4bae05f16 566 if (FLAG_O2) CellO2_2 = sensors.requestCellO2_2();
POTLESS_2 9:04bfdfc029cb 567
POTLESS_2 8:a750d531b381 568 //HTU21D
POTLESS_2 9:04bfdfc029cb 569 Temp2 = temphumid.sample_ctemp();
POTLESS_2 9:04bfdfc029cb 570 Humid = temphumid.sample_humid();
POTLESS_2 9:04bfdfc029cb 571
POTLESS_2 10:aca745a66d51 572 //Retour position des servos
POTLESS_2 17:bef8abc445f2 573 volet_poumon_Position = Servo_Poumon.Get_Position();
POTLESS_2 43:5ae8baf28e32 574 volet_fuite_Position = Servo_Fuite.Get_Position();
POTLESS_2 43:5ae8baf28e32 575
POTLESS_2 43:5ae8baf28e32 576 //Calcul des OTU
POTLESS_2 58:694d4d00407c 577 //Calcul_OTU();
POTLESS_2 34:26f6e3dbefb9 578
POTLESS_2 19:cac3761a5d0b 579 }
POTLESS_2 19:cac3761a5d0b 580 }
POTLESS_2 12:7f3aadd79f89 581
POTLESS_2 57:a0827fa46b03 582 void GO_TO_thread_POUMON()
POTLESS_2 19:cac3761a5d0b 583 {
POTLESS_2 19:cac3761a5d0b 584 while (true) {
POTLESS_2 57:a0827fa46b03 585 //DEEP_DEBUG(" GO_TO_Thread_POUMON\r\n");
POTLESS_2 34:26f6e3dbefb9 586
POTLESS_2 19:cac3761a5d0b 587 //Servo_Poumon.Go_To_Prop(Consigne_poumon);
POTLESS_2 26:a2fe19341f92 588 //Servo_Poumon.Go_To_PID(Consigne_poumon, Volet_DeadBand);
POTLESS_2 34:26f6e3dbefb9 589 Servo_Poumon.Go_To(Consigne_poumon, Volets_Speed, Volet_DeadBand);
POTLESS_2 57:a0827fa46b03 590 }
POTLESS_2 57:a0827fa46b03 591 }
POTLESS_2 57:a0827fa46b03 592
POTLESS_2 57:a0827fa46b03 593 void GO_TO_thread_FUITE()
POTLESS_2 57:a0827fa46b03 594 {
POTLESS_2 57:a0827fa46b03 595 while (true) {
POTLESS_2 57:a0827fa46b03 596 //DEEP_DEBUG(" GO_TO_Thread_FUITE\r\n");
POTLESS_2 34:26f6e3dbefb9 597
POTLESS_2 19:cac3761a5d0b 598 //Servo_Fuite.Go_To_Prop(Consigne_fuite);
POTLESS_2 43:5ae8baf28e32 599 //Servo_Fuite.Go_To_PID(Consigne_fuite, Volet_DeadBand);
POTLESS_2 57:a0827fa46b03 600 Servo_Fuite.Go_To(Consigne_fuite, Volets_Speed, Volet_DeadBand);
POTLESS_2 15:efd3b3bf3f37 601 }
potless 2:4a8bf1d53439 602 }
POTLESS_2 4:d84250f67dec 603
POTLESS_2 20:5f79fb4565a7 604 void SECU_thread()
POTLESS_2 20:5f79fb4565a7 605 {
POTLESS_2 34:26f6e3dbefb9 606 while (true) {
POTLESS_2 58:694d4d00407c 607 //Mettre toutes les vérifs de sécu....
POTLESS_2 20:5f79fb4565a7 608 }
POTLESS_2 20:5f79fb4565a7 609 }
POTLESS_2 20:5f79fb4565a7 610
POTLESS_2 57:a0827fa46b03 611 //Callback de l'intérruption des envois de commandes depuis le terminal / WINDEV
POTLESS_2 6:ebed9093d661 612 void callbackParam()
POTLESS_2 34:26f6e3dbefb9 613 {
POTLESS_2 40:32d89e04ead1 614
POTLESS_2 34:26f6e3dbefb9 615 while(serialMonit.readable()) {
POTLESS_2 40:32d89e04ead1 616 if ((indexParam == sizeParam) || newParamFlag == true) { //éviter la saturation du buffer
POTLESS_2 29:5b822d18bce6 617 char char_flush = serialMonit.getc();
POTLESS_2 40:32d89e04ead1 618 } else {
POTLESS_2 29:5b822d18bce6 619 param [indexParam ++] = serialMonit.getc();//chargement du buffer dans le message
POTLESS_2 40:32d89e04ead1 620 if ((indexParam == sizeParam) || (param[indexParam - 1] == '\n')) {//le message est complet ou nouvelle ligne ou autre si on veut...
POTLESS_2 40:32d89e04ead1 621 param[indexParam] = 0;
POTLESS_2 40:32d89e04ead1 622 newParamFlag = true;
POTLESS_2 40:32d89e04ead1 623 }
POTLESS_2 56:61b0f4d6a890 624 }
POTLESS_2 56:61b0f4d6a890 625 }
POTLESS_2 56:61b0f4d6a890 626 }
POTLESS_2 56:61b0f4d6a890 627
POTLESS_2 56:61b0f4d6a890 628 //Callback de l'intérruption des envois de commandes depuis l'IHM
POTLESS_2 56:61b0f4d6a890 629 void callbackIHM()
POTLESS_2 56:61b0f4d6a890 630 {
POTLESS_2 56:61b0f4d6a890 631
POTLESS_2 56:61b0f4d6a890 632 while(display.readable()) {
POTLESS_2 56:61b0f4d6a890 633 if ((indexIHM == sizeIHM) || newIHMFlag == true) { //éviter la saturation du buffer
POTLESS_2 58:694d4d00407c 634 NVIC_DisableIRQ(USART3_IRQn);
POTLESS_2 56:61b0f4d6a890 635 char char_flush = display.getc();
POTLESS_2 56:61b0f4d6a890 636 NVIC_EnableIRQ(USART3_IRQn);
POTLESS_2 56:61b0f4d6a890 637 } else {
POTLESS_2 56:61b0f4d6a890 638 NVIC_DisableIRQ(USART3_IRQn);
POTLESS_2 56:61b0f4d6a890 639 IHM [indexIHM ++] = display.getc();//chargement du buffer dans le message
POTLESS_2 56:61b0f4d6a890 640 if ((indexIHM == sizeIHM) || (IHM[indexIHM - 1] == '\n')) {//le message est complet ou nouvelle ligne ou autre si on veut...
POTLESS_2 56:61b0f4d6a890 641 IHM[indexIHM] = 0;
POTLESS_2 56:61b0f4d6a890 642 newIHMFlag = true;
POTLESS_2 56:61b0f4d6a890 643 }
POTLESS_2 56:61b0f4d6a890 644 NVIC_EnableIRQ(USART3_IRQn);
POTLESS_2 34:26f6e3dbefb9 645 }
POTLESS_2 34:26f6e3dbefb9 646 }
POTLESS_2 6:ebed9093d661 647 }
POTLESS_2 4:d84250f67dec 648
POTLESS_2 9:04bfdfc029cb 649 void Decoding_Message(char message [])
POTLESS_2 9:04bfdfc029cb 650 {
POTLESS_2 9:04bfdfc029cb 651
POTLESS_2 42:3591ec9903b4 652 char com[20] = "";
POTLESS_2 42:3591ec9903b4 653 char numb[30] = "";
POTLESS_2 36:1f5e2247b073 654
POTLESS_2 34:26f6e3dbefb9 655 sscanf(message,"%s %s",&com , &numb);
POTLESS_2 36:1f5e2247b073 656
POTLESS_2 56:61b0f4d6a890 657 DEBUG("\r\n Commande = %s Valeur = %s \r\n\r\n", com, numb);
POTLESS_2 36:1f5e2247b073 658
POTLESS_2 43:5ae8baf28e32 659 OUTPUT("?\r\n");
POTLESS_2 43:5ae8baf28e32 660
POTLESS_2 30:7a16a66d76f3 661 if (0 == strcmp(com, "secu")) {
POTLESS_2 19:cac3761a5d0b 662 Mode_SECU();
POTLESS_2 42:3591ec9903b4 663 } else if (0 == strcmp(com, "PING")) {
POTLESS_2 56:61b0f4d6a890 664 Commande_IHM = 1;
POTLESS_2 56:61b0f4d6a890 665 IHM("<0 0 ;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;%d>\r\n", Commande_IHM);
POTLESS_2 57:a0827fa46b03 666 FLAG_DISPLAY = false;
POTLESS_2 59:fd64ca9dae27 667 Commande_IHM = 0;
POTLESS_2 34:26f6e3dbefb9 668 } else if (0 == strcmp(com, "ARNSRS_ID")) {
POTLESS_2 58:694d4d00407c 669 OUTPUT(" Changement de l'ID de l'appareil pour le N°: %s\r\n", numb);
POTLESS_2 58:694d4d00407c 670 //UTILS::Store_A_Val(atoi(numb), "ARNSRS_ID");
POTLESS_2 58:694d4d00407c 671 UTILS::EffacePage(2, 30, 1);
POTLESS_2 58:694d4d00407c 672 UTILS::Write(ID_ARNSRS_ADDR, (uint64_t) atoi(numb));
POTLESS_2 43:5ae8baf28e32 673 } else if (0 == strcmp(com, "monit")) {
POTLESS_2 43:5ae8baf28e32 674 FLAG_AFF = false;
POTLESS_2 43:5ae8baf28e32 675 FLAG_WINDEV = true;
POTLESS_2 43:5ae8baf28e32 676 } else if (0 == strcmp(com, "debug")) {
POTLESS_2 43:5ae8baf28e32 677 FLAG_AFF = false;
POTLESS_2 43:5ae8baf28e32 678 FLAG_WINDEV = false;
POTLESS_2 34:26f6e3dbefb9 679 } else if (0 == strcmp(com, "Head_ID")) {
POTLESS_2 34:26f6e3dbefb9 680 //On l'enregistre dans l'eeprom
POTLESS_2 43:5ae8baf28e32 681 OUTPUT("Changement de l'ID de la tête capteur pour le N°: %s\r\n", numb);
POTLESS_2 34:26f6e3dbefb9 682 UTILS::write_EEPROM(numb, HEAD_ID);
POTLESS_2 34:26f6e3dbefb9 683 } else if (0 == strcmp(com, "O2_1_ID")) {
POTLESS_2 34:26f6e3dbefb9 684 //On l'enregistre dans l'eeprom
POTLESS_2 34:26f6e3dbefb9 685 UTILS::write_EEPROM(numb, CELL_O2_1_ID);
POTLESS_2 34:26f6e3dbefb9 686 } else if (0 == strcmp(com, "O2_2_ID")) {
POTLESS_2 34:26f6e3dbefb9 687 //On l'enregistre dans l'eeprom
POTLESS_2 34:26f6e3dbefb9 688 UTILS::write_EEPROM(numb, CELL_O2_2_ID);
POTLESS_2 34:26f6e3dbefb9 689 } else if (0 == strcmp(com, "CO2_ID")) {
POTLESS_2 34:26f6e3dbefb9 690 //On l'enregistre dans l'eeprom
POTLESS_2 34:26f6e3dbefb9 691 UTILS::write_EEPROM(numb, CO2_ID);
POTLESS_2 34:26f6e3dbefb9 692 } else if (0 == strcmp(com, "calib_O2")) {
POTLESS_2 33:f5d4bae05f16 693 FLAG_O2 = false;
POTLESS_2 33:f5d4bae05f16 694 wait_ms(100);
POTLESS_2 42:3591ec9903b4 695 float Val = sensors.Calibrate_O2(atoi(numb));
POTLESS_2 43:5ae8baf28e32 696 OUTPUT(" Calibration O2 dans l'air = %f\r\n", Val);
POTLESS_2 33:f5d4bae05f16 697 wait_ms(100);
POTLESS_2 33:f5d4bae05f16 698 FLAG_O2 = true;
POTLESS_2 41:51ba69648f9d 699 } else if (0 == strcmp(com, "calib_CO2_A")) {
POTLESS_2 43:5ae8baf28e32 700 int Val = sensors.Calibrate_CO2();
POTLESS_2 43:5ae8baf28e32 701 OUTPUT(" Calibration CO2 dans l'air = %d\r\n", Val);
POTLESS_2 34:26f6e3dbefb9 702 } else if (0 == strcmp(com, "flash_i")) {
POTLESS_2 42:3591ec9903b4 703 UTILS::Flash_Infos(&serialMonit);
POTLESS_2 36:1f5e2247b073 704 } else if (0 == strcmp(com, "flash_u")) {
POTLESS_2 43:5ae8baf28e32 705 OUTPUT(" Démontage de la Flash.\r\n");
POTLESS_2 36:1f5e2247b073 706 FLAG_REC = false;
POTLESS_2 36:1f5e2247b073 707 UTILS::UnMount_Flash();
POTLESS_2 36:1f5e2247b073 708 } else if (0 == strcmp(com, "flash_m")) {
POTLESS_2 43:5ae8baf28e32 709 OUTPUT(" Montage de la Flash.\r\n");
POTLESS_2 40:32d89e04ead1 710 UTILS::Mount_Flash();
POTLESS_2 35:a209a192f431 711 } else if (0 == strcmp(com, "check_F")) {
POTLESS_2 58:694d4d00407c 712 /*
POTLESS_2 43:5ae8baf28e32 713 OUTPUT(" ARNSRS_ID.sys = %d\r\n", (int)UTILS::Read_A_Val("ARNSRS_ID.sys"));
POTLESS_2 43:5ae8baf28e32 714 OUTPUT(" Servo_Poumon.sys = %d\r\n", (int)UTILS::Read_A_Val("Servo_Poumon.sys"));
POTLESS_2 43:5ae8baf28e32 715 OUTPUT(" Servo_Fuite.sys = %d\r\n", (int)UTILS::Read_A_Val("Servo_Fuite.sys"));
POTLESS_2 58:694d4d00407c 716 */
POTLESS_2 58:694d4d00407c 717 OUTPUT(" ARNSRS ID = %d\r\n", (int) UTILS::Read(ID_ARNSRS_ADDR));
POTLESS_2 58:694d4d00407c 718 OUTPUT(" Dernière Position volet poumon enregistrée = %d\r\n", (int) UTILS::Read(VOLET_POUMON_ADDR));
POTLESS_2 58:694d4d00407c 719 OUTPUT(" Dernière Position volet fuite enregistrée = %d\r\n", (int) UTILS::Read(VOLET_FUITE_ADDR));
POTLESS_2 35:a209a192f431 720 } else if (0 == strcmp(com, "check_E")) {
POTLESS_2 42:3591ec9903b4 721 sensors.Sensor_head_check(&serialMonit);
POTLESS_2 34:26f6e3dbefb9 722 } else if (0 == strcmp(com, "rec")) {
POTLESS_2 34:26f6e3dbefb9 723 if (FLAG_REC) {
POTLESS_2 34:26f6e3dbefb9 724 FLAG_REC = false;
POTLESS_2 43:5ae8baf28e32 725 OUTPUT(" Arrêt du Data Logging.\r\n");
POTLESS_2 34:26f6e3dbefb9 726 } else {
POTLESS_2 34:26f6e3dbefb9 727 FLAG_REC = true;
POTLESS_2 43:5ae8baf28e32 728 OUTPUT(" Démarrage Data Logging dans %s\r\n", Log_File_Name);
POTLESS_2 34:26f6e3dbefb9 729 }
POTLESS_2 34:26f6e3dbefb9 730 } else if (0 == strcmp(com, "help")) {
POTLESS_2 29:5b822d18bce6 731 FLAG_AFF = false;
POTLESS_2 42:3591ec9903b4 732 UTILS::Help(&serialMonit);
POTLESS_2 34:26f6e3dbefb9 733 } else if (0 == strcmp(com, "start")) {
POTLESS_2 29:5b822d18bce6 734 FLAG_AFF = true;
POTLESS_2 34:26f6e3dbefb9 735 } else if (0 == strcmp(com, "stop")) {
POTLESS_2 29:5b822d18bce6 736 FLAG_AFF = false;
POTLESS_2 40:32d89e04ead1 737 //UTILS::Help();
POTLESS_2 36:1f5e2247b073 738 } else if (0 == strcmp(com, "flash_c")) {
POTLESS_2 29:5b822d18bce6 739 FLAG_REC = false;
POTLESS_2 29:5b822d18bce6 740 UTILS::Clean_Flash();
POTLESS_2 42:3591ec9903b4 741 } else if (0 == strcmp(com, "flash_f")) {
POTLESS_2 34:26f6e3dbefb9 742 FLAG_REC = false;
POTLESS_2 43:5ae8baf28e32 743 UTILS::Clean_Flash_All();
POTLESS_2 42:3591ec9903b4 744 } else if (0 == strcmp(com, "dir")) {
POTLESS_2 43:5ae8baf28e32 745 FLAG_WINDEV = false;
POTLESS_2 56:61b0f4d6a890 746 wait(0.5);
POTLESS_2 43:5ae8baf28e32 747 OUTPUT("$\r\n");
POTLESS_2 43:5ae8baf28e32 748 wait(0.5);
POTLESS_2 42:3591ec9903b4 749 UTILS::Dir_Flash(&serialMonit);
POTLESS_2 42:3591ec9903b4 750 } else if (0 == strcmp(com, "get")) {
POTLESS_2 29:5b822d18bce6 751 wait_ms(100);
POTLESS_2 43:5ae8baf28e32 752 char filename[20];
POTLESS_2 43:5ae8baf28e32 753 UTILS::Read_Flash_File(&serialMonit, numb);
POTLESS_2 43:5ae8baf28e32 754 wait_ms(100);
POTLESS_2 34:26f6e3dbefb9 755 } else if (0 == strcmp(com, "del")) {
POTLESS_2 29:5b822d18bce6 756 FLAG_REC = false;
POTLESS_2 29:5b822d18bce6 757 char filename[20];
POTLESS_2 42:3591ec9903b4 758 UTILS::Delete_Flash_File(numb);
POTLESS_2 43:5ae8baf28e32 759 OUTPUT("$\r\n");
POTLESS_2 43:5ae8baf28e32 760 wait(0.5);
POTLESS_2 43:5ae8baf28e32 761 UTILS::Dir_Flash(&serialMonit);
POTLESS_2 31:231a96d1d1c8 762 FLAG_REC = true;
POTLESS_2 34:26f6e3dbefb9 763 } else if (0 == strcmp(com, "file_s")) {
POTLESS_2 31:231a96d1d1c8 764 char filename[20];
POTLESS_2 42:3591ec9903b4 765 UTILS::Get_File_Size(&serialMonit, numb);
POTLESS_2 29:5b822d18bce6 766 } else if (0 == strcmp(com, "calib_p")) {
POTLESS_2 59:fd64ca9dae27 767 volet_poumon_Position = 0;
POTLESS_2 59:fd64ca9dae27 768 Servo_Poumon.reset();
POTLESS_2 58:694d4d00407c 769 Consigne_poumon = HOME_SERVO_POUMON;
POTLESS_2 43:5ae8baf28e32 770 OUTPUT(" Volet poumon Calibré.\r\n");
POTLESS_2 29:5b822d18bce6 771 } else if (0 == strcmp(com, "calib_f")) {
POTLESS_2 59:fd64ca9dae27 772 volet_fuite_Position = 0;
POTLESS_2 59:fd64ca9dae27 773 Servo_Fuite.reset();
POTLESS_2 58:694d4d00407c 774 Consigne_fuite = HOME_SERVO_FUITE;
POTLESS_2 43:5ae8baf28e32 775 OUTPUT(" Volet fuite Calibré.\r\n");
POTLESS_2 29:5b822d18bce6 776 } else if (0 == strcmp(com, "sleep")) {
POTLESS_2 19:cac3761a5d0b 777 Stop_Sequence();
POTLESS_2 29:5b822d18bce6 778 } else if (0 == strcmp(com, "time")) {//Depuis terminal MAC taper : " date +%s "
POTLESS_2 34:26f6e3dbefb9 779 set_time(atoi(numb));
POTLESS_2 43:5ae8baf28e32 780 OUTPUT(" La RTC a été mise à l'heure.\r\n");
POTLESS_2 29:5b822d18bce6 781 } else if (0 == strcmp(com, "c_pou")) {
POTLESS_2 43:5ae8baf28e32 782 Consigne_poumon = atof(numb);
POTLESS_2 43:5ae8baf28e32 783 DEBUG(" Servo Poumon = %f\r\n", Consigne_poumon);
POTLESS_2 43:5ae8baf28e32 784 } else if (0 == strcmp(com, "c_fui")) {
POTLESS_2 43:5ae8baf28e32 785 Consigne_fuite = atof(numb);
POTLESS_2 43:5ae8baf28e32 786 DEBUG(" Servo Fuite = %f\r\n", Consigne_fuite);
POTLESS_2 43:5ae8baf28e32 787 } else if (0 == strcmp(com, "mp_pou")) {
POTLESS_2 41:51ba69648f9d 788 Consigne_poumon += atof(numb);
POTLESS_2 33:f5d4bae05f16 789 DEBUG(" Servo Poumon = %f\r\n", Consigne_poumon);
POTLESS_2 43:5ae8baf28e32 790 } else if (0 == strcmp(com, "mp_fui")) {
POTLESS_2 41:51ba69648f9d 791 Consigne_fuite += atof(numb);
POTLESS_2 33:f5d4bae05f16 792 DEBUG(" Servo Fuite = %f\r\n", Consigne_fuite);
POTLESS_2 29:5b822d18bce6 793 } else if (0 == strcmp(com, "reset")) {
POTLESS_2 43:5ae8baf28e32 794 FLAG_REC = false;
POTLESS_2 57:a0827fa46b03 795 Mode_SECU();
POTLESS_2 36:1f5e2247b073 796 UTILS::UnMount_Flash();
POTLESS_2 43:5ae8baf28e32 797 OUTPUT(" Reset de l'appareil.\r\n");
POTLESS_2 43:5ae8baf28e32 798 wait(1);
POTLESS_2 10:aca745a66d51 799 NVIC_SystemReset();
POTLESS_2 43:5ae8baf28e32 800 } else if (0 == strcmp(com, "Kc")) {
POTLESS_2 43:5ae8baf28e32 801 Kc = atof(numb);
POTLESS_2 43:5ae8baf28e32 802 control_Servo.reset();
POTLESS_2 43:5ae8baf28e32 803 control_Servo.setTunings(Kc, Ti, Td);
POTLESS_2 56:61b0f4d6a890 804 OUTPUT(" MAJ PID --> Kc = %f Ti = %f Td = %f\r\n", Kc, Ti, Td);
POTLESS_2 43:5ae8baf28e32 805 } else if (0 == strcmp(com, "Ti")) {
POTLESS_2 43:5ae8baf28e32 806 Ti = atof(numb);
POTLESS_2 43:5ae8baf28e32 807 control_Servo.reset();
POTLESS_2 43:5ae8baf28e32 808 control_Servo.setTunings(Kc, Ti, Td);
POTLESS_2 56:61b0f4d6a890 809 OUTPUT(" MAJ PID --> Kc = %f Ti = %f Td = %f\r\n", Kc, Ti, Td);
POTLESS_2 43:5ae8baf28e32 810 } else if (0 == strcmp(com, "Td")) {
POTLESS_2 43:5ae8baf28e32 811 Td = atof(numb);
POTLESS_2 43:5ae8baf28e32 812 control_Servo.reset();
POTLESS_2 43:5ae8baf28e32 813 control_Servo.setTunings(Kc, Ti, Td);
POTLESS_2 56:61b0f4d6a890 814 OUTPUT(" MAJ PID --> Kc = %f Ti = %f Td = %f\r\n", Kc, Ti, Td);
POTLESS_2 43:5ae8baf28e32 815 } else if (0 == strcmp(com, "Cons")) {
POTLESS_2 43:5ae8baf28e32 816 consigne = atoi(numb);
POTLESS_2 43:5ae8baf28e32 817 control_Servo.setSetPoint(consigne);
POTLESS_2 56:61b0f4d6a890 818 OUTPUT(" MAJ CONSIGNE PID --> Consigne = %d\r\n", consigne);
potless 49:a7432da60647 819 } else if (0 == strcmp(com, "dfu")) {
POTLESS_2 53:84571a5e2cda 820 OUTPUT(" Passage en DFU...\r\n");
POTLESS_2 58:694d4d00407c 821 FLAG_REC = false;
POTLESS_2 58:694d4d00407c 822 Mode_SECU();
POTLESS_2 58:694d4d00407c 823 UTILS::UnMount_Flash();
POTLESS_2 59:fd64ca9dae27 824 UTILS::EffacePage(2, 29, 1);
POTLESS_2 59:fd64ca9dae27 825 UTILS::Write(DFU_ADDR, 0xDEADBEEF);
POTLESS_2 58:694d4d00407c 826 wait(1);
POTLESS_2 58:694d4d00407c 827 NVIC_SystemReset();
POTLESS_2 43:5ae8baf28e32 828 } else if (0 == strcmp(com, "PID")) {
POTLESS_2 43:5ae8baf28e32 829 if (FLAG_PID == 1) {
POTLESS_2 58:694d4d00407c 830 //control_Servo.setMode(MANUAL_MODE);
POTLESS_2 56:61b0f4d6a890 831 OUTPUT(" PID OFF\r\n");
POTLESS_2 43:5ae8baf28e32 832 FLAG_PID = 0;
POTLESS_2 43:5ae8baf28e32 833 } else if (FLAG_PID == 0) {
POTLESS_2 58:694d4d00407c 834 //control_Servo.setMode(AUTO_MODE);
POTLESS_2 56:61b0f4d6a890 835 OUTPUT(" PID ON\r\n");
POTLESS_2 43:5ae8baf28e32 836 FLAG_PID = 1;
POTLESS_2 43:5ae8baf28e32 837 }
POTLESS_2 12:7f3aadd79f89 838 } else {
POTLESS_2 43:5ae8baf28e32 839
POTLESS_2 9:04bfdfc029cb 840 sensors.cozirSend(message);
POTLESS_2 9:04bfdfc029cb 841 }
POTLESS_2 34:26f6e3dbefb9 842
POTLESS_2 9:04bfdfc029cb 843 strcpy(param," ");
POTLESS_2 9:04bfdfc029cb 844 indexParam = 0;
POTLESS_2 9:04bfdfc029cb 845 newParamFlag = false;
POTLESS_2 9:04bfdfc029cb 846 }
POTLESS_2 9:04bfdfc029cb 847
POTLESS_2 56:61b0f4d6a890 848 void Decoding_IHM(char message [])
POTLESS_2 56:61b0f4d6a890 849 {
POTLESS_2 56:61b0f4d6a890 850
POTLESS_2 56:61b0f4d6a890 851 char com[20] = "";
POTLESS_2 56:61b0f4d6a890 852 char numb[30] = "";
POTLESS_2 56:61b0f4d6a890 853
POTLESS_2 56:61b0f4d6a890 854 sscanf(message,"%s %s",&com , &numb);
POTLESS_2 56:61b0f4d6a890 855
POTLESS_2 56:61b0f4d6a890 856 DEEP_DEBUG("\r\n Commande = %s Valeur = %s \r\n\r\n", com, numb);
POTLESS_2 56:61b0f4d6a890 857
POTLESS_2 56:61b0f4d6a890 858 OUTPUT("?\r\n");
POTLESS_2 56:61b0f4d6a890 859
POTLESS_2 56:61b0f4d6a890 860 if (0 == strcmp(com, "1")) {
POTLESS_2 58:694d4d00407c 861
POTLESS_2 56:61b0f4d6a890 862 } else if (0 == strcmp(com, "2")) {
POTLESS_2 58:694d4d00407c 863
POTLESS_2 56:61b0f4d6a890 864 } else if (0 == strcmp(com, "3")) {
POTLESS_2 56:61b0f4d6a890 865
POTLESS_2 56:61b0f4d6a890 866 } else {
POTLESS_2 58:694d4d00407c 867
POTLESS_2 56:61b0f4d6a890 868 }
POTLESS_2 56:61b0f4d6a890 869
POTLESS_2 56:61b0f4d6a890 870 strcpy(IHM," ");
POTLESS_2 56:61b0f4d6a890 871 indexIHM = 0;
POTLESS_2 56:61b0f4d6a890 872 newIHMFlag = false;
POTLESS_2 56:61b0f4d6a890 873 }
POTLESS_2 56:61b0f4d6a890 874
POTLESS_2 26:a2fe19341f92 875 void Create_File_Name_Date()
POTLESS_2 25:322ef9488e65 876 {
POTLESS_2 25:322ef9488e65 877 //Du nom du fichier Date / heure
POTLESS_2 25:322ef9488e65 878 seconds = time(NULL);
POTLESS_2 25:322ef9488e65 879 char Time[40];
POTLESS_2 25:322ef9488e65 880 strftime(Time, 40, "%a_%d_%m_%Y_%H%M", localtime(&seconds));
POTLESS_2 42:3591ec9903b4 881 sprintf(Log_File_Name, "%s_LOG.csv", Time);
POTLESS_2 42:3591ec9903b4 882 DEBUG(" Nouveau fichier LOG = %s \r\n", Log_File_Name);
POTLESS_2 34:26f6e3dbefb9 883 }
POTLESS_2 34:26f6e3dbefb9 884
POTLESS_2 26:a2fe19341f92 885 void Create_File_Name_Index()
POTLESS_2 26:a2fe19341f92 886 {
POTLESS_2 26:a2fe19341f92 887 //Du nom du fichier par Index
POTLESS_2 42:3591ec9903b4 888 sprintf(Log_File_Name, "LOG_%d.csv", UTILS::File_Index());
POTLESS_2 34:26f6e3dbefb9 889 DEBUG(" Nouveau fichier LOG = %s \r\n", Log_File_Name);
POTLESS_2 34:26f6e3dbefb9 890 }
POTLESS_2 34:26f6e3dbefb9 891
potless 48:9ceb095f397a 892
POTLESS_2 4:d84250f67dec 893 int main()
POTLESS_2 12:7f3aadd79f89 894 {
POTLESS_2 58:694d4d00407c 895
POTLESS_2 40:32d89e04ead1 896 HAL_Init();
POTLESS_2 40:32d89e04ead1 897 __HAL_RCC_PWR_CLK_ENABLE();
potless 37:f9461c6592f2 898 HAL_PWR_EnableBkUpAccess();
POTLESS_2 53:84571a5e2cda 899
POTLESS_2 58:694d4d00407c 900 UTILS::DFU();
potless 60:e2922f9e309c 901 flagSleep(); // on vérifie si la demande de sleep n'est pas active (permet de redémarrer sur un front haut)
POTLESS_2 58:694d4d00407c 902
POTLESS_2 56:61b0f4d6a890 903 E5V = 1;
POTLESS_2 57:a0827fa46b03 904 E3V = 1;
POTLESS_2 40:32d89e04ead1 905
POTLESS_2 58:694d4d00407c 906 if (PIN_V_USB_DIGI) flag_USB = true;
POTLESS_2 59:fd64ca9dae27 907 if (PIN_V_PILES_DIGI) flag_Piles = true;
POTLESS_2 58:694d4d00407c 908
POTLESS_2 58:694d4d00407c 909 UTILS::PVD_Config();
POTLESS_2 58:694d4d00407c 910
POTLESS_2 56:61b0f4d6a890 911 buzzer.beep(1000,0.5);
POTLESS_2 58:694d4d00407c 912
POTLESS_2 43:5ae8baf28e32 913 //Ci-dessous commande pour formater une nouvelle carte
POTLESS_2 58:694d4d00407c 914 //UTILS::Format_Flash();
POTLESS_2 43:5ae8baf28e32 915
POTLESS_2 43:5ae8baf28e32 916 //Montage Flash
POTLESS_2 43:5ae8baf28e32 917 UTILS::Mount_Flash();
POTLESS_2 58:694d4d00407c 918 /*
POTLESS_2 58:694d4d00407c 919 if (UTILS::File_Exist("ARNSRS_ID.sys") == false) {
POTLESS_2 58:694d4d00407c 920 UTILS::Store_A_Val(000, "ARNSRS_ID.sys");
POTLESS_2 58:694d4d00407c 921 DEBUG("ARNSRS ID forcée à 000\r\n");
POTLESS_2 58:694d4d00407c 922 }
POTLESS_2 58:694d4d00407c 923 */
POTLESS_2 58:694d4d00407c 924 //pour le premier lancement quand l'appareil n'a pas d'ID.
POTLESS_2 58:694d4d00407c 925 //int ID = 0;
POTLESS_2 58:694d4d00407c 926 //UTILS::Write(ADRESSE_ID, ID);
POTLESS_2 12:7f3aadd79f89 927
POTLESS_2 57:a0827fa46b03 928 DEBUG("\r\n\r\n Démarrage de l'appareil, veuillez patienter...\r\n\r\n");
POTLESS_2 58:694d4d00407c 929
POTLESS_2 34:26f6e3dbefb9 930
POTLESS_2 43:5ae8baf28e32 931 //Vérification RTC, si on est le 01/01/70, c'est qu'il y a un problème...
POTLESS_2 43:5ae8baf28e32 932 seconds = time(NULL);
POTLESS_2 43:5ae8baf28e32 933 char YEAR[10];
POTLESS_2 43:5ae8baf28e32 934 strftime(YEAR, 10, "%D", localtime(&seconds));
POTLESS_2 58:694d4d00407c 935 if (0 == strcmp(YEAR, "01/01/70"));
POTLESS_2 58:694d4d00407c 936 DEBUG(" Vous devez régler la RTC...\r\n\r\n");
POTLESS_2 18:bfd78c05b589 937
POTLESS_2 43:5ae8baf28e32 938 bool calib_O2 = false;
POTLESS_2 43:5ae8baf28e32 939 bool calib_CO2 = false;
potless 61:c3391376ca21 940
potless 61:c3391376ca21 941 //todo à remettre si tête capteur présente
potless 60:e2922f9e309c 942 //sensors.Sensors_INIT(calib_O2, calib_CO2);
POTLESS_2 43:5ae8baf28e32 943
POTLESS_2 43:5ae8baf28e32 944 wait(1);
POTLESS_2 43:5ae8baf28e32 945
POTLESS_2 43:5ae8baf28e32 946 //Création du nouveau fichier LOG par index / par date.
POTLESS_2 43:5ae8baf28e32 947 //Create_File_Name_Index();
POTLESS_2 43:5ae8baf28e32 948 Create_File_Name_Date();
POTLESS_2 43:5ae8baf28e32 949
POTLESS_2 43:5ae8baf28e32 950 //Création et écriture du header du fichier LOG
POTLESS_2 43:5ae8baf28e32 951 sensors.Create_Header(Log_File_Name);
POTLESS_2 42:3591ec9903b4 952
POTLESS_2 58:694d4d00407c 953 /*
POTLESS_2 43:5ae8baf28e32 954 Servo_Poumon.Init("Servo_Poumon.sys");
POTLESS_2 43:5ae8baf28e32 955 Servo_Fuite.Init("Servo_Fuite.sys");
POTLESS_2 15:efd3b3bf3f37 956
POTLESS_2 58:694d4d00407c 957 Servo_Poumon.Init(VOLET_POUMON_ADDR);
POTLESS_2 58:694d4d00407c 958 Servo_Fuite.Init(VOLET_FUITE_ADDR);
POTLESS_2 58:694d4d00407c 959 */
POTLESS_2 58:694d4d00407c 960
POTLESS_2 57:a0827fa46b03 961 DEBUG(" Demarrage des threads...\r\n\r\n");
POTLESS_2 18:bfd78c05b589 962
POTLESS_2 43:5ae8baf28e32 963 wait(1);
POTLESS_2 20:5f79fb4565a7 964
POTLESS_2 43:5ae8baf28e32 965 thread_Secu.start(callback(SECU_thread));
POTLESS_2 34:26f6e3dbefb9 966
POTLESS_2 56:61b0f4d6a890 967 DEBUG(" Contrôle des paramètres de sécu démarré\r\n\r\n");
POTLESS_2 43:5ae8baf28e32 968
POTLESS_2 43:5ae8baf28e32 969 wait(1);
potless 60:e2922f9e309c 970
POTLESS_2 43:5ae8baf28e32 971 thread_Head.start(callback(SENSORS_thread));
POTLESS_2 36:1f5e2247b073 972
POTLESS_2 56:61b0f4d6a890 973 DEBUG(" Tête capteurs démarrée\r\n\r\n");
POTLESS_2 43:5ae8baf28e32 974
POTLESS_2 43:5ae8baf28e32 975 wait(1);
POTLESS_2 9:04bfdfc029cb 976
POTLESS_2 57:a0827fa46b03 977 thread_Volets_POUMON.start(callback(GO_TO_thread_POUMON));
POTLESS_2 58:694d4d00407c 978
POTLESS_2 57:a0827fa46b03 979 wait(1);
POTLESS_2 56:61b0f4d6a890 980
POTLESS_2 57:a0827fa46b03 981 thread_Volets_FUITE.start(callback(GO_TO_thread_FUITE));
POTLESS_2 56:61b0f4d6a890 982
POTLESS_2 56:61b0f4d6a890 983 DEBUG(" Contrôle des volets démarré\r\n\r\n");
POTLESS_2 56:61b0f4d6a890 984
POTLESS_2 43:5ae8baf28e32 985 //Init PID
POTLESS_2 43:5ae8baf28e32 986 //Entrée PPO2 entre 100 et 1000 mb
POTLESS_2 43:5ae8baf28e32 987 control_Servo.setInputLimits(Min_Input, Max_Input);
POTLESS_2 43:5ae8baf28e32 988 //Sortie servo entre 0 et 100 %
POTLESS_2 43:5ae8baf28e32 989 control_Servo.setOutputLimits(Min_Output, Max_Output);
POTLESS_2 57:a0827fa46b03 990 //Reglage de l'interval du PID
POTLESS_2 57:a0827fa46b03 991 control_Servo.setInterval(RATE_PID);
POTLESS_2 43:5ae8baf28e32 992 //Consigne à x mb
POTLESS_2 43:5ae8baf28e32 993 control_Servo.setSetPoint(consigne);
POTLESS_2 57:a0827fa46b03 994 //Mode auto au démarrage
POTLESS_2 58:694d4d00407c 995 control_Servo.setMode(AUTO_MODE);
POTLESS_2 34:26f6e3dbefb9 996
POTLESS_2 56:61b0f4d6a890 997 DEBUG(" Cliquez sur le bouton help pour voir la liste des \r\n commandes administrateur disponibles.\r\n");
POTLESS_2 7:ad15c386e960 998
POTLESS_2 46:28298df0ac55 999 OUTPUT("$\r\n");
POTLESS_2 43:5ae8baf28e32 1000 wait(0.5);
POTLESS_2 43:5ae8baf28e32 1001 UTILS::Dir_Flash(&serialMonit);
POTLESS_2 43:5ae8baf28e32 1002
POTLESS_2 47:89a088bc8866 1003 serialMonit.attach(&callbackParam);
POTLESS_2 58:694d4d00407c 1004
POTLESS_2 56:61b0f4d6a890 1005 display.attach(&callbackIHM);
POTLESS_2 58:694d4d00407c 1006
POTLESS_2 58:694d4d00407c 1007 OTU_Ticker.attach(&Calcul_OTU, 60);
POTLESS_2 58:694d4d00407c 1008
potless 60:e2922f9e309c 1009 vusb_off_on.fall(&USB_unplugged);
POTLESS_2 59:fd64ca9dae27 1010
potless 61:c3391376ca21 1011 vpiles_off_on.fall(&PILES_unplugged);
POTLESS_2 53:84571a5e2cda 1012
POTLESS_2 56:61b0f4d6a890 1013 buzzer.beep(1000,0.3);
POTLESS_2 56:61b0f4d6a890 1014 wait_ms(500);
POTLESS_2 56:61b0f4d6a890 1015 buzzer.beep(1000,0.3);
POTLESS_2 58:694d4d00407c 1016
POTLESS_2 43:5ae8baf28e32 1017 while (true) {
POTLESS_2 36:1f5e2247b073 1018
POTLESS_2 43:5ae8baf28e32 1019 //Démarrage du Timer mesurant le temps d'éxecution du code
POTLESS_2 43:5ae8baf28e32 1020 REAL_RATE.start();
POTLESS_2 36:1f5e2247b073 1021
POTLESS_2 43:5ae8baf28e32 1022 if (newParamFlag) {
POTLESS_2 43:5ae8baf28e32 1023 DEEP_DEBUG(" From PC = %s\r\n", param);
POTLESS_2 43:5ae8baf28e32 1024 Decoding_Message(param);
POTLESS_2 43:5ae8baf28e32 1025 }
POTLESS_2 58:694d4d00407c 1026
POTLESS_2 56:61b0f4d6a890 1027 if (newIHMFlag) {
POTLESS_2 56:61b0f4d6a890 1028 DEEP_DEBUG(" From IHM = %s\r\n", IHM);
POTLESS_2 56:61b0f4d6a890 1029 Decoding_IHM(IHM);
POTLESS_2 56:61b0f4d6a890 1030 }
POTLESS_2 34:26f6e3dbefb9 1031
POTLESS_2 43:5ae8baf28e32 1032 //Fabrication de la chaine Date / heure
POTLESS_2 43:5ae8baf28e32 1033 seconds = time(NULL);
POTLESS_2 43:5ae8baf28e32 1034 char Time_buf[32];
POTLESS_2 43:5ae8baf28e32 1035 strftime(Time_buf, 32, "%D %I-%M-%S ", localtime(&seconds));
POTLESS_2 19:cac3761a5d0b 1036
POTLESS_2 56:61b0f4d6a890 1037 //Fabrication de la chaine de com
POTLESS_2 56:61b0f4d6a890 1038 sprintf(to_store,"<%s;%d;%d;%.2f;%d;%.2f;%.2f;%d;%d;%d;%.2f;%.2f;%d;%.3f;%.3f;%.3f;%d;%d>",
POTLESS_2 43:5ae8baf28e32 1039 Time_buf,
POTLESS_2 43:5ae8baf28e32 1040 co2,
POTLESS_2 43:5ae8baf28e32 1041 ppO2,
POTLESS_2 43:5ae8baf28e32 1042 pression,
POTLESS_2 43:5ae8baf28e32 1043 (int)OTU,
POTLESS_2 43:5ae8baf28e32 1044 Temp1,
POTLESS_2 43:5ae8baf28e32 1045 Temp2,
POTLESS_2 43:5ae8baf28e32 1046 Humid,
POTLESS_2 43:5ae8baf28e32 1047 CellO2_1,
POTLESS_2 43:5ae8baf28e32 1048 CellO2_2,
POTLESS_2 43:5ae8baf28e32 1049 volet_poumon_Position,
POTLESS_2 43:5ae8baf28e32 1050 volet_fuite_Position,
POTLESS_2 43:5ae8baf28e32 1051 FLAG_PID,
POTLESS_2 43:5ae8baf28e32 1052 Kc,
POTLESS_2 43:5ae8baf28e32 1053 Ti,
POTLESS_2 43:5ae8baf28e32 1054 Td,
POTLESS_2 56:61b0f4d6a890 1055 consigne,
POTLESS_2 56:61b0f4d6a890 1056 Commande_IHM
POTLESS_2 58:694d4d00407c 1057 );
POTLESS_2 15:efd3b3bf3f37 1058
POTLESS_2 15:efd3b3bf3f37 1059
POTLESS_2 43:5ae8baf28e32 1060 //Pour windev
POTLESS_2 43:5ae8baf28e32 1061 if (FLAG_WINDEV) {
POTLESS_2 43:5ae8baf28e32 1062 OUTPUT("%s\r\n", to_store);
POTLESS_2 43:5ae8baf28e32 1063 }
POTLESS_2 53:84571a5e2cda 1064
POTLESS_2 43:5ae8baf28e32 1065 //Pour l'IHM
POTLESS_2 46:28298df0ac55 1066 if (FLAG_DISPLAY) {
POTLESS_2 46:28298df0ac55 1067 IHM("%s\r\n", to_store);
POTLESS_2 46:28298df0ac55 1068 }
POTLESS_2 53:84571a5e2cda 1069
POTLESS_2 43:5ae8baf28e32 1070 //Vers le moniteur série
POTLESS_2 43:5ae8baf28e32 1071 if (FLAG_AFF) {
POTLESS_2 43:5ae8baf28e32 1072 Affichage();
POTLESS_2 43:5ae8baf28e32 1073 }
POTLESS_2 12:7f3aadd79f89 1074
POTLESS_2 43:5ae8baf28e32 1075 //Enregistrement de la chaine
POTLESS_2 43:5ae8baf28e32 1076 if (FLAG_REC) {
POTLESS_2 43:5ae8baf28e32 1077 UTILS::Write_Flash_File(to_store, Log_File_Name);
POTLESS_2 43:5ae8baf28e32 1078 count ++;
POTLESS_2 43:5ae8baf28e32 1079 if (count > Max_Log_Size) {
POTLESS_2 43:5ae8baf28e32 1080 Create_File_Name_Date();
POTLESS_2 43:5ae8baf28e32 1081 sensors.Create_Header(Log_File_Name);
POTLESS_2 43:5ae8baf28e32 1082 count = 0;
POTLESS_2 43:5ae8baf28e32 1083 OUTPUT("$\r\n");
POTLESS_2 43:5ae8baf28e32 1084 wait(0.5);
POTLESS_2 43:5ae8baf28e32 1085 UTILS::Dir_Flash(&serialMonit);
POTLESS_2 34:26f6e3dbefb9 1086 }
POTLESS_2 34:26f6e3dbefb9 1087 }
POTLESS_2 43:5ae8baf28e32 1088
POTLESS_2 56:61b0f4d6a890 1089
POTLESS_2 43:5ae8baf28e32 1090 //Update du PID
POTLESS_2 58:694d4d00407c 1091 if (FLAG_PID == 1 && EN_MODE_SECU == false) {
POTLESS_2 58:694d4d00407c 1092 control_Servo.setProcessValue(ppO2);
POTLESS_2 58:694d4d00407c 1093 //Nouvelle sortie servo fuite si on est pas en mode SECU
POTLESS_2 58:694d4d00407c 1094 Consigne_fuite = control_Servo.compute();
POTLESS_2 58:694d4d00407c 1095 }
POTLESS_2 43:5ae8baf28e32 1096
POTLESS_2 43:5ae8baf28e32 1097 //Arrêt du Timer mesurant le temps d'éxecution du code
POTLESS_2 43:5ae8baf28e32 1098 REAL_RATE.stop();
POTLESS_2 43:5ae8baf28e32 1099 //Définition de la nouvelle valeur du temps d'échantillonage du PID.
POTLESS_2 43:5ae8baf28e32 1100 RATE = REAL_RATE.read();
POTLESS_2 43:5ae8baf28e32 1101 //Reset du Timer
POTLESS_2 43:5ae8baf28e32 1102 REAL_RATE.reset();
POTLESS_2 43:5ae8baf28e32 1103
POTLESS_2 43:5ae8baf28e32 1104 //Pour ralentir le code à Ref_Time seconde fixe quelque soit les intéruptions du loop....
POTLESS_2 43:5ae8baf28e32 1105 if (Ref_Time > RATE) {
POTLESS_2 43:5ae8baf28e32 1106 RATE_TRUE = (Ref_Time - RATE) * 1000;
POTLESS_2 43:5ae8baf28e32 1107 } else {
POTLESS_2 43:5ae8baf28e32 1108 RATE_TRUE = 0;
POTLESS_2 43:5ae8baf28e32 1109
POTLESS_2 43:5ae8baf28e32 1110 DEEP_DEBUG("Pour ralentir le code, Ref_Time doit être supérieur à %f seconde(s)\r\n\n", RATE);
POTLESS_2 43:5ae8baf28e32 1111 }
POTLESS_2 43:5ae8baf28e32 1112
POTLESS_2 43:5ae8baf28e32 1113 wait_ms(RATE_TRUE);
POTLESS_2 34:26f6e3dbefb9 1114 }
POTLESS_2 4:d84250f67dec 1115 }
POTLESS_2 43:5ae8baf28e32 1116
POTLESS_2 43:5ae8baf28e32 1117