Revision 3:5f7286858dd0, committed 2018-02-23

Comitter:

dprowe

Date:

Fri Feb 23 17:35:16 2018 +0000

Parent:

2:1dab962fe6f0

Child:

4:84d5af56a266

Commit message:

lab6 (real one)

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ADXL362.lib	Fri Feb 23 17:35:16 2018 +0000
@@ -0,0 +1,1 @@
+ADXL362#4ad7d311e548

--- a/main.cpp	Wed Feb 07 22:47:01 2018 +0000
+++ b/main.cpp	Fri Feb 23 17:35:16 2018 +0000
@@ -1,174 +1,356 @@
+#include "mbed.h"
+#include "ADXL362.h"
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
-#include "mbed.h"
 
-#define PI        (3.141592653589793238462)
-#define AMPLITUDE (1.0)    // x * 3.3V
-#define PHASE     (PI * 1) // 2*pi is one period
-#define RANGE     (0x7FFF)
-#define OFFSET    (0x7FFF)
-
-// Configuration for sinewave output
-#define BUFFER_SIZE (120)
-uint16_t buffer[BUFFER_SIZE];
-
-Serial pc(USBTX, USBRX);
-DigitalOut led1(LED1);
-DigitalIn button(PC_13);
-AnalogOut Vout(PA_4);
+DigitalOut myled(LED1);
+ADXL362 adxl362(PA_0,PA_7,PA_6,PA_1);
 
