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