Revision 2:e23243b26a23, committed 2020-06-09

Comitter:

bolko

Date:

Tue Jun 09 11:23:48 2020 +0000

Parent:

1:d562d46c33b7

Commit message:

look;

Changed in this revision

--- a/TS_DISCO_F429ZI.lib	Wed May 20 07:59:22 2020 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-https://os.mbed.com/teams/ST/code/TS_DISCO_F429ZI/#4f8b6df8e235

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/command_decoder.cpp	Tue Jun 09 11:23:48 2020 +0000
@@ -0,0 +1,80 @@
+#include "command_decoder.h"
+#include <string.h>
+#include <iostream>
+#include "mbed.h"
+
+struct Keyword asKeywordList[MAX_KEYWORD_NR]=
+    {
+        {ID, "id"},
+        {CALLIB, "callib"},
+        {GOTO, "goto"},
+        {STEP, "step"}
+    };
+struct Token asToken[MAX_TOKEN_NR];
+enum State {TOKEN,DELIMITER};
+unsigned char ucTokenNr = 0;
+
+unsigned char CommandDecoder::ucFindTokensInString(char *pcString){
+    char * pCurrentToken;
+    unsigned char ucTokenCounter = 0;
+    
+    pCurrentToken = strtok(pcString, " ");
+    while(NULL != pCurrentToken && ucTokenCounter < MAX_TOKEN_NR){
+        asToken[ucTokenCounter].uValue.pcString = pCurrentToken;
+        ucTokenCounter++;
+        pCurrentToken = strtok(NULL, " ");
+    }    
+    return ucTokenCounter;
+}
+
+
+enum Result CommandDecoder::eStringToKeyword(char pcStr[],enum KeywordCode *peKeywordCode){
+    unsigned char ucKeywordCounter;
+    for(ucKeywordCounter=0;ucKeywordCounter<MAX_KEYWORD_NR;ucKeywordCounter++)
+    {
+        if (strcmp(pcStr,asKeywordList[ucKeywordCounter].cString) == 0)
+        {
+            *peKeywordCode = asKeywordList[ucKeywordCounter].eCode;
+            return OK;
+        }
+    }
+    return FAIL;
+};
+
+
+enum Result CommandDecoder::DecodeTokens(){
+    
+    unsigned int uiNumber;
+    unsigned char ucTokenIndex;
+    enum KeywordCode eKeyword;
+    
+    for(ucTokenIndex=0; ucTokenIndex < ucTokenNr; ucTokenIndex++){
+        if((eStringToKeyword (asToken[ucTokenIndex].uValue.pcString, &eKeyword))== OK){
+            asToken[ucTokenIndex].eType = KEYWORD;
+            asToken[ucTokenIndex].uValue.eKeyword=eKeyword;
+        }
+        else if(sscanf(asToken[ucTokenIndex].uValue.pcString,"%x",&uiNumber) == 1){ 
+            asToken[ucTokenIndex].eType = NUMBER;
+            asToken[ucTokenIndex].uValue.uiNumber = uiNumber;       
+        }
+        else{
+            asToken[ucTokenIndex].eType = STRING;
+        }
+    }
+    return OK;
+}
+
+
+void CommandDecoder::ReplaceCharactersInString(char pcString[], char cOldChar,char cNewChar){
+    char *pString = pcString;
+    while((pString = strchr(pString,cOldChar)) != NULL){
+        *pString++ = cNewChar;
+    }    
+}    
+
+
+void CommandDecoder::DecodeMsg(char *pcString){
+    ucTokenNr = ucFindTokensInString(pcString);
+    ReplaceCharactersInString(pcString,' ', NULL);
+    DecodeTokens();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/command_decoder.h	Tue Jun 09 11:23:48 2020 +0000
@@ -0,0 +1,47 @@
+#ifndef COMMAND_DECODER_H
+#define COMMAND_DECODER_H
+#include "mbed.h"
+#include <string>
+
+#define MAX_TOKEN_NR 2 
+#define MAX_KEYWORD_STRING_LTH 6
+#define MAX_KEYWORD_NR 4
+#define DELIMITER_CHAR 0x20
+
+enum TokenType { KEYWORD, NUMBER, STRING};
+enum KeywordCode {ID,CALLIB,GOTO,STEP};
+enum Result { OK, FAIL };
+
+
+union TokenValue {
+    enum KeywordCode eKeyword;
+    unsigned int uiNumber;
+    char *pcString;
+};
+
+struct Token {
+    enum TokenType eType; 
+    union TokenValue uValue;
+};
+
+struct Keyword {
+    enum KeywordCode eCode;
+    char cString[MAX_KEYWORD_STRING_LTH + 1]; 
+};
+
+class CommandDecoder {
+    public:
+        void DecodeMsg(char *pcString);
+        struct Token asToken[MAX_TOKEN_NR];
+        unsigned char ucTokenNr;
+    private:
+        enum Result eHexStringToUInt(char pcStr[],unsigned int *puiValue);
+        void ReplaceCharactersInString(char pcString[], char cOldChar,char cNewChar);
+        void TokenizeString(char *pcString);
+        unsigned char ucFindTokensInString(char *pcString);
+        enum Result eStringToKeyword(char pcStr[],enum KeywordCode *peKeywordCode);
+        enum Result DecodeTokens();
+       
+};    
+
+#endif
\ No newline at end of file

--- a/keyboard_ts.cpp	Wed May 20 07:59:22 2020 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,29 +0,0 @@
-#include "keyboard_ts.h"
-#include "TS_DISCO_F429ZI.h"
-
-TS_DISCO_F429ZI ts;
-
-KeyboardTs::KeyboardTs(uint8_t WhichColumn){
-        ts.Init(240,320);
-        ui8Column = ((WhichColumn > 1) && (WhichColumn <= 3)) ? WhichColumn: 1;
-};
-enum KeyboardState KeyboardTs::eRead(void){
-        TS_StateTypeDef TS_State; 
-        ts.GetState(&TS_State);
-        
-             if(TS_State.TouchDetected &&(TS_State.X > (80*(ui8Column-1))) && (TS_State.X<(80*ui8Column))){
-                 if((TS_State.Y<80)){
-                     return BUTTON_0;
-                 }
-                else if((TS_State.Y >= 80) && (TS_State.Y<160)){
-                    return BUTTON_1;
-                }
-                else if((TS_State.Y >= 160)&& (TS_State.Y<240)){
-                    return BUTTON_2;
-                }
-                else if((TS_State.Y >= 240)&& (TS_State.Y<320)){
-                    return BUTTON_3; 
-                }               
-             }
-             return RELEASED;
-};
\ No newline at end of file

--- a/keyboard_ts.h	Wed May 20 07:59:22 2020 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-#ifndef KEYBOARD_TS_H
-#define KEYBOARD_TS_H
-#include "mbed.h"
-
-enum KeyboardState{
-    BUTTON_0,
-    BUTTON_1,
-    BUTTON_2,
-    BUTTON_3,
-    RELEASED
-};
-    
-class KeyboardTs{
-    public:
-        enum KeyboardState eRead();
-        KeyboardTs(uint8_t);
-    private:
-        uint8_t ui8Column;
-};
-
-
-#endif
\ No newline at end of file

--- a/keyboard_ts_lcd.cpp	Wed May 20 07:59:22 2020 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,27 +0,0 @@
-#include "keyboard_ts_lcd.h"
-
-KeyboardTsLcd::KeyboardTsLcd(uint8_t ui8Column) {
-        pKeyboard = new KeyboardTs(ui8Column);
-        pLed = new LedLcd(ui8Column);
-    };
-
-
-enum KeyboardState KeyboardTsLcd::eRead(){
-    switch(pKeyboard->eRead()){
-            case BUTTON_0:
-                pLed->On(0);
-                return BUTTON_0;
-            case BUTTON_1:
-                pLed->On(1);
-                return BUTTON_1;
-            case BUTTON_2:
-                pLed->On(2);
-                return BUTTON_2;
-            case BUTTON_3:
-                pLed->On(3);
-                return BUTTON_3;
-            default :
-                pLed->On(4);
-                return RELEASED;         
-         }   
-    };
\ No newline at end of file

--- a/keyboard_ts_lcd.h	Wed May 20 07:59:22 2020 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,18 +0,0 @@
-#ifndef KEYBOARD_TS_LCD_H
-#define KEYBOARD_TS_LCD_H
-#include "led_lcd.h"
-#include "keyboard_ts.h"
-
-class KeyboardTsLcd{
-    public:
-    KeyboardTsLcd(uint8_t ui8Column);
-    enum KeyboardState eRead(); 
-    
-    private:
-    KeyboardTs *pKeyboard;
-    LedLcd *pLed;
-    
-    };
-
-
-#endif

--- a/led_lcd.cpp	Wed May 20 07:59:22 2020 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,51 +0,0 @@
-#include "led_lcd.h"
-#include "mbed.h"
-#include "LCD_DISCO_F429ZI.h"
-
-LCD_DISCO_F429ZI lcd;
-
-LedLcd::LedLcd(uint8_t WhichColumn){
-    lcd.Clear(LCD_COLOR_BLACK);
-    ui8Column = ((WhichColumn > 1) && (WhichColumn <= 3)) ? WhichColumn: 1;
-      
-};
-
-void LedLcd::DrawLed(uint8_t ui8LedNumber, LedState eLedState){
-     char cBuffer[2];
-      
-     lcd.SetTextColor(LCD_COLOR_GREEN);
-     lcd.DrawRect(((ui8Column-1)*80),80*ui8LedNumber,80,80);
-     
-     if(eLedState == LED_PRESSED){
-          lcd.SetTextColor(LCD_COLOR_GREEN); 
-     }
-    else if(eLedState == LED_RELEASED){
-          lcd.SetTextColor(LCD_COLOR_BLUE); 
-    }
-    
-     lcd.FillRect(((ui8Column-1)*80)+2,80*ui8LedNumber+2,77,77);
-     
-     BSP_LCD_SetFont(&Font24);
-     lcd.SetBackColor(LCD_COLOR_RED);
-     sprintf(cBuffer,"%d",ui8LedNumber);
-     lcd.SetTextColor(LCD_COLOR_WHITE);   
-     lcd.DisplayStringAt(((ui8Column-1)*80)+1,80*ui8LedNumber+1,(uint8_t *)&cBuffer,LEFT_MODE);
-};     
-        
-/*void LedLcd::On(uint8_t ui8LedNumber){     
-    
-    for(uint8_t ui8LedCounter=0; ui8LedCounter<4; ui8LedCounter++){
-            if(ui8LedCounter == ui8LedNumber){ 
-                DrawLed(ui8LedCounter,LED_PRESSED);
-            }
-            else {
-                DrawLed(ui8LedCounter,LED_RELEASED);
-            }
-    }*/
-void LedLcd::On(uint8_t ui8LedNumber){ 
-
-     for(uint8_t ui8LedCounter = 0; ui8LedCounter <= 3; ui8LedCounter++){
-            DrawLed(ui8LedCounter, LED_RELEASED);
-     } 
-     DrawLed(ui8LedNumber,LED_PRESSED);                                                  
-};  

--- a/led_lcd.h	Wed May 20 07:59:22 2020 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,20 +0,0 @@
-#ifndef LED_LCD_H
-#define LED_LCD_H
-#include "LCD_DISCO_F429ZI.h"
-
-enum LedState {
-    LED_PRESSED,
-    LED_RELEASED
-    };
-
-
-class LedLcd{
-    public:
-        LedLcd(uint8_t);
-        void On(uint8_t);
-    private:
-        void DrawLed(uint8_t,LedState);
-        uint8_t ui8Column;
-    };
-    
-#endif
\ No newline at end of file

--- a/main.cpp	Wed May 20 07:59:22 2020 +0000
+++ b/main.cpp	Tue Jun 09 11:23:48 2020 +0000
@@ -1,30 +1,106 @@
 #include "mbed.h"
-#include "keyboard_ts_lcd.h"
+#include "command_decoder.h"
+#include "servo_gui.h"
+
+#define CR '\r'
+
+Serial MyUART(USBTX, USBRX,9600);
+ServoGui MyServoGui;
+CommandDecoder MyCommandDecoder;
 
-int main()
-{  
-    KeyboardTsLcd MyKeyboardTsLcd(1);
-    LedLcd MyLed(3);
+uint8_t puts(char *cBufferTransmit, unsigned char ucBufferSize){
+    unsigned char ucCharacterCounter;   
+    
+    for(ucCharacterCounter = 0; ucCharacterCounter <= ucBufferSize; ucCharacterCounter++){      
+        if(cBufferTransmit[ucBufferSize] == NULL){
+        break;
+        }
+    }       
+    if(ucCharacterCounter == ucBufferSize){
+        return 1;
+    }
+        
+    for(unsigned char ucCharacterCounter = 0; cBufferTransmit[ucCharacterCounter] != NULL; ucCharacterCounter++){
+        MyUART.putc(cBufferTransmit[ucCharacterCounter]); 
+    }                              
+    MyUART.putc(CR);           
+    return 0;     
+  } 
   
-    while(1){  
-       switch(MyKeyboardTsLcd.eRead()){
-           case BUTTON_0:
-                MyLed.On(3);
+uint8_t gets(char *cBufferReceived, unsigned char ucBufferSize){
+    unsigned char ucCharacterCounter = 0;
+    
+    while(ucCharacterCounter < ucBufferSize){
+        cBufferReceived[ucCharacterCounter] = MyUART.getc(); 
+        if(cBufferReceived[ucCharacterCounter] == CR){
+           cBufferReceived[ucCharacterCounter] = NULL; 
+           return 0;        
+        }
+        ucCharacterCounter++;
+    }    
+    return 1;
+} 
+
+void TokenHandling(){  
+    char cID[] = "id_0x777";
+    char cUnkownCommand[] = "unknowncommand";
+    char cOK[] = "ok";
+    
+    if((MyCommandDecoder.ucTokenNr>0) && (MyCommandDecoder.asToken[0].eType == KEYWORD)){
+       switch(MyCommandDecoder.asToken[0].uValue.eKeyword){
+            case ID:
+                puts(cID);
                 break;
-            case BUTTON_1:
-                MyLed.On(2);
-                break; 
-            case BUTTON_2:
-                MyLed.On(1);
-                break;    
-            case BUTTON_3:
-                MyLed.On(0);
+            case CALLIB:
+                MyServoGui.ServoCallib();
+                puts(cOK);
+                break;
+            case GOTO:
+                if(MyCommandDecoder.asToken[1].eType == NUMBER){
+                  MyServoGui.ServoGoTo(MyCommandDecoder.asToken[1].uValue.uiNumber);
+                  MyServoGui.sServo.uiPreviousPosition = MyCommandDecoder.asToken[1].uValue.uiNumber;   
+                  puts(cOK);                         
+                }
+                else{
+                   puts(cUnkownCommand);
+                }
                 break;   
+            case STEP:
+                if(MyCommandDecoder.asToken[1].eType == NUMBER){
+                  MyServoGui.ServoGoTo(MyServoGui.sServo.uiPreviousPosition + MyCommandDecoder.asToken[1].uValue.uiNumber);
+                  MyServoGui.sServo.uiPreviousPosition = MyServoGui.sServo.uiPreviousPosition + MyCommandDecoder.asToken[1].uValue.uiNumber; 
+                  puts(cOK); 
+                }
+                else{
+                 puts(cUnkownCommand);
+                }  
+                break;
             default:
-                MyLed.On(4);
-            break; 
+                puts(cUnkownCommand);
+                break;                                                                   
         }
-     wait(0.1); 
-     } 
+    }
+    else {
+        puts(cUnkownCommand,sizeof(cUnkownCommand));
+    }       
+}              
+
+int main(){    
+   char cUnkownCommand[] = "unkowncommand"; 
+   char cBufferReceived[10];
+
+    while(1){   
+          
+          if(gets(cBufferReceived,sizeof(cBufferReceived)) == 0){
+              MyCommandDecoder.DecodeMsg(cBufferReceived);
+              TokenHandling();
+              
+          }
+          else{
+              puts(cUnkownCommand,sizeof(cUnkownCommand));
+          } 
+                              
+    }     
 }
 
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/servo_gui.cpp	Tue Jun 09 11:23:48 2020 +0000
@@ -0,0 +1,97 @@
+#include "servo_gui.h"
+
+
+DigitalIn MyCallibButton(USER_BUTTON);
+
+ServoGui::ServoGui(){
+    lcd.Clear(LCD_COLOR_WHITE);
+    ui8ActualLedPoint = 0;
+    DrawDisk();
+    LedOn(0);
+    
+}
+
+enum eState ServoGui::eReadDetector(){
+    if(MyCallibButton == 1){
+        return ON;
+    }
+    else {
+        return OFF;
+    }    
+}    
+
+void ServoGui::ServoCallib(){
+    while(eReadDetector() == OFF){
+        LedStep(RIGHT);
+        wait(DELAY);    
+    }
+    sServo.uiCurrentPosition = ui8ActualLedPoint;
+    sServo.uiDesiredPosition = ui8ActualLedPoint;
+    
+}
+
+void ServoGui::ServoGoTo(uint8_t ui8Position){
+  sServo.uiDesiredPosition = ui8Position;
+  while(sServo.uiCurrentPosition != sServo.uiDesiredPosition){
+      if(sServo.uiCurrentPosition < sServo.uiDesiredPosition){
+            LedStep(LEFT);
+            sServo.uiCurrentPosition++;
+       }
+       else if(sServo.uiCurrentPosition > sServo.uiDesiredPosition){
+           LedStep(RIGHT);
+           sServo.uiCurrentPosition--;   
+       } 
+       wait(DELAY);  
+  }   
+}
+
+void ServoGui::DrawLed(uint8_t ui8LedNumber){
+    
+    if(ui8LedNumber <= 3){
+        lcd.SetTextColor(LCD_COLOR_BLACK);
+        lcd.DrawCircle(LED_X + LED_DISTANCE*ui8LedNumber,LED_Y,LED_RADIUS); 
+    }
+    if(eLedStates[ui8LedNumber] == ON){
+        lcd.SetTextColor(LCD_COLOR_BLUE);
+    }
+    else{
+        lcd.SetTextColor(LCD_COLOR_WHITE);
+    }
+    
+    lcd.FillCircle(LED_X+LED_DISTANCE*ui8LedNumber,LED_Y ,LED_RADIUS-2);
+}  
+
+
+void ServoGui::LedOn(uint8_t ui8LedNumber){
+      for(uint8_t ui8LedCounter = 0; ui8LedCounter <= 3; ui8LedCounter++){
+            eLedStates[ui8LedCounter] = OFF;
+            DrawLed(ui8LedCounter);
+      }
+          if(ui8LedNumber <= 3){
+            eLedStates[ui8LedNumber] = ON;
+            DrawLed(ui8LedNumber);
+          }    
+}  
+
+void ServoGui::LedStep(enum eDirection eWhere){
+    if(eWhere == RIGHT){
+        ui8ActualLedPoint = ui8ActualLedPoint + 1;
+    }
+    else if(eWhere == LEFT){
+        ui8ActualLedPoint = ui8ActualLedPoint - 1;
+    }
+    LedOn(ui8ActualLedPoint%4);
+    DrawDisk();   
+}
+
+void ServoGui::DrawDisk(){
+    double dAngleOfPointer = (ui8ActualLedPoint%MAX_STEPS);
+    dAngleOfPointer = dAngleOfPointer/ MAX_STEPS;
+    dAngleOfPointer = dAngleOfPointer * 2 * PI;
+    
+    lcd.SetTextColor(LCD_COLOR_BLACK);
+    lcd.FillCircle(DISK_X,DISK_Y,DISK_RADIUS);
+    lcd.SetTextColor(LCD_COLOR_WHITE);
+    lcd.DrawLine(DISK_X,DISK_Y,DISK_X+(DISK_RADIUS * cos(dAngleOfPointer)), DISK_Y + (DISK_RADIUS * sin(dAngleOfPointer)));
+    lcd.FillCircle(DISK_X,DISK_Y,SMALL_DISK_RADIUS);    
+}    
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/servo_gui.h	Tue Jun 09 11:23:48 2020 +0000
@@ -0,0 +1,48 @@
+#ifndef SERVO_GUI_H
+#define SERVO_GUI_H
+#include "LCD_DISCO_F429ZI.h"
+#include "mbed.h"
+
+#define DISK_X 120
+#define DISK_Y 120
+#define DISK_RADIUS 100
+#define SMALL_DISK_RADIUS 20
+#define MAX_STEPS 16
+#define PI 3.14159
+#define LED_X 30
+#define LED_Y 290
+#define LED_DISTANCE 60
+#define LED_RADIUS 20
+#define DELAY 0.25
+
+
+enum eState {ON,OFF};
+enum eDirection {LEFT,RIGHT};
+
+struct Servo {
+    unsigned int uiCurrentPosition;
+    unsigned int uiDesiredPosition;
+    unsigned int uiPreviousPosition;
+};
+
+class ServoGui{
+    public:
+        ServoGui();
+        void ServoCallib();
+        void ServoGoTo(uint8_t ui8Position);
+        struct Servo sServo;
+    private:
+        LCD_DISCO_F429ZI lcd;
+        uint8_t ui8ActualLedPoint;
+        void DrawDisk();
+        enum eState eLedStates[3];
+        void LedOn(uint8_t ui8LedNumber);
+        void DrawLed(uint8_t);
+        enum eState eReadDetector();
+        void LedStep(enum eDirection eWhere);      
+};     
+
+
+
+
+#endif