embedded smtf7 based scope

Dependencies:   BSP_DISCO_F746NG_patch_fixed mbed

Files at this revision

API Documentation at this revision

Comitter:
the_sz
Date:
Wed Nov 18 14:31:49 2015 +0000
Commit message:
1.01

Changed in this revision

BSP_DISCO_F746NG_patch_fixed.lib Show annotated file Show diff for this revision Revisions of this file
Interface.h Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
mbed.bld Show annotated file Show diff for this revision Revisions of this file
diff -r 000000000000 -r 0babd18ae684 BSP_DISCO_F746NG_patch_fixed.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/BSP_DISCO_F746NG_patch_fixed.lib	Wed Nov 18 14:31:49 2015 +0000
@@ -0,0 +1,1 @@
+https://developer.mbed.org/users/the_sz/code/BSP_DISCO_F746NG_patch_fixed/#3c0a51826ecc
diff -r 000000000000 -r 0babd18ae684 Interface.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Interface.h	Wed Nov 18 14:31:49 2015 +0000
@@ -0,0 +1,62 @@
+#ifndef __Interface_h
+#define __Interface_h
+
+#pragma pack(1)
+
+#define BUFFER_SIZE             1000            // number of samples per HT_DATA report
+
+#define CHANNEL_COUNT           2
+#define HEADER_MAGIC            0x53636F70      // 'Scop'
+
+typedef enum
+{
+    HT_NONE,
+    HT_DATA,
+    HT_INFO_REQUEST,
+    HT_INFO_RESPONSE,
+    HT_CAPTURE_START,
+
+} HEADER_TYPE_ENUM;
+
+typedef struct
+{
+    float                       values[CHANNEL_COUNT];
+
+} VALUES_STRUCT;
+
+typedef struct
+{
+    uint32_t                    magic;
+    uint8_t                     type;
+    uint32_t                    length;                     // length in bytes of following data
+
+} HEADER_STRUCT;
+
+typedef struct
+{
+    uint8_t                     versionMajor;
+    uint8_t                     versionMinor;
+    char                        name[20];
+
+} INTERFACE_INFO_RESPONSE_STRUCT;
+
+typedef enum
+{
+    TM_NONE                     =0x00,
+    TM_RAISING                  =0x01,
+    TM_FALLING                  =0x02,
+    TM_AUTO                     =0x04,
+    
+} TRIGGER_MODE_ENUM;
+
+typedef struct
+{
+    float                       triggerLevel;
+    uint8_t                     triggerMode;
+    uint16_t                    delay;                      // in usec
+
+} INTERFACE_CAPTURE_START_STRUCT;
+
+#pragma pack()
+
+#endif
diff -r 000000000000 -r 0babd18ae684 main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Wed Nov 18 14:31:49 2015 +0000
@@ -0,0 +1,229 @@
+#include "mbed.h"
+#include "stm32746g_discovery_lcd.h"
+
+#include "Interface.h"
+
+DigitalOut                      led(LED1);
+Serial                          serial(PA_9,PB_7);          // serial 1
+AnalogIn                        analogIn1(A0);
+AnalogIn                        analogIn2(A1);
+VALUES_STRUCT                   buffer[BUFFER_SIZE];
+uint8_t                         commandBuffer[100];
+uint32_t                        commandLength;
+
+void sendBuffer(uint8_t *buffer,uint32_t length)
+{
+    while (length>0)
+    {
+        serial.putc(*buffer);
+
+        buffer++;
+        length--;
+    }
+}
+
+void sendCommand(HEADER_TYPE_ENUM type,uint8_t *buffer,uint32_t length)
+{
+    HEADER_STRUCT               header;
+
+    header.magic=HEADER_MAGIC;
+    header.type=type;
+    header.length=length;
+
+    sendBuffer((uint8_t *)&header,sizeof(header));
+    sendBuffer(buffer,length);
+}
+
+bool readWithTimeout(uint8_t *buffer)
+{
+    uint32_t counter;
+
+    counter=0;
+    while (counter<10000)
+    {
+        if (serial.readable())
+        {
+            (*buffer)=serial.getc();
+            return true;
+        }
+
+        wait_us(50);
+
+        counter++;
+    }
+
+    // re-init serial port
+    serial.baud(115200);
+
+    return false;
+}
+
+HEADER_TYPE_ENUM readCommand(void)
+{
+    HEADER_STRUCT               *header;
+    uint32_t                    index;
+    HEADER_TYPE_ENUM            type;
+
+    for (index=0;index<sizeof(HEADER_STRUCT);index++)
+    {
+        if (readWithTimeout(&commandBuffer[index])==false)
+            return HT_NONE;
+    }
+
+    header=(HEADER_STRUCT *)commandBuffer;
+    if (header->magic!=HEADER_MAGIC)
+            return HT_NONE;
+
+    type=(HEADER_TYPE_ENUM)header->type;
+        
+    if (header->length>0)
+    {
+        commandLength=header->length;
+
+        for (index=0;index<commandLength;index++)
+        {
+            if (readWithTimeout(&commandBuffer[index])==false)
+            return HT_NONE;
+        }
+    }
+
+    return type;
+}
+
+int main()
+{
+    int32_t                         index;
+    int32_t                         indexPrevious;
+    int32_t                         stop;
+    HEADER_TYPE_ENUM                type;
+    bool                            capture;
+    float                           triggerLevel;
+    uint8_t                         triggerMode;
+    uint16_t                        delay;
+    bool                            triggered;
+
+    serial.baud(115200);
+
+    BSP_LCD_Init();
+    BSP_LCD_DisplayOff();
+
+    capture=false;
+    triggerLevel=0.0;
+    triggerMode=TM_NONE;
+    delay=0;
+
+    for (;;)
+    {
+        if (serial.readable())
+        {
+            type=readCommand();
+            switch (type)
+            {
+                case HT_INFO_REQUEST:
+                    {
+                        INTERFACE_INFO_RESPONSE_STRUCT              InfoResponse;
+                        
+                        memset(&InfoResponse,0,sizeof(InfoResponse));
+                        InfoResponse.versionMajor=1;
+                        InfoResponse.versionMinor=0;
+                        snprintf(InfoResponse.name,sizeof(InfoResponse.name),"Scope");
+                        sendCommand(HT_INFO_RESPONSE,(uint8_t *)&InfoResponse,sizeof(InfoResponse));
+                    }
+                    break;
+                    
+                case HT_CAPTURE_START:
+                    {
+                        INTERFACE_CAPTURE_START_STRUCT              *captuerStart;
+                        
+                        if (commandLength==sizeof(INTERFACE_CAPTURE_START_STRUCT))
+                        {
+                            captuerStart=(INTERFACE_CAPTURE_START_STRUCT *)commandBuffer;
+    
+                            triggerLevel=captuerStart->triggerLevel;
+                            triggerMode=captuerStart->triggerMode;
+                            delay=captuerStart->delay;
+
+                            // seems our measurement loop needs 5 µs per loop
+                            if (delay>5)
+                                delay-=5;
+    
+                            capture=true;
+                        }
+                    }
+                    break;
+            }
+        }
+        
+        if (capture==true)
+        {
+            led=1;
+    
+            // dummy read for nicer results
+            for (index=0;index<5;index++)
+            {
+                analogIn1.read();
+                analogIn2.read();
+            }
+     
+            stop=0;
+            index=0;
+            indexPrevious=0;
+            triggered=false;
+            for (;;)
+            {
+                buffer[index].values[0]=analogIn1.read();
+                buffer[index].values[1]=analogIn2.read();
+        
+                // check for trigger
+                if ((triggered==false) && (index>(BUFFER_SIZE/2)))
+                {
+                    // we trigger only on channel 1
+                    if ((triggerMode & TM_RAISING)!=0)
+                        if (buffer[indexPrevious].values[0]<triggerLevel)
+                            if (buffer[index].values[0]>=triggerLevel)
+                                triggered=true;
+                    if ((triggerMode & TM_FALLING)!=0)
+                        if (buffer[indexPrevious].values[0]>triggerLevel)
+                            if (buffer[index].values[0]<=triggerLevel)
+                                triggered=true;
+
+                    if (triggered==true)
+                        stop=(index + (BUFFER_SIZE / 2)) % BUFFER_SIZE;
+                }
+
+                indexPrevious=index;
+
+                index++;
+                if (index>=BUFFER_SIZE)
+                    index=0;
+
+                if (index==stop)
+                    break;
+
+                wait_us(delay);
+            }
+
+            led=0;
+            capture=false;
+
+            if ((triggered==true) || ((triggerMode & TM_AUTO)!=0))
+            {
+                HEADER_STRUCT               header;
+
+                header.magic=HEADER_MAGIC;
+                header.type=HT_DATA;
+                header.length=sizeof(buffer);
+
+                // send header
+                sendBuffer((uint8_t *)&header,sizeof(header));
+                // send part 1
+                sendBuffer((uint8_t *)&buffer[stop],((BUFFER_SIZE-stop)*sizeof(VALUES_STRUCT)));
+                // send part 2
+                if (stop>0)
+                    sendBuffer((uint8_t *)&buffer[0],(stop*sizeof(VALUES_STRUCT)));
+            }
+            else
+                sendCommand(HT_DATA,(uint8_t *)&buffer,0);
+        }
+    }
+}
diff -r 000000000000 -r 0babd18ae684 mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Wed Nov 18 14:31:49 2015 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/9296ab0bfc11
\ No newline at end of file