-// Create the sinewave buffer
-void calculate_sinewave(void){
-  for (int i = 0; i < BUFFER_SIZE; i++) {
-     double rads = (PI * (i*3))/180.0; // Convert degree in radian
-     buffer[i] = (uint16_t)(AMPLITUDE * (RANGE * (cos(rads + PHASE))) + OFFSET);
-  }
-}
-
-
-void sinecom(char* inputstring) {
-    
-    calculate_sinewave();
-    char s[20];
-    char sV[20];
-    char sF[20];
-    int pos, len;
-    int i = 1;
-    strcpy(s, inputstring);
-    len = strlen(s);
-    
+int adxl362_reg_print(int start, int length) {
+    int rvalue = 0;
+    rvalue = adxl362.read_reg(ADXL362::DEVID_AD);
+    if(rvalue!=0xAD){
+        printf("value is %X\n\r",rvalue);
+        printf("error\n\r");
+        return -1;
+        }
+    else if(!(0 <= start && start < 46)){
+        printf("error\n\r");
+        return -1;
+        }
+    else if (!(length >= 0)){
+        printf("error\n\r");
+        return -1;
+        }
+    int i = 0;
     
-    for (; i < len; i++){     
-            if (s[i] == ' '){
-                pos = i;
-                break;
-                }
+    if (length!=0){
+        for (i = start; i < start+length; i++){
+            switch(i){
+                case 0 : 
+                    rvalue = adxl362.read_reg(ADXL362::DEVID_AD);
+                    printf("0x00: DEVID_AD = %X \n\r", rvalue);
+                    break;
+                case 1 :
+                    rvalue = adxl362.read_reg(ADXL362::DEVID_MST);
+                    printf("0x01: DEVID_MST = %X \n\r", rvalue);
+                    break;
+                case 2 :
+                    rvalue = adxl362.read_reg(ADXL362::PARTID);
+                    printf("0x02: PARTID = %X \n\r", rvalue);
+                    break;
+                case 3 :
+                    rvalue = adxl362.read_reg(ADXL362::REVID);
+                    printf("0x03: REVID = %X \n\r", rvalue);
+                case 4 :
+                    rvalue = adxl362.read_reg(ADXL362::XDATA);
+                    printf("0x08: XDATA = %X \n\r", rvalue);
+                    break;
+                case 5 :
+                    rvalue = adxl362.read_reg(ADXL362::YDATA);
+                    printf("0x09: YDATA = %X \n\r", rvalue);
+                    break;
+                case 6 :
+                    rvalue = adxl362.read_reg(ADXL362::ZDATA);
+                    printf("0x0A: ZDATA = %X \n\r", rvalue);
+                    break;
+                case 7 :
+                    rvalue = adxl362.read_reg(ADXL362::STATUS);
+                    printf("0x0B: STATUS = %X \n\r", rvalue);
+                    break;
+                case 8 :
+                    rvalue = adxl362.read_reg(ADXL362::FIFO_ENTRIES_L);
+                    printf("0x0C: FIFO_ENTRIES_L = %X \n\r", rvalue);
+                    break;
+                case 9 :
+                    rvalue = adxl362.read_reg(ADXL362::FIFO_ENTRIES_H);
+                    printf("0x0D: FIFO_ENTRIES_H = %X \n\r", rvalue);
+                    break;
+                case 10 :
+                    rvalue = adxl362.read_reg(ADXL362::XDATA_L);
+                    printf("0x0E: XDATA_L = %X \n\r", rvalue);
+                    break;
+                case 11 :
+                    rvalue = adxl362.read_reg(ADXL362::XDATA_H);
+                    printf("0x0F: XDATA_H = %X \n\r", rvalue);
+                    break;
+                case 12 :
+                    rvalue = adxl362.read_reg(ADXL362::YDATA_L);
+                    printf("0x10: YDATA_L = %X \n\r", rvalue);
+                    break;
+                case 13 :
+                    rvalue = adxl362.read_reg(ADXL362::YDATA_H);
+                    printf("0x11: YDATA_H = %X \n\r", rvalue);
+                    break;
+                case 14 :
+                    rvalue = adxl362.read_reg(ADXL362::ZDATA_L);
+                    printf("0x12: ZDATA_L = %X \n\r", rvalue);
+                    break;
+                case 15 :
+                    rvalue = adxl362.read_reg(ADXL362::ZDATA_H);
+                    printf("0x13: ZDATA_H = %X \n\r", rvalue);
+                    break;
+                case 16 :
+                    rvalue = adxl362.read_reg(ADXL362::TEMP_L);
+                    printf("0x14: TEMP_L = %X \n\r", rvalue);
+                    break;
+                case 17 :
+                    rvalue = adxl362.read_reg(ADXL362::TEMP_H);
+                    printf("0x15: TEMP_H = %X \n\r", rvalue);
+                    break;
+                case 18 :
+                    rvalue = adxl362.read_reg(ADXL362::SOFT_RESET);
+                    printf("0x1F: SOFT_RESET = %X \n\r", rvalue);
+                    break;
+                case 19 :
+                    rvalue = adxl362.read_reg(ADXL362::THRESH_ACT_L);
+                    printf("0x20: THRESH_ACT_L = %X \n\r", rvalue);
+                    break;
+                case 20 :
+                    rvalue = adxl362.read_reg(ADXL362::THRESH_ACT_H);
+                    printf("0x21: THRESH_ACT_H = %X \n\r", rvalue);
+                    break;
+                case 21 :
+                    rvalue = adxl362.read_reg(ADXL362::TIME_ACT);
+                    printf("0x22: TIME_ACT = %X \n\r", rvalue);
+                    break;
+                case 22 :
+                    rvalue = adxl362.read_reg(ADXL362::THRESH_INACT_L);
+                    printf("0x23: THRESH_INACT_L = %X \n\r", rvalue);
+                    break;
+                case 23 :
+                    rvalue = adxl362.read_reg(ADXL362::THRESH_INACT_H);
+                    printf("0x24: THRESH_INACT_H = %X \n\r", rvalue);
+                    break;
+                case 24 :
+                    rvalue = adxl362.read_reg(ADXL362::TIME_INACT_L);
+                    printf("0x25: TIME_INACT_L = %X \n\r", rvalue);
+                    break;
+                case 25 :
+                    rvalue = adxl362.read_reg(ADXL362::TIME_INACT_H);
+                    printf("0x26: TIME_INACT_H = %X \n\r", rvalue);
+                    break;
+                case 26 :
+                    rvalue = adxl362.read_reg(ADXL362::ACT_INACT_CTL);
+                    printf("0x27: ACT_INACT_CTL = %X \n\r", rvalue);
+                    break;
+                case 27 :
+                    rvalue = adxl362.read_reg(ADXL362::FIFO_CONTROL);
+                    printf("0x28: FIFO_CONTROL = %X \n\r", rvalue);
+                    break;
+                case 28 :
+                    rvalue = adxl362.read_reg(ADXL362::FIFO_SAMPLES);
+                    printf("0x29: FIFO_SAMPLES = %X \n\r", rvalue);
+                    break;
+                case 29 :
+                    rvalue = adxl362.read_reg(ADXL362::INTMAP1);
+                    printf("0x2A: INTMAP1 = %X \n\r", rvalue);
+                    break;
+                case 30 :
+                    rvalue = adxl362.read_reg(ADXL362::INTMAP2);
+                    printf("0x2B: INTMAP2 = %X \n\r", rvalue);
+                    break;
+                case 31 :
+                    rvalue = adxl362.read_reg(ADXL362::FILTER_CTL);
+                    printf("0x2C: FILTER_CTL = %X \n\r", rvalue);
+                    break;
+                case 32 :
+                    rvalue = adxl362.read_reg(ADXL362::POWER_CTL);
+                    printf("0x2D: POWER_CTL = %X \n\r", rvalue);
+                    break;
+                case 33 :
+                    rvalue = adxl362.read_reg(ADXL362::SELF_TEST);
+                    printf("0x2E: SELF_TEST = %X \n\r", rvalue);
+                    break;
+                default :
+                    printf("ERROR:  NO REGISTER HERE\n\r");
+                    break;
+                   }        
+            }
         }
-        
-    memcpy(sF, &s[pos], len-pos);          
-    memcpy(sV, &s[0], pos);
-    float inV = atof(sV);
-    float input_f = atof(sF);
-    pc.printf("Voltage: %f \n\r",inV);
-    pc.printf("Frequency: %f \n\r",input_f);
-
-    float wait_time = -9.955923 + (20817940 + 9.955923) / (1 + powf(input_f/0.0007111212, 1.049561));  //took data points and got this equation by estimating the graph with computer, results in 1-3% error
+    else {
+        for (i = 0; i < 34; i++){
+            switch(i){
+                case 0 : 
+                    rvalue = adxl362.read_reg(ADXL362::DEVID_AD);
+                    printf("0x00: DEVID_AD = %X \n\r", rvalue);
+                    break;
+                case 1 :
+                    rvalue = adxl362.read_reg(ADXL362::DEVID_MST);
+                    printf("0x01: DEVID_MST = %X \n\r", rvalue);
+                    break;
+                case 2 :
+                    rvalue = adxl362.read_reg(ADXL362::PARTID);
+                    printf("0x02: PARTID = %X \n\r", rvalue);
+                    break;
+                case 3 :
+                    rvalue = adxl362.read_reg(ADXL362::REVID);
+                    printf("0x03: REVID = %X \n\r", rvalue);
+                    break;
+                case 4 :
+                    rvalue = adxl362.read_reg(ADXL362::XDATA);
+                    printf("0x08: XDATA = %X \n\r", rvalue);
+                    break;
+                case 5 :
+                    rvalue = adxl362.read_reg(ADXL362::YDATA);
+                    printf("0x09: YDATA = %X \n\r", rvalue);
+                    break;
+                case 6 :
+                    rvalue = adxl362.read_reg(ADXL362::ZDATA);
+                    printf("0x0A: ZDATA = %X \n\r", rvalue);
+                    break;
+                case 7 :
+                    rvalue = adxl362.read_reg(ADXL362::STATUS);
+                    printf("0x0B: STATUS = %X \n\r", rvalue);
+                    break;
+                case 8 :
+                    rvalue = adxl362.read_reg(ADXL362::FIFO_ENTRIES_L);
+                    printf("0x0C: FIFO_ENTRIES_L = %X \n\r", rvalue);
+                    break;
+                case 9 :
+                    rvalue = adxl362.read_reg(ADXL362::FIFO_ENTRIES_H);
+                    printf("0x0D: FIFO_ENTRIES_H = %X \n\r", rvalue);
+                    break;
+                case 10 :
+                    rvalue = adxl362.read_reg(ADXL362::XDATA_L);
+                    printf("0x0E: XDATA_L = %X \n\r", rvalue);
+                    break;
+                case 11 :
+                    rvalue = adxl362.read_reg(ADXL362::XDATA_H);
+                    printf("0x0F: XDATA_H = %X \n\r", rvalue);
+                    break;
+                case 12 :
+                    rvalue = adxl362.read_reg(ADXL362::YDATA_L);
+                    printf("0x10: YDATA_L = %X \n\r", rvalue);
+                    break;
+                case 13 :
+                    rvalue = adxl362.read_reg(ADXL362::YDATA_H);
+                    printf("0x11: YDATA_H = %X \n\r", rvalue);
+                    break;
+                case 14 :
+                    rvalue = adxl362.read_reg(ADXL362::ZDATA_L);
+                    printf("0x12: ZDATA_L = %X \n\r", rvalue);
+                    break;
+                case 15 :
+                    rvalue = adxl362.read_reg(ADXL362::ZDATA_H);
+                    printf("0x13: ZDATA_H = %X \n\r", rvalue);
+                    break;
+                case 16 :
+                    rvalue = adxl362.read_reg(ADXL362::TEMP_L);
+                    printf("0x14: TEMP_L = %X \n\r", rvalue);
+                    break;
+                case 17 :
+                    rvalue = adxl362.read_reg(ADXL362::TEMP_H);
+                    printf("0x15: TEMP_H = %X \n\r", rvalue);
+                    break;
+                case 18 :
+                    rvalue = adxl362.read_reg(ADXL362::SOFT_RESET);
+                    printf("0x1F: SOFT_RESET = %X \n\r", rvalue);
+                    break;
+                case 19 :
+                    rvalue = adxl362.read_reg(ADXL362::THRESH_ACT_L);
+                    printf("0x20: THRESH_ACT_L = %X \n\r", rvalue);
+                    break;
+                case 20 :
+                    rvalue = adxl362.read_reg(ADXL362::THRESH_ACT_H);
+                    printf("0x21: THRESH_ACT_H = %X \n\r", rvalue);
+                    break;
+                case 21 :
+                    rvalue = adxl362.read_reg(ADXL362::TIME_ACT);
+                    printf("0x22: TIME_ACT = %X \n\r", rvalue);
+                    break;
+                case 22 :
+                    rvalue = adxl362.read_reg(ADXL362::THRESH_INACT_L);
+                    printf("0x23: THRESH_INACT_L = %X \n\r", rvalue);
+                    break;
+                case 23 :
+                    rvalue = adxl362.read_reg(ADXL362::THRESH_INACT_H);
+                    printf("0x24: THRESH_INACT_H = %X \n\r", rvalue);
+                    break;
+                case 24 :
+                    rvalue = adxl362.read_reg(ADXL362::TIME_INACT_L);
+                    printf("0x25: TIME_INACT_L = %X \n\r", rvalue);
+                    break;
+                case 25 :
+                    rvalue = adxl362.read_reg(ADXL362::TIME_INACT_H);
+                    printf("0x26: TIME_INACT_H = %X \n\r", rvalue);
+                    break;
+                case 26 :
+                    rvalue = adxl362.read_reg(ADXL362::ACT_INACT_CTL);
+                    printf("0x27: ACT_INACT_CTL = %X \n\r", rvalue);
+                    break;
+                case 27 :
+                    rvalue = adxl362.read_reg(ADXL362::FIFO_CONTROL);
+                    printf("0x28: FIFO_CONTROL = %X \n\r", rvalue);
+                    break;
+                case 28 :
+                    rvalue = adxl362.read_reg(ADXL362::FIFO_SAMPLES);
+                    printf("0x29: FIFO_SAMPLES = %X \n\r", rvalue);
+                    break;
+                case 29 :
+                    rvalue = adxl362.read_reg(ADXL362::INTMAP1);
+                    printf("0x2A: INTMAP1 = %X \n\r", rvalue);
+                    break;
+                case 30 :
+                    rvalue = adxl362.read_reg(ADXL362::INTMAP2);
+                    printf("0x2B: INTMAP2 = %X \n\r", rvalue);
+                    break;
+                case 31 :
+                    rvalue = adxl362.read_reg(ADXL362::FILTER_CTL);
+                    printf("0x2C: FILTER_CTL = %X \n\r", rvalue);
+                    break;
+                case 32 :
+                    rvalue = adxl362.read_reg(ADXL362::POWER_CTL);
+                    printf("0x2D: POWER_CTL = %X \n\r", rvalue);
+                    break;
+                case 33 :
+                    rvalue = adxl362.read_reg(ADXL362::SELF_TEST);
+                    printf("0x2E: SELF_TEST = %X \n\r", rvalue);
+                    break;
+                default :
+                    printf("ERROR:  NO REGISTER HERE\n\r");
+                    break;
+                   }        
+            }     
+        }
     
-    while(!pc.readable()) {      
-        // sinewave output
-        for (int i = 0; i < BUFFER_SIZE; i++) {
-            Vout.write_u16(buffer[i]/(3.30 * (1.00/inV)));
-            wait_us((int)wait_time);
-        }
+    return 0;
     }
-    return;
-}
-
-void ledcom(char* onoff)
-{
-    if(strstr(onoff, "ON") != NULL)
-        led1 = 1; 
-    else 
-        led1 = 0;
-}
-
-void buttoncom(void)
-{
-    if(button.read() == 0){
-        pc.printf("PRESSED \n\r");
-        }
-    else if (button.read() != 0) {
-        pc.printf("RELEASED \n\r");
-        }
+    
+int blink() {
+        myled = 1; // LED is ON
+        wait(2); // 2 sec
+        myled = 0; // LED is OFF
+        return 0;
 }
 
-void blinkcom(char* reps)
-{
-    int x = atoi(reps);
-    int i;
-    for(i = 0; i < x; i++)
-    {
-        led1 = 1;
-        wait(.5);
-        led1 = 0;
-        wait(.5);
-    }
-}
-
-void dccom(char *volts)
-{
-    float volt = atof(volts);
-    pc.printf("voltage output: %4.2f \n\r", volt);
-    Vout.write_u16((volt/3.317)*0xFFFF); 
-}
-
-
 int main() {
-    char s[20];
-    pc.printf("Enter command \n\r");
-    while (true) {
-        int j = 0;
-        char c;
+    wait_ms(600); // we need to wait at least 500ms after ADXL362 reset
+    adxl362.set_mode(ADXL362::MEASUREMENT);
+    int8_t x,y,z; 
+    int8_t nx, ny, nz;
+    adxl362_reg_print(0, 0); // call register printing here
+    adxl362_reg_print(0, 5);
+    adxl362_reg_print(4, 6);
+    //while (1) {adxl362_reg_print(0, 0);} to print forever
     
-        while(true){
-            c = pc.getc();
-            pc.putc(c);
-            s[j]=c;
-            j++;
-            if(c == '\r'){
-                pc.printf("\n\r");
-                break;
-                }
-            }
-        s[j] = '\0'; 
-        char s_one[20];
-        char s_two[20];
-        int len = strlen(s);
-        int pos = 0;
-        
-        int i = 0;
-        for (; i < len; i++){
-            
-            if (s[i] == ' '){
-                pos = i;
-                break;
-                }
-            else if (i == len)
-                pos = len+1;
+    int blink_c = 0;
+    x=adxl362.scanx_u8();
+    y=adxl362.scany_u8();
+    z=adxl362.scanz_u8();
+
+    while(1) { //detects knocks
+        x=adxl362.scanx_u8();
+        y=adxl362.scany_u8();
+        z=adxl362.scanz_u8();
+        wait_us(100);
+        nx=adxl362.scanx_u8();
+        ny=adxl362.scany_u8();
+        nz=adxl362.scanz_u8();
+        if ((abs(x-nx)>=4) || (abs(y-ny)>=4) || (abs(z-nz)>=4)){ 
+            blink_c += 1;
+            printf("number of knocks detected: %d\n\r",blink_c);
+            blink();
         }
-        
-        
-        if (pos <= len){
-            memcpy(s_two, &s[pos], len-pos);
-            s_two[len - pos] = '\0';
-            
-            memcpy(s_one, &s[0], pos+1);
-            s_one[pos] = '\0';
-            }
-        
-        else {
-            memcpy(s_one, &s[0], len);
-            s_one[len] = '\0';
-            pc.printf("%s \n\r", s_one);
-            }//case where there is no space  
-
-
-        if (strstr(s_one, "LED") != NULL) {
-            ledcom(s_two);
-            }
-        else if (strstr(s, "BUTTON") != NULL) {
-            buttoncom();
-            }
-        else if (strstr(s_one, "BLINK") != NULL) {
-            blinkcom(s_two);
-            }
-        else if (strstr(s_one, "DC") != NULL) {
-            dccom(s_two);
-            }
-        else if (strstr(s_one, "SINE") != NULL){
-            sinecom(s_two);
-            }
-        else pc.printf("Bad command, try again buddy \n\r");         
-        }
+    } 
 }
\ No newline at end of file

--- a/report.txt	Wed Feb 07 22:47:01 2018 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-
-RESULTS:
-Our end results were fairly good in terms of expected output, given the difficulty
-of the task.  When looking at our results of 1V sine waves, We noted marked 
-decrease in output voltage of sine waves that had over 200Hz.  We also noted
-some decreases at all increasing frequencies from the initial 100Hz.  This is 
-evidence that our low pass filter is functioning differently than an ideal low
-pass filter.  
-
-Difficulties:
-We had huge difficutlies with creating a sinewave that had accurate amplitude 
-and frequency.  We eventually achieved this simply by taking several data points
-from inputs of 5 - 70 micro seconds in delay, with ouputs of frequency from 
-100Hz - 500Hz, in delay and using this data to create a function that would then 
-work in the reverse.  That is to say that we used the data points with frequency
-as an input and the wait time as an output to convert input frequencies to 
-wait times that the STM board would then use to output the correct frequencies. 
-This function was relatively accurate, and ended up being more accurate than the
-relatively simple and "exact" mathmatically correct function that converts 
-frequency to delta time.
-
-Expected vs Actual Results:
-Due to this somewhat "approximate" approach to creating the correct frequency, 
-we obviously had some differences in our actual results when compared to our 
-expected results.  Our generated function was most accuate at low voltages and low
-frequencies, often achieving less than 1% error in the 1V and 100Hz range.  When 
-using higher frequencies, the function would usually output a frequency that was 
-roughly 2-4% higher than our desired frequency.  The voltage output was a similar
-story, with 1V being almost perfect, while 3V was usually off by around 3-5%.  
-Because of these differences, and the nature of imperfect capacitors and resistors,
-our actual results when measuring our low pass filter were even further from
-the ideal results.  We did note marked decrease in the output strength of 
-frequencies over 200Hz, but not as sharp of decreases as expected.  We also 
-meausured a decrease in strength of the signal even when frequency was still below
-200Hz, which should only happen when very close to 200Hz.  These differences 
-must be attributed to many factors, the primary ones being slightly incorrect 
-voltage and frequency outputs, imperfect wires, resistor, and capacitors, and 
-some limitations in the measuring equipment.
\ No newline at end of file