Diff: main.cpp

Revision:

0:9d5134074d84

Child:

1:af7a42f7d465

diff -r 000000000000 -r 9d5134074d84 main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Fri Jul 08 23:52:38 2016 +0000
@@ -0,0 +1,273 @@
+#include "mbed.h"
+#include <cctype>
+#include <string>
+#include "SerialBuffered.h"
+#include "HTS221.h"
+
+// comment out the following line if color is not supported on the terminal
+#define USE_COLOR
+#ifdef USE_COLOR
+ #define BLK "\033[30m"
+ #define RED "\033[31m"
+ #define GRN "\033[32m"
+ #define YEL "\033[33m"
+ #define BLU "\033[34m"
+ #define MAG "\033[35m"
+ #define CYN "\033[36m"
+ #define WHT "\033[37m"
+ #define DEF "\033[39m"
+#else
+ #define BLK
+ #define RED
+ #define GRN
+ #define YEL
+ #define BLU
+ #define MAG
+ #define CYN
+ #define WHT
+ #define DEF
+#endif
+
+#define MDM_DBG_OFF                             0
+#define MDM_DBG_AT_CMDS                         (1 << 0)
+int mdm_dbgmask = MDM_DBG_OFF;
+
+Serial         pc(USBTX, USBRX);
+SerialBuffered mdm(PTD3, PTD2, 128);
+DigitalOut     led_red(LED_RED);
+DigitalOut     led_green(LED_GREEN);
+
+DigitalOut  mdm_uart2_rx_boot_mode_sel(PTC17);  // on powerup, 0 = boot mode, 1 = normal boot
+DigitalOut  mdm_power_on(PTB9);                 // 0 = turn modem on, 1 = turn modem off (should be held high for >5 seconds to cycle modem)
+DigitalOut  mdm_wakeup_in(PTC2);                // 0 = let modem sleep, 1 = keep modem awake -- Note: pulled high on shield
+
+DigitalOut  shield_3v3_1v8_sig_trans_ena(PTC4); // 0 = disabled (all signals high impedence, 1 = translation active
+DigitalOut  mdm_uart1_cts(PTD0);
+
+#define TOUPPER(a) (a) //toupper(a)
+
+const char ok_str[] = "OK";
+const char error_str[] = "ERROR";
+
+#define MDM_OK                                  0
+#define MDM_ERR_TIMEOUT                         -1
+
+#define MAX_AT_RSP_LEN                          255
+
+//
+// The modem will return strings of HEX encoded data.  This function takes
+// a pointer to a string of HEX ASCII data and converts it into a string
+// of ASCII data.  It takes a pointer to the string of HEX ASCII data and
+// a pointer to the destination string.  It returns the number of characters
+// it converted.
+//
+int DecodeASCIIstr(string& ins, string& outs) {
+    int val, n = 0;
+    char ts[2];
+    
+    while(n<ins.length()) {
+        val = atoi((const char*)ins[n])*16+atoi((const char*)ins[n+1]);
+        sprintf(ts,"%c",val);
+        outs.append(ts);
+        n += 2;
+     }
+     return outs.length();
+}
+
+
+//
+// Modem expects data to be passed to it in the form of HEX encoded strings.  This
+// function takes a pointer to a users supplied ASCII string, and converts it into
+// an ASCII string of equivelent HEX numbers encoded as a string.  The function takes
+// a pointer to the users input string, and a pointer to the output string.  The
+// function returns the number of characters converted or 0 if an error occurs or more
+// than 750 characters were converted.  The 750 chacter limit is because the modem
+// will only accept up to 1500 characters, and the converted srings will be 2x the
+// input string since the hex representation of 1 character is a two digit hex value.
+//
+int CreateASCIIstr(string& in, string& out) {
+    int i = 0;
+    char ts[3];
+    
+    if( in.length() > 749 )
+      return 0;
+
+    while(in[i] != 0x00) {
+        sprintf(ts,"%02X", in[i]);
+        out.append(ts);
+        i++;
+        }
+    return out.length();
+}
+
+
+
+ssize_t mdm_getline(char *buff, size_t size, int timeout_ms) {
+    int cin = -1;
+    int cin_last;
+    
+    if (NULL == buff || size == 0) {
+        return -1;
+    }
+
+    size_t len = 0;
+    Timer timer;
+    timer.start();
+    while ((len < (size-1)) && (timer.read_ms() < timeout_ms)) {
+        if (mdm.readable()) {
+            cin_last = cin;
+            cin = mdm.getc();
+            if (isprint(cin)) {
+                buff[len++] = (char)cin;
+                continue;
+            } else if (('\r' == cin_last) && ('\n' == cin)) {
+                break;
+            }
+        }
+        wait_ms(1);
+    }
+    buff[len] = NULL;
+    
+    return len;
+}
+
+int mdm_sendAtCmd(const char *cmd, const char **rsp_list, int timeout_ms) {
+    if (cmd && strlen(cmd) > 0) {
+        if (mdm_dbgmask & MDM_DBG_AT_CMDS) {
+            printf(MAG "ATCMD: " DEF "--> " GRN "%s" DEF "\n", cmd);
+        }
+        mdm.printf("%s\r\n", cmd);
+    }
+    
+    if (rsp_list) {
+        Timer   timer;
+        char    rsp[MAX_AT_RSP_LEN+1];
+        int     len;
+        
+        timer.start();
+        while (timer.read_ms() < timeout_ms) {
+            len = mdm_getline(rsp, sizeof(rsp), timeout_ms - timer.read_ms());
+            
+            if (len < 0)
+                return MDM_ERR_TIMEOUT;
+
+            if (len == 0)
+                continue;
+                
+            if (mdm_dbgmask & MDM_DBG_AT_CMDS) {
+                printf(MAG "ATRSP: " DEF "<-- " CYN "%s" DEF "\n", rsp);
+            }
+        
+            if (rsp_list) {
+                int rsp_idx = 0;
+                while (rsp_list[rsp_idx]) {
+                    if (strcasecmp(rsp, rsp_list[rsp_idx]) == 0) {
+                        return rsp_idx;
+                    }
+                    rsp_idx++;
+                }
+            }
+        }
+        return MDM_ERR_TIMEOUT;
+    }
+    return MDM_OK;
+}
+
+int mdm_init(void) {
+    // disable signal level translator
+    shield_3v3_1v8_sig_trans_ena = 0;
+
+    // power modem on //off
+    mdm_power_on = 0; //1;
+    
+    // insure modem boots into normal operating mode
+    // and does not go to sleep when powered on
+    mdm_uart2_rx_boot_mode_sel = 1;
+    mdm_wakeup_in = 1;
+    
+    // initialze comm with the modem
+    mdm.baud(115200);
+    mdm_uart1_cts = 0;
+    
+    // enable the signal level translator to start
+    // modem reset process (modem will be powered down)
+    shield_3v3_1v8_sig_trans_ena = 1;
+    
+    // Give the modem 60 secons to start responding by
+    // sending simple 'AT' commands to modem once per second.
+    Timer timer;
+    timer.start();
+    while (timer.read() < 60) {
+        const char * rsp_lst[] = { ok_str, error_str, NULL };
+        int rc = mdm_sendAtCmd("AT", rsp_lst, 500);
+        if (rc == 0)
+            return timer.read();
+        wait_ms(1000 - (timer.read_ms() % 1000));
+        pc.printf("\r%d",timer.read_ms()/1000);
+    }
+    return false;       
+}
+
+#define CTOF(x)  ((x)*1.8+32)
+
+int main() {
+    HTS221 hts221;
+    pc.baud(115200);
+    int i,
+        CreateASCIIstr(string& in, string& out), 
+        DecodeASCIIstr(string& ins, string& outs);
+    string ins, outs;
+    
+    void hts221_init(void);
+
+    pc.printf(BLU "Hello World from AT&T Shape!\r\n");
+    pc.printf(GRN "Initialize the HTS221\n\r");
+
+    i = hts221.begin();  
+    if( i ) 
+        pc.printf(BLU "HTS221 Detected! (0x%02X)\n\r",i);
+    else
+        pc.printf(RED "HTS221 NOT DETECTED!!\n\r");
+
+    printf("Temp  is: %0.2f F \n\r",CTOF(hts221.readTemperature()));
+    printf("Humid is: %02d %%\n\r",hts221.readHumidity());
+    
+    // Initialize the modem
+    printf(GRN "Modem initializing... will take up to 60 seconds" DEF "\r\n");
+    i=mdm_init();
+    if (!i) {
+        pc.printf(RED "Modem initialization failed!" DEF "\n");
+        while (1);
+    }
+    
+    // Now that the modem is up and running, transfer characters
+    // between the pc terminal and the modem to give the user
+    // a virtual terminal to the modem.
+    pc.printf(YEL "\rAT command interface ready, completed in %d seconds.  You may now type AT commands" DEF "\r\n",i);
+   
+    while(1) {
+        if(pc.readable()) {
+            char char_in = TOUPPER(pc.getc());
+            
+            static char last_char_in = 0;
+
+            if (('\r' == char_in) || ('\n' == char_in))
+            {
+                if (('\r' == char_in) || ('\r' != last_char_in))
+                {
+                    mdm.puts("\r\n");
+                }
+            }
+            else
+            {
+                pc.putc(char_in);
+                mdm.putc(char_in);
+            }
+            last_char_in = char_in;
+        }
+        if(mdm.readable()) {
+            char ser_char = mdm.getc();
+                pc.putc(ser_char);
+            }
+    }
+}