+/rtos

git clone https://git.julia.blue/+/rtos

Joseph RyanAdd core temp reading413cd76

master
17.6 KiB531 linesraw
1// Driver for ESP8266 module to act as a WiFi client or server
2// Currently restricted to one incoming or outgoing connection at a time
3// ESP8266 resources below:
4// General info and AT commands: http://nurdspace.nl/ESP8266
5// General info and AT commands: http://www.electrodragon.com/w/Wi07c
6// Vcc is a separate regulated 3.3V supply with at least 215mA
7// /------------------------------\
8// |              chip      1   8 |
9// | Ant                    2   7 |
10// | enna       processor   3   6 |
11// |                        4   5 |
12// \------------------------------/
13// Connects (#define below) TM4C123 on either UART1 (PB) or UART2 (PD)
14// Reset (#define below) on either PB5 or PB1
15
16// ESP8266    TM4C123
17//  1 URxD    PD7       UART out of TM4C123, 115200 baud
18//  2 GPIO0             +3.3V for normal operation (ground to flash)
19//  3 GPIO2             +3.3V
20//  4 GND     Gnd       GND (70mA)
21//  5 UTxD    PD6       UART out of ESP8266, 115200 baud
22//  6 Ch_PD             chip select, 10k resistor to 3.3V
23//  7 Reset   PB1       TM4C123 can issue output low to cause hardware reset
24//  8 Vcc               regulated 3.3V supply with at least 70mA
25
26#include "esp8266.h"
27#include "fifo.h"
28#include "interrupts.h"
29#include "io.h"
30#include "printf.h"
31#include "std.h"
32#include "tivaware/gpio.h"
33#include "tivaware/hw_gpio.h"
34#include "tivaware/hw_ints.h"
35#include "tivaware/hw_memmap.h"
36#include "tivaware/hw_types.h"
37#include "tivaware/hw_uart.h"
38#include "tivaware/pin_map.h"
39#include "tivaware/rom.h"
40#include "tivaware/sysctl.h"
41#include <stdbool.h>
42#include <stdint.h>
43
44#ifndef PASSKEY
45#define PASSKEY ""
46#endif
47#ifndef SSID_NAME
48#define SSID_NAME ""
49#endif
50
51// ESP responses
52static const char* ESP8266_READY_RESPONSE = "\r\nready\r\n";
53static const char* ESP8266_OK_RESPONSE = "\r\nOK\r\n";
54static const char* ESP8266_ERROR_RESPONSE = "\r\nERROR\r\n";
55static const char* ESP8266_FAIL_RESPONSE = "\r\nFAIL\r\n";
56static const char* ESP8266_SENDOK_RESPONSE = "\r\nSEND OK\r\n";
57
58// Globals for UART driver
59bool ESP8266_EchoResponse = false;
60bool ESP8266_EchoCommand = false;
61bool ESP8266_ConnectionMux = false;
62
63#define FIFOSIZE 1024 // size of the FIFOs
64static FIFO* rxfifo;
65static FIFO* rxdata_fifo;
66static FIFO* txfifo;
67
68// ESP8266 state
69uint16_t ESP8266_Server = 0; // server port, if any
70
71const char* ReceiveDataSearchString = "+IPD,";
72static uint32_t ReceiveDataSearchIndex = 0;
73static uint32_t ReceiveDataState = 1;  // 0 to disable filtering
74static uint32_t ReceiveDataStream = 0; // connection ID for received data
75static uint32_t ReceiveDataLen = 0;    // receive data packet remaining size
76volatile uint32_t ESP8266_DataAvailable =
77    0;                                  // received data (about to be) available
78volatile uint32_t ESP8266_DataLoss = 0; // lost data (for debugging)
79
80// State machine to filter out received data stream from UART Rx input
81// Inputs: character to check
82// returns true if data was filtered out, false otherwise
83static bool ReceiveDataFilter(char letter) {
84    switch (ReceiveDataState) { // Filter FSM
85    case 4: // filter out data and put it into the right receive FIFO
86        if (ReceiveDataLen) {
87            switch (ReceiveDataStream) {
88            case 0:
89                if (!fifo_try_put(rxdata_fifo, letter)) { // overflow, data loss
90                    ESP8266_DataAvailable--;
91                    ESP8266_DataLoss++;
92                }
93                break;
94                // only one connection currently supported
95            }
96            ReceiveDataLen--;
97            return true;
98        }
99        ReceiveDataState = 1; // restart
100        // fall through to start searching again if data is done
101    case 1: // Look for +IPD
102        if (letter == ReceiveDataSearchString[ReceiveDataSearchIndex]) {
103            // match letter
104            ReceiveDataSearchIndex++;
105            if (ReceiveDataSearchString[ReceiveDataSearchIndex] == 0) {
106                // end of match string
107                ReceiveDataState = ESP8266_ConnectionMux ? 2 : 3;
108                ReceiveDataSearchIndex = 0;
109                ReceiveDataStream = 0;
110                ReceiveDataLen = 0;
111            }
112        } else {
113            ReceiveDataSearchIndex = 0; // start over
114        }
115        return false;
116    case 2: // look for connection ID (separated by comma)
117        if (letter >= '0' && letter <= '9') {
118            ReceiveDataStream =
119                ReceiveDataStream * 10 + (letter - '0'); // add digit to ID
120        } else if (letter == ',') {
121            ReceiveDataState = 3; // ID completed, move on
122        } else {
123            ReceiveDataStream = 0;
124            ReceiveDataState = 1; // error, start over
125        }
126        return false;
127    case 3: // look for receive data size (separated by colon)
128        if (letter >= '0' && letter <= '9') {
129            ReceiveDataLen =
130                ReceiveDataLen * 10 + (letter - '0'); // add digit to length
131        } else if (letter == ':') {
132            ReceiveDataState = 4; // size complete, move on
133            ESP8266_DataAvailable +=
134                ReceiveDataLen; // mark as becoming available
135        } else {
136            ReceiveDataStream = 0;
137            ReceiveDataLen = 0;
138            ReceiveDataState = 1; // error, start over
139        }
140        return false;
141    }
142    return false;
143}
144
145// Preprocessor magic to construct UARTx_ identifiers
146#define STR(x) #x
147#define CONCAT(x, y, z) x##y##z
148
149#define UART_STR(uart) "UART" STR(uart)
150#define UART_NAME(uart, identifier) CONCAT(UART, uart, identifier)
151
152#define UART_ESP8266(identifier) HWREG(UART2_BASE + UART_##identifier)
153
154const uint32_t baud = 115200;
155void ESP8266_InitUART(int rx_echo, int tx_echo) {
156    rxfifo = fifo_new(FIFOSIZE);
157    rxdata_fifo = fifo_new(FIFOSIZE);
158    txfifo = fifo_new(FIFOSIZE);
159    ESP8266_EchoResponse = rx_echo;
160    ESP8266_EchoCommand = tx_echo;
161    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2);
162    while (!ROM_SysCtlPeripheralReady(SYSCTL_PERIPH_UART2)) {}
163    HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; // unlock port d
164    HWREG(GPIO_PORTD_BASE + GPIO_O_CR) |= 0xFF; // allow changes to PD7
165    ROM_GPIOPinConfigure(GPIO_PD6_U2RX);
166    ROM_GPIOPinConfigure(GPIO_PD7_U2TX);
167    ROM_GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_6 | GPIO_PIN_7);
168
169    // Initialize the UART. Set the baud rate, number of data bit
170    UART_ESP8266(O_CTL) &=
171        ~UART_CTL_UARTEN; // Clear UART enable bit during config
172    UART_ESP8266(O_IBRD) = (80000000 / 16) / baud;
173    UART_ESP8266(O_FBRD) = ((64 * ((80000000 / 16) % baud)) + baud / 2) / baud;
174    // UART_ESP8266(_IBRD_R) = 43;   // IBRD = int(80,000,000 / (16 * 115,200))
175    // = int(43.403) UART_ESP8266(_FBRD_R) = 26;   // FBRD = round(0.4028 * 64 )
176    // = 26
177    UART_ESP8266(O_LCRH) =
178        (UART_LCRH_WLEN_8 |
179         UART_LCRH_FEN); // 8 bit word length, 1 stop, no parity, FIFOs enabled
180    UART_ESP8266(O_IFLS) &=
181        ~0x3F; // Clear TX and RX interrupt FIFO level fields
182    UART_ESP8266(O_IFLS) +=
183        (UART_IFLS_TX1_8 |
184         UART_IFLS_RX1_8); // RX and TX FIFO interrupt threshold >= 1/8th full
185    UART_ESP8266(O_IM) |=
186        (UART_IM_RXIM | UART_IM_TXIM |
187         UART_IM_RTIM); // Enable interupt on TX, RX and RX transmission end
188    UART_ESP8266(O_CTL) |=
189        (UART_CTL_UARTEN | UART_CTL_RXE | UART_CTL_TXE); // Set UART enable bit
190}
191
192// Copies TX buffer (software defined FIFO) to uart
193void static ESP8266BufferToTx(void) {
194    uint8_t letter;
195    while (((UART_ESP8266(O_FR) & UART_FR_TXFF) == 0) &&
196           (!fifo_empty(txfifo))) {
197        fifo_try_get(txfifo, &letter);
198        if (ESP8266_EchoCommand) {
199            uart_putchar(letter);
200        }
201        UART_ESP8266(O_DR) = letter;
202    }
203}
204
205// Copies uart fifo to RX buffer (software defined FIFO)
206static void ESP8266RxToBuffer(void) {
207    char letter;
208    while (((UART_ESP8266(O_FR) & UART_FR_RXFE) == 0) && !fifo_full(rxfifo)) {
209        letter = UART_ESP8266(O_DR);
210        if (ESP8266_EchoResponse) {
211            uart_putchar(letter);
212        }
213        if (!ReceiveDataFilter(letter)) {
214            fifo_try_put(rxfifo, letter);
215        }
216    }
217}
218
219// at least one of three things has happened:
220// hardware TX FIFO goes from 3 to 2 or less items
221// hardware RX FIFO goes from 1 to 2 or more items
222// UART receiver has timed out
223void uart2_handler(void) {
224    if (UART_ESP8266(O_RIS) & UART_RIS_TXRIS) { // hardware TX FIFO <= 2 items
225        UART_ESP8266(O_ICR) = UART_ICR_TXIC;    // acknowledge TX FIFO
226        ESP8266BufferToTx();
227        if (fifo_empty(txfifo)) {
228            UART_ESP8266(O_IM) &= ~UART_IM_TXIM; // disable TX FIFO interrupt
229        }
230    }
231    if (UART_ESP8266(O_RIS) & UART_RIS_RXRIS) { // hardware RX FIFO >= 2 items
232        UART_ESP8266(O_ICR) = UART_ICR_RXIC;    // acknowledge RX FIFO
233        ESP8266RxToBuffer();
234    }
235    if (UART_ESP8266(O_RIS) & UART_RIS_RTRIS) { // receiver timed out
236        UART_ESP8266(O_ICR) = UART_ICR_RTIC;    // acknowledge receiver time out
237        ESP8266RxToBuffer();
238    }
239}
240
241static void esp_putc(char data) {
242    while (!fifo_try_put(txfifo, data)) {};
243    UART_ESP8266(O_IM) &= ~UART_IM_TXIM; // disable TX FIFO interrupt
244    ESP8266BufferToTx();
245    UART_ESP8266(O_IM) |= UART_IM_TXIM; // enable TX FIFO interrupt
246}
247
248static char esp_getc(void) {
249    uint8_t letter;
250    while (!fifo_try_get(rxfifo, &letter)) {};
251    return letter;
252}
253
254static void esp_puts(const char* command) {
255    int index = 0;
256    while (command[index]) { esp_putc(command[index++]); }
257}
258
259bool ESP8266_WaitForResponse(const char* success, const char* failure) {
260    char d;
261    const char* s = success;
262    const char* f = failure;
263    while ((!s || *s) && (!f || *f)) { // end of search string reached?
264        d = esp_getc();
265        if (s && (d == *s)) {
266            s++;
267        } else {
268            s = success; // start over
269            if (s && (d == *s))
270                s++; // match first char?
271        }
272        if (f && (d == *f)) {
273            f++;
274        } else {
275            f = failure; // start over
276            if (f && (d == *f))
277                f++; // match first char?
278        }
279    }
280    if (failure && !(*f))
281        return false;
282    return true;
283}
284
285bool ESP8266_Init(bool rx_echo, bool tx_echo) {
286    char c;
287    const char* s;
288    uint32_t timer = 1;
289
290    ROM_IntDisable(INT_UART2);
291    ESP8266_InitUART(rx_echo, tx_echo);
292    ROM_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_1); // Reset pin
293
294    // Hard reset
295    ROM_GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_1, 0);
296    busy_wait(7, ms(10));
297    ROM_GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_1, GPIO_PIN_1);
298
299    // Wait for ready status with timeout
300    // Use low-level UART communication, interrupts disabled
301    s = ESP8266_READY_RESPONSE;
302    timer = 5000000; // around a 1-2s total timeout
303    while (*s) {
304        while (timer && ((UART_ESP8266(O_FR) & UART_FR_RXFE) != 0)) { timer--; }
305        if (!timer)
306            break;
307        c = (char)(UART_ESP8266(O_DR) & 0xFF);
308        if (rx_echo)
309            uart_putchar(c); // will print garbage
310        if (c == *s) {
311            s++;
312        } else {
313            s = ESP8266_READY_RESPONSE;
314            if (c == *s)
315                s++;
316        }
317    }
318    ROM_IntPrioritySet(INT_UART2, 4 << 5);
319    ROM_IntEnable(INT_UART2);
320
321    return timer;
322}
323
324bool ESP8266_Connect(bool verbose) {
325    return ESP8266_Reset() && (verbose ? ESP8266_GetMACAddress() : true) &&
326           (verbose ? ESP8266_ListAccessPoints() : true) &&
327           ESP8266_SetWifiMode(CLIENT) &&
328           ESP8266_JoinAccessPoint(SSID_NAME, PASSKEY) &&
329           (verbose ? ESP8266_GetIPAddress() : true);
330}
331
332bool ESP8266_SetConnectionMux(bool multiple) {
333    char TXBuffer[32];
334    sprintf(TXBuffer, "AT+CIPMUX=%d\r\n", multiple);
335    esp_puts(TXBuffer);
336    if (ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, 0)) {
337        ESP8266_ConnectionMux = multiple;
338        return true;
339    }
340    return false;
341}
342
343bool ESP8266_StartServer(uint16_t port, uint16_t timeout) {
344    ESP8266_SetConnectionMux(true);
345    char TXBuffer[32];
346    sprintf(TXBuffer, "AT+CIPSERVER=1,%d\r\n", port);
347    esp_puts(TXBuffer);
348    if (ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, 0)) {
349        ESP8266_Server = port;
350        return ESP8266_SetServerTimeout(timeout);
351    }
352    return false;
353}
354
355bool ESP8266_StopServer(void) {
356    esp_puts("AT+CIPSERVER=0\r\n");
357    ESP8266_Server = 0;
358    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, 0) &&
359           ESP8266_SetConnectionMux(false);
360}
361
362bool ESP8266_Reset(void) {
363    esp_puts("AT+RST\r\n");
364    return ESP8266_WaitForResponse(ESP8266_READY_RESPONSE, 0);
365}
366
367bool ESP8266_Restore(void) {
368    esp_puts("AT+RESTORE\r\n");
369    return ESP8266_WaitForResponse(ESP8266_READY_RESPONSE, 0);
370}
371
372bool ESP8266_GetVersionNumber(void) {
373    esp_puts("AT+GMR\r\n");
374    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, 0);
375}
376
377bool ESP8266_GetMACAddress(void) {
378    esp_puts("AT+CIPSTAMAC?\r\n");
379    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, 0);
380}
381
382bool ESP8266_SetWifiMode(uint8_t mode) {
383    char TXBuffer[32];
384    sprintf(TXBuffer, "AT+CWMODE=%d\r\n", mode);
385    esp_puts(TXBuffer);
386    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, 0);
387}
388
389bool ESP8266_ListAccessPoints(void) {
390    esp_puts("AT+CWLAP\r\n");
391    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, ESP8266_ERROR_RESPONSE);
392}
393
394bool ESP8266_JoinAccessPoint(const char* ssid, const char* password) {
395    esp_puts("AT+CWJAP=\"");
396    esp_puts(ssid);
397    esp_puts("\",\"");
398    esp_puts(password);
399    esp_puts("\"\r\n");
400    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, ESP8266_FAIL_RESPONSE);
401}
402
403bool ESP8266_QuitAccessPoint(void) {
404    esp_puts("AT+CWQAP\r\n");
405    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, 0);
406}
407
408bool ESP8266_GetIPAddress(void) {
409    esp_puts("AT+CIFSR\r\n");
410    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, ESP8266_ERROR_RESPONSE);
411}
412
413bool ESP8266_MakeTCPConnection(char* IPaddress, uint16_t port) {
414    char TXBuffer[32];
415    esp_puts("AT+CIPSTART=\"TCP\",\"");
416    esp_puts(IPaddress);
417    sprintf(TXBuffer, "\",%d\r\n", port);
418    esp_puts(TXBuffer); // open and connect to a socket
419    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, ESP8266_ERROR_RESPONSE);
420}
421
422bool ESP8266_Send(const char* str) {
423    char TXBuffer[32];
424    if (ESP8266_ConnectionMux) {
425        sprintf(TXBuffer, "AT+CIPSEND=%d,%d\r\n", 0, strlen(str));
426    } else {
427        sprintf(TXBuffer, "AT+CIPSEND=%d\r\n", strlen(str));
428    }
429    esp_puts(TXBuffer);
430    if (!ESP8266_WaitForResponse(">", ESP8266_ERROR_RESPONSE))
431        return false;
432    esp_puts(str);
433    return ESP8266_WaitForResponse(ESP8266_SENDOK_RESPONSE,
434                                   ESP8266_ERROR_RESPONSE);
435}
436
437bool ESP8266_SendBuffered(const char* str) {
438    char TXBuffer[32];
439    if (ESP8266_ConnectionMux) {
440        sprintf(TXBuffer, "AT+CIPSEND=%d,%d\r\n", 0, strlen(str));
441    } else {
442        sprintf(TXBuffer, "AT+CIPSEND=%d\r\n", strlen(str));
443    }
444    esp_puts(TXBuffer);
445    if (!ESP8266_WaitForResponse(">", ESP8266_ERROR_RESPONSE))
446        return false;
447    esp_puts(str);
448    sprintf(TXBuffer, "Recv %d bytes", strlen(str));
449    return ESP8266_WaitForResponse(TXBuffer, ESP8266_ERROR_RESPONSE);
450}
451
452bool ESP8266_Receive(char* buf, uint32_t max) {
453    long sr;
454    uint8_t letter;
455    while (max > 1) {
456        if (fifo_size(rxdata_fifo) ||
457            ESP8266_DataAvailable) { // data (about to be) available?
458            while (fifo_try_get(rxdata_fifo, &letter) == false) {};
459            sr = start_critical();
460            if (ESP8266_DataAvailable)
461                ESP8266_DataAvailable--;
462            end_critical(sr);
463            if (letter == '\r')
464                continue;
465            if (letter == '\n')
466                break;
467            *buf = letter;
468            buf++;
469            max--;
470        } else { // wait for next packet or connection close
471            if (!ESP8266_WaitForResponse(ReceiveDataSearchString,
472                                         ESP8266_ConnectionMux ? "0,CLOSED"
473                                                               : "CLOSED")) {
474                *buf = 0; // connection closed
475                return false;
476            }
477            while (esp_getc() != ':') {} // wait for DataAvailable to be updated
478        }
479    }
480    *buf = 0; // terminate with null character
481    return true;
482}
483
484bool ESP8266_ReceiveEcho() {
485    long sr;
486    uint8_t letter;
487    while (true) {
488        if (fifo_size(rxdata_fifo) ||
489            ESP8266_DataAvailable) { // data (about to be) available?
490            while (fifo_try_get(rxdata_fifo, &letter) == false) {};
491            sr = start_critical();
492            if (ESP8266_DataAvailable)
493                ESP8266_DataAvailable--;
494            end_critical(sr);
495            if (letter == '\x03') // ETX
496                break;
497            uart_putchar(letter);
498        } else { // wait for next packet or connection close
499            if (!ESP8266_WaitForResponse(ReceiveDataSearchString,
500                                         ESP8266_ConnectionMux ? "0,CLOSED"
501                                                               : "CLOSED")) {
502                return false;
503            }
504            while (esp_getc() != ':') {} // wait for DataAvailable to be updated
505        }
506    }
507    return true;
508}
509
510bool ESP8266_CloseTCPConnection(void) {
511    esp_puts(ESP8266_ConnectionMux ? "AT+CIPCLOSE=0\r\n" : "AT+CIPCLOSE\r\n");
512    fifo_clear(rxdata_fifo);
513    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, ESP8266_ERROR_RESPONSE);
514}
515
516bool ESP8266_GetStatus(void) {
517    esp_puts("AT+CIPSTATUS\r\n");
518    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, 0);
519}
520
521bool ESP8266_SetServerTimeout(uint16_t timeout) {
522    char TXBuffer[32];
523    sprintf(TXBuffer, "AT+CIPSTO=%d\r\n", timeout);
524    esp_puts(TXBuffer);
525    return ESP8266_WaitForResponse(ESP8266_OK_RESPONSE, ESP8266_ERROR_RESPONSE);
526}
527
528bool ESP8266_WaitForConnection(void) {
529    return ESP8266_ConnectionMux && ESP8266_Server &&
530           ESP8266_WaitForResponse("0,CONNECT\r\n", 0);
531}