Jonathan Moreno / Mbed 2 deprecated PYL_v6

PYL

Dependencies:   mbed-rtos mbed

Fork of STINGR_PDR by JOEL CONTRERAS

main.cpp@4:c52a2d06bd93, 2018-06-29 (annotated)

Committer:
jmoreno10
Date:
Fri Jun 29 22:29:33 2018 +0000
Revision:
4:c52a2d06bd93
Parent:
3:5d959275ac05 
mbed

Who changed what in which revision?

UserRevisionLine numberNew contents of line
jmoreno10 4:c52a2d06bd93 1 #include "mbed.h" // Se declara la librería mbed.
Sumobot 0:88a700f174a3 2 #include "rtos.h"
Sumobot 0:88a700f174a3 3
jmoreno10 4:c52a2d06bd93 4 // Serial communication to PC
jmoreno10 4:c52a2d06bd93 5 Serial pc(USBTX, USBRX, 9600);
jmoreno10 4:c52a2d06bd93 6
jmoreno10 4:c52a2d06bd93 7 // STINGR connections
jmoreno10 4:c52a2d06bd93 8 DigitalIn CTS(p7, PullUp); // Entrada "CTS" en modo Pull-Up, para encontrarse normalmente a VCC cuando no haya un pulso.
jmoreno10 4:c52a2d06bd93 9 DigitalOut RTS(p8, 1); // Salida "RTS"; Predefinido para valer 1 en su estado inactivo dentro del código.
jmoreno10 4:c52a2d06bd93 10 Serial device(p9, p10, 9600); // tx, rx Comunicación Serial con el Módulo STINGR
Sumobot 0:88a700f174a3 11
jmoreno10 4:c52a2d06bd93 12 // Declared functions
jmoreno10 4:c52a2d06bd93 13 //void stx3(); // stx3() and waitCTS() appear to be same functions
jmoreno10 4:c52a2d06bd93 14 uint16_t ModRTU_CRC(char *buf, int len); // returns CRC bytes
jmoreno10 3:5d959275ac05 15 void respuesta();
jmoreno10 4:c52a2d06bd93 16 void waitCTS();
jmoreno10 3:5d959275ac05 17
jmoreno10 4:c52a2d06bd93 18 // Global variables
jmoreno10 4:c52a2d06bd93 19 int flag = 1; // Declaración de la Bandera.
jmoreno10 4:c52a2d06bd93 20 int incomingByte = 0; // Used to collect bytes from STINGR responses
jmoreno10 4:c52a2d06bd93 21 Thread thread; // Declaration to run threads
jmoreno10 4:c52a2d06bd93 22 int packet[15]; // STINGR response array
jmoreno10 4:c52a2d06bd93 23 int num = 0; // packet[15] index variable
jmoreno10 4:c52a2d06bd93 24 AnalogIn ain(p20); // Initialize pin for analog input
jmoreno10 4:c52a2d06bd93 25 int counter = 0;
jmoreno10 4:c52a2d06bd93 26
jmoreno10 3:5d959275ac05 27
jmoreno10 3:5d959275ac05 28 int main()
jmoreno10 4:c52a2d06bd93 29 {
jmoreno10 4:c52a2d06bd93 30 // SETUP___________________________________________________________________
jmoreno10 4:c52a2d06bd93 31 //thread.start(stx3);
jmoreno10 4:c52a2d06bd93 32 thread.start(respuesta); // STINGR responses to commands
jmoreno10 3:5d959275ac05 33
jmoreno10 4:c52a2d06bd93 34 // Send Setup Command
jmoreno10 4:c52a2d06bd93 35 waitCTS();
jmoreno10 3:5d959275ac05 36
jmoreno10 4:c52a2d06bd93 37 device.putc(0XAA);
jmoreno10 4:c52a2d06bd93 38 device.putc(0X0E);
jmoreno10 4:c52a2d06bd93 39 device.putc(0X06);
jmoreno10 4:c52a2d06bd93 40 device.putc(0X00);
jmoreno10 4:c52a2d06bd93 41 device.putc(0X00);
jmoreno10 4:c52a2d06bd93 42 device.putc(0X00);
jmoreno10 4:c52a2d06bd93 43 device.putc(0X00);
jmoreno10 3:5d959275ac05 44
jmoreno10 4:c52a2d06bd93 45 device.putc(0X00); //RF Channel (A)
jmoreno10 4:c52a2d06bd93 46 device.putc(0X01); //Bursts (1)
jmoreno10 4:c52a2d06bd93 47 device.putc(0X01); //Interval min (5 seconds)
jmoreno10 4:c52a2d06bd93 48 device.putc(0X02); //Interval max (10 seconds)
jmoreno10 4:c52a2d06bd93 49
jmoreno10 4:c52a2d06bd93 50 device.putc(0X00);
jmoreno10 4:c52a2d06bd93 51 device.putc(0X21); // CRC 1
jmoreno10 4:c52a2d06bd93 52 device.putc(0X39); // CRC 2
jmoreno10 4:c52a2d06bd93 53 // Post Command --------------------------
jmoreno10 4:c52a2d06bd93 54 Thread::wait(10); //comment? // Se esperan .1 segundos una vez que se terminaron de hacer las transmisiones
jmoreno10 3:5d959275ac05 55 //El tiempo total de transmisión es; el wait previo a las transmisiones, el tiempo que tarda el Mu en enviar los datos y el wait posterior a la transmisión
jmoreno10 3:5d959275ac05 56 RTS=1;
jmoreno10 4:c52a2d06bd93 57 Thread::wait(150); //comment?
jmoreno10 4:c52a2d06bd93 58 pc.printf("\n\rCTS: %d\n\r",CTS.read());
jmoreno10 3:5d959275ac05 59 flag=1;
jmoreno10 4:c52a2d06bd93 60 // ---------------------------------------
jmoreno10 4:c52a2d06bd93 61 Thread::wait(3000);
jmoreno10 3:5d959275ac05 62
jmoreno10 4:c52a2d06bd93 63 // LOOP____________________________________________________________________
jmoreno10 4:c52a2d06bd93 64 while(true)
jmoreno10 4:c52a2d06bd93 65 {
jmoreno10 4:c52a2d06bd93 66 printf("Fault sin pc");
jmoreno10 4:c52a2d06bd93 67
jmoreno10 4:c52a2d06bd93 68 // read the input voltage. represented as a float in the range [0.0, 1.0]
jmoreno10 4:c52a2d06bd93 69 // scaled by 3300 for a range of [0.0, 3300.0]
jmoreno10 4:c52a2d06bd93 70 float voltage = 3300 * ain.read();
jmoreno10 4:c52a2d06bd93 71
jmoreno10 4:c52a2d06bd93 72 // regardless, print the voltage reading (in float format; %f) for debugging
jmoreno10 4:c52a2d06bd93 73 printf("voltage [0,3300]: %f \n", voltage);
jmoreno10 4:c52a2d06bd93 74
jmoreno10 4:c52a2d06bd93 75 if(voltage == 0)
jmoreno10 4:c52a2d06bd93 76 {
jmoreno10 4:c52a2d06bd93 77 printf("Fault -- Voltage is 0");
jmoreno10 4:c52a2d06bd93 78 }
jmoreno10 4:c52a2d06bd93 79
jmoreno10 4:c52a2d06bd93 80 else if(voltage < 400)
jmoreno10 4:c52a2d06bd93 81 {
jmoreno10 4:c52a2d06bd93 82 printf("Preheating");
jmoreno10 4:c52a2d06bd93 83 //Question: How long does preheating take?
jmoreno10 4:c52a2d06bd93 84 //If preheating is quick, make a rewritable delay.
jmoreno10 4:c52a2d06bd93 85 // 5 second delay loops for preheating
jmoreno10 4:c52a2d06bd93 86 // 30 second delay loops for transmitting
jmoreno10 4:c52a2d06bd93 87 //otherwise, there will be an undesirable long 30 second delay
jmoreno10 4:c52a2d06bd93 88 }
jmoreno10 4:c52a2d06bd93 89
jmoreno10 4:c52a2d06bd93 90 else // (voltage >= 400)
jmoreno10 4:c52a2d06bd93 91 {
jmoreno10 4:c52a2d06bd93 92 int voltage_diference = voltage - 400; // ?? Why subtract 400
jmoreno10 4:c52a2d06bd93 93 int ppm = voltage_diference*50.0/16.0; // ?? voltage to ppm conversion?
jmoreno10 4:c52a2d06bd93 94
jmoreno10 4:c52a2d06bd93 95 // Printing voltage and ppm
jmoreno10 4:c52a2d06bd93 96 printf("voltage es: %f mV \n", voltage);
jmoreno10 4:c52a2d06bd93 97 printf("concentracion de C02 en ppm es: %X \n", ppm);
jmoreno10 4:c52a2d06bd93 98
jmoreno10 4:c52a2d06bd93 99 // Wake-up STINGR communication
jmoreno10 4:c52a2d06bd93 100 //stx3();
jmoreno10 4:c52a2d06bd93 101 waitCTS();
jmoreno10 4:c52a2d06bd93 102
jmoreno10 4:c52a2d06bd93 103 // Create Command vector -----------------
jmoreno10 4:c52a2d06bd93 104 // ?? Command length is 7 bytes?
jmoreno10 4:c52a2d06bd93 105 // * 3 header bytes, 2 data bytes, 2 CRC bytes?
jmoreno10 4:c52a2d06bd93 106 int number = 5;
jmoreno10 4:c52a2d06bd93 107 char header[3] = {0xAA,0x07,0x00}; // Define header information
jmoreno10 4:c52a2d06bd93 108 char vec[number]; // 3 header bytes, 2 data bytes
jmoreno10 4:c52a2d06bd93 109
jmoreno10 4:c52a2d06bd93 110 // store header to vec
jmoreno10 4:c52a2d06bd93 111 for(int k = 0; k < 3; k++)
jmoreno10 4:c52a2d06bd93 112 vec[k] = header[k];
jmoreno10 4:c52a2d06bd93 113
jmoreno10 4:c52a2d06bd93 114 // Break ppm integer(2 bytes) into separate c1,c2 uint8_t(bytes)
jmoreno10 4:c52a2d06bd93 115 uint8_t c1 = ppm;
jmoreno10 4:c52a2d06bd93 116 uint8_t c2 = ppm >> 8;
jmoreno10 4:c52a2d06bd93 117
jmoreno10 4:c52a2d06bd93 118 // store data bytes to vec
jmoreno10 4:c52a2d06bd93 119 vec[3] = c2;
jmoreno10 4:c52a2d06bd93 120 vec[4] = c1;
jmoreno10 3:5d959275ac05 121
jmoreno10 4:c52a2d06bd93 122 // Print characters in HEX (Debugging)
jmoreno10 4:c52a2d06bd93 123 pc.printf("Command(HEX):\t\t");
jmoreno10 4:c52a2d06bd93 124 for(int k = 0; k < number; k++)
jmoreno10 4:c52a2d06bd93 125 pc.printf("%X ",vec[k]);
jmoreno10 4:c52a2d06bd93 126
jmoreno10 4:c52a2d06bd93 127 // CRC calculation -----------------------
jmoreno10 4:c52a2d06bd93 128 char *t = (char *)vec;
jmoreno10 4:c52a2d06bd93 129 char crc1 = ModRTU_CRC(t,t[1]-2)&0xFF;
jmoreno10 4:c52a2d06bd93 130 char crc2 = ModRTU_CRC(t,t[1]-2)>>8;
jmoreno10 4:c52a2d06bd93 131
jmoreno10 4:c52a2d06bd93 132 pc.printf("%X ",crc1); //%X print char in HEX format
jmoreno10 4:c52a2d06bd93 133 pc.printf("%X ",crc2); //%X print char in HEX format
jmoreno10 4:c52a2d06bd93 134 pc.printf("\nResponse: ");
jmoreno10 4:c52a2d06bd93 135
jmoreno10 4:c52a2d06bd93 136 // Send Command to STINGR ----------------
jmoreno10 4:c52a2d06bd93 137 for(int k = 0; k < number; k++)
jmoreno10 4:c52a2d06bd93 138 device.putc(vec[k]);
jmoreno10 4:c52a2d06bd93 139 device.putc(crc1);
jmoreno10 4:c52a2d06bd93 140 device.putc(crc2);
jmoreno10 4:c52a2d06bd93 141
jmoreno10 4:c52a2d06bd93 142 // Post Command --------------------------
jmoreno10 4:c52a2d06bd93 143 Thread::wait(10); //comment? // Se esperan .1 segundos una vez que se terminaron de hacer las transmisiones
jmoreno10 4:c52a2d06bd93 144 //El tiempo total de transmisión es; el wait previo a las transmisiones, el tiempo que tarda el Mu en enviar los datos y el wait posterior a la transmisión
jmoreno10 4:c52a2d06bd93 145 RTS=1;
jmoreno10 4:c52a2d06bd93 146 Thread::wait(150); //comment?
jmoreno10 4:c52a2d06bd93 147 pc.printf("\n\rCTS: %d\n\r",CTS.read());
jmoreno10 4:c52a2d06bd93 148 flag=1;
jmoreno10 4:c52a2d06bd93 149 // ---------------------------------------
jmoreno10 4:c52a2d06bd93 150 counter++;
jmoreno10 4:c52a2d06bd93 151
jmoreno10 4:c52a2d06bd93 152 }// else statement ends
jmoreno10 4:c52a2d06bd93 153
jmoreno10 4:c52a2d06bd93 154 if (counter < 30)
jmoreno10 4:c52a2d06bd93 155 {
jmoreno10 4:c52a2d06bd93 156 for(int u = 0; u < 2; u++)
jmoreno10 4:c52a2d06bd93 157 Thread::wait(60000); // LOOP delay. 1 minuto (Note: units are in milliseconds)
jmoreno10 4:c52a2d06bd93 158 }
jmoreno10 4:c52a2d06bd93 159 else
jmoreno10 4:c52a2d06bd93 160 {
jmoreno10 4:c52a2d06bd93 161 for(int u = 0; u < 30; u++)
jmoreno10 4:c52a2d06bd93 162 Thread::wait(60000); // LOOP delay. 1 minuto (Note: units are in milliseconds)
jmoreno10 4:c52a2d06bd93 163 }
jmoreno10 4:c52a2d06bd93 164 }// LOOP (while statement) ends____________________________________________
jmoreno10 4:c52a2d06bd93 165
jmoreno10 4:c52a2d06bd93 166 }// main function ends
jmoreno10 3:5d959275ac05 167
jmoreno10 4:c52a2d06bd93 168 /*
jmoreno10 4:c52a2d06bd93 169 void stx3()
jmoreno10 3:5d959275ac05 170 {
jmoreno10 4:c52a2d06bd93 171 wait(200); // Se da un tiempo para que el analizador se estabilice
jmoreno10 4:c52a2d06bd93 172 incomingByte=0;
jmoreno10 4:c52a2d06bd93 173 pc.printf("El valor de CTS es %d\n\r",CTS.read()); // Se lee el valor de la variable CTS, la cual debe ser 1
jmoreno10 4:c52a2d06bd93 174 pc.printf("El valor de RTS es %d\n\r",RTS.read()); // Se lee el valor de la variable RTS, la cual debe ser 1
jmoreno10 4:c52a2d06bd93 175 RTS=0;
jmoreno10 4:c52a2d06bd93 176 // Se manda un pulso en bajo en RTS, para inicial el proceso de transmisión
jmoreno10 4:c52a2d06bd93 177 while(flag==1)
jmoreno10 4:c52a2d06bd93 178 { // Flag inicialmente vale 1, así que el ciclo while cambiará hasta que esa condición no se cumpla
jmoreno10 4:c52a2d06bd93 179 flag=CTS.read(); // Cuando entra el ciclo, se iguala flag a CTS, el cual cuando cambie a 0 provocará que termine el while (máx 125 ms)
jmoreno10 4:c52a2d06bd93 180 pc.printf("El valor de flag es %d\n\r", flag); // Se imprime el valor de flag, para identificar cuando termina el ciclo while
jmoreno10 3:5d959275ac05 181 }
jmoreno10 3:5d959275ac05 182 }
jmoreno10 4:c52a2d06bd93 183 */
jmoreno10 3:5d959275ac05 184
jmoreno10 3:5d959275ac05 185 uint16_t ModRTU_CRC(char * buf, int len)
jmoreno10 3:5d959275ac05 186 {
jmoreno10 3:5d959275ac05 187 unsigned char i;
jmoreno10 3:5d959275ac05 188 unsigned short data;
jmoreno10 3:5d959275ac05 189 uint16_t crc = 0xFFFF;
jmoreno10 3:5d959275ac05 190
jmoreno10 3:5d959275ac05 191 do{
jmoreno10 3:5d959275ac05 192 data = (unsigned int)0x00FF & *buf++;
jmoreno10 3:5d959275ac05 193 crc = crc ^ data;
jmoreno10 3:5d959275ac05 194
jmoreno10 3:5d959275ac05 195 for(i = 8; i > 0; i--)
jmoreno10 3:5d959275ac05 196 {
jmoreno10 3:5d959275ac05 197 if(crc & 0x0001)
jmoreno10 3:5d959275ac05 198 crc = (crc >> 1) ^ 0x8408;
jmoreno10 3:5d959275ac05 199 else
jmoreno10 3:5d959275ac05 200 crc >>=1;
jmoreno10 3:5d959275ac05 201 }
jmoreno10 3:5d959275ac05 202
jmoreno10 3:5d959275ac05 203 }while (--len);
jmoreno10 3:5d959275ac05 204
jmoreno10 3:5d959275ac05 205 crc = ~crc;
jmoreno10 3:5d959275ac05 206
jmoreno10 3:5d959275ac05 207 // Note, this number has low and high bytes swapped, so use it accordingly (or swap bytes)
jmoreno10 3:5d959275ac05 208 return (crc);
jmoreno10 3:5d959275ac05 209 }
jmoreno10 3:5d959275ac05 210
jmoreno10 4:c52a2d06bd93 211 void respuesta()
jmoreno10 4:c52a2d06bd93 212 {
jmoreno10 4:c52a2d06bd93 213 while(1)
jmoreno10 4:c52a2d06bd93 214 {
jmoreno10 4:c52a2d06bd93 215 if(device.readable())
jmoreno10 4:c52a2d06bd93 216 { // Se esperan datos provenientes del TX del módulo STX3
jmoreno10 4:c52a2d06bd93 217 incomingByte = device.getc();
jmoreno10 4:c52a2d06bd93 218 packet[num] = incomingByte;
jmoreno10 4:c52a2d06bd93 219 pc.printf("%X",incomingByte); // Format specifier
jmoreno10 4:c52a2d06bd93 220 pc.printf(" ");
jmoreno10 4:c52a2d06bd93 221 num++;
jmoreno10 4:c52a2d06bd93 222 }
jmoreno10 4:c52a2d06bd93 223 }
jmoreno10 4:c52a2d06bd93 224 }
jmoreno10 4:c52a2d06bd93 225
jmoreno10 4:c52a2d06bd93 226 void clearPacket() //reuired function for respuesta
jmoreno10 3:5d959275ac05 227 {
jmoreno10 4:c52a2d06bd93 228 num = 0;
jmoreno10 4:c52a2d06bd93 229 for(int i = 0; i < 15 ; i++)
jmoreno10 4:c52a2d06bd93 230 packet[i] = 0;
jmoreno10 4:c52a2d06bd93 231 }
jmoreno10 4:c52a2d06bd93 232
jmoreno10 4:c52a2d06bd93 233 void waitCTS()
jmoreno10 4:c52a2d06bd93 234 {
jmoreno10 4:c52a2d06bd93 235 Thread::wait(200); // Se da un tiempo para que el analizador se estabilice
jmoreno10 4:c52a2d06bd93 236 incomingByte=0;
jmoreno10 4:c52a2d06bd93 237 //pc.printf("El valor de CTS es %d\n\r",CTS.read()); // Se lee el valor de la variable CTS, la cual debe ser 1
jmoreno10 4:c52a2d06bd93 238 //pc.printf("El valor de RTS es %d\n\r",RTS.read()); // Se lee el valor de la variable RTS, la cual debe ser 1
jmoreno10 4:c52a2d06bd93 239 RTS=0; // Se manda un pulso en bajo en RTS, para inicial el proceso de transmisión
jmoreno10 4:c52a2d06bd93 240
jmoreno10 4:c52a2d06bd93 241 while(flag==1)
jmoreno10 4:c52a2d06bd93 242 {// Flag inicialmente vale 1, así que el ciclo while cambiará hasta que esa condición no se cumpla
jmoreno10 4:c52a2d06bd93 243 flag=CTS.read(); // Cuando entra el ciclo, se iguala flag a CTS, el cual cuando cambie a 0 provocará que termine el while (máx 125 ms)
jmoreno10 4:c52a2d06bd93 244 //pc.printf("El valor de flag es %d\n\r", flag); // Se imprime el valor de flag, para identificar cuando termina el ciclo while
jmoreno10 4:c52a2d06bd93 245 }
jmoreno10 4:c52a2d06bd93 246 }
jmoreno10 4:c52a2d06bd93 247