foc control for using hoverboard as as hoverboard no mods

.gitignore

@@ -1,2 +1,5 @@
-build/*
 !build/hover.hex
+.pio/
+.pioenvs/
+.vscode/
+01_Matlab/slprj/

.travis.yml

@@ -0,0 +1,55 @@
+notifications:
+  email: true
+
+sudo: false
+
+matrix:
+  fast_finish: true
+  include:
+
+    - name: make (gcc-arm-none-eabi-7)
+      script: make
+      language: c
+      addons:
+        apt:
+          packages:
+          - libc6-i386
+      install:
+      - pushd .
+      - cd ~
+      - mkdir arm-gcc-toolchain
+      - wget -O $HOME/arm-gcc-toolchain/gcc.tar.bz2 https://developer.arm.com/-/media/Files/downloads/gnu-rm/7-2018q2/gcc-arm-none-eabi-7-2018-q2-update-linux.tar.bz2?revision=bc2c96c0-14b5-4bb4-9f18-bceb4050fee7?product=GNU%20Arm%20Embedded%20Toolchain,64-bit,,Linux,7-2018-q2-update
+      - cd arm-gcc-toolchain
+      - tar -jxf gcc.tar.bz2 --strip=1
+      - popd
+      - export PATH=$HOME/arm-gcc-toolchain/bin:$PATH
+      before_script: arm-none-eabi-gcc --version
+
+    - name: make (gcc-arm-none-eabi-5)
+      script: make
+      language: c
+      addons:
+        apt:
+          packages:
+          - libc6-i386
+      install:
+      - pushd .
+      - cd ~
+      - mkdir arm-gcc-toolchain
+      - wget -O $HOME/arm-gcc-toolchain/gcc.tar.bz2 https://developer.arm.com/-/media/Files/downloads/gnu-rm/5_4-2016q3/gcc-arm-none-eabi-5_4-2016q3-20160926-linux.tar.bz2?revision=111dee36-f88b-4672-8ac6-48cf41b4d375?product=GNU%20Arm%20Embedded%20Toolchain,32-bit,,Linux,5-2016-q3-update
+      - cd arm-gcc-toolchain
+      - tar -jxf gcc.tar.bz2 --strip=1
+      - popd
+      - export PATH=$HOME/arm-gcc-toolchain/bin:$PATH
+      before_script: arm-none-eabi-gcc --version
+
+    - name: pio genericSTM32F103RC
+      script: platformio run -e genericSTM32F103RC
+      language: python
+      python:
+        - "2.7"
+      install:
+      - pip install -U platformio
+      - platformio update
+      cache:
+      - directories: "~/.platformio"

01_Matlab/99_RecycleBin/bldc_motor_derating.c

@@ -0,0 +1,258 @@
+/*
+* This file has been re-implemented with 4 new selectable motor control methods.
+* Recommended control method: 3 = Sinusoidal 3rd order. This control method offers superior performanace
+* compared to previous method. The new method features:
+* ► reduced noise and vibrations
+* ► smooth torque output
+* ► improved motor efficiency -> lower energy consumption
+*
+* Copyright (C) 2019 Emanuel FERU <[email protected]>
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "stm32f1xx_hal.h"
+#include "defines.h"
+#include "setup.h"
+#include "config.h"
+
+// Matlab includes and defines - from auto-code generation
+// ###############################################################################
+#include "BLDC_controller.h"           /* Model's header file */
+#include "rtwtypes.h"
+
+extern RT_MODEL *const rtM_Left;
+extern RT_MODEL *const rtM_Right;
+
+extern DW rtDW_Left;                    /* Observable states */
+extern ExtU rtU_Left;                   /* External inputs */
+extern ExtY rtY_Left;                   /* External outputs */
+
+extern DW rtDW_Right;                   /* Observable states */
+extern ExtU rtU_Right;                  /* External inputs */
+extern ExtY rtY_Right;                  /* External outputs */
+// ###############################################################################
+
+
+volatile int pwml = 0;
+volatile int pwmr = 0;
+
+int pwm_limiter = 1024;
+
+extern volatile adc_buf_t adc_buffer;
+
+extern volatile uint32_t timeout;
+
+uint8_t buzzerFreq          = 0;
+uint8_t buzzerPattern       = 0;
+static uint32_t buzzerTimer = 0;
+
+uint8_t enable              = 0;
+
+static const uint16_t pwm_res   = 64000000 / 2 / PWM_FREQ;      // = 2000
+static float          pwml_lim  = 0;
+static float          curl_filt = 0;
+float CUR;
+
+static int offsetcount = 0;
+static int offsetrl1   = 2000;
+static int offsetrl2   = 2000;
+static int offsetrr1   = 2000;
+static int offsetrr2   = 2000;
+static int offsetdcl   = 2000;
+static int offsetdcr   = 2000;
+
+float batteryVoltage = BAT_NUMBER_OF_CELLS * 4.0;
+
+//scan 8 channels with 2ADCs @ 20 clk cycles per sample
+//meaning ~80 ADC clock cycles @ 8MHz until new DMA interrupt =~ 100KHz
+//=640 cpu cycles
+void DMA1_Channel1_IRQHandler(void) {
+
+  DMA1->IFCR = DMA_IFCR_CTCIF1;
+  // HAL_GPIO_WritePin(LED_PORT, LED_PIN, 1);
+  // HAL_GPIO_TogglePin(LED_PORT, LED_PIN);
+
+  if(offsetcount < 1000) {  // calibrate ADC offsets
+    offsetcount++;
+    offsetrl1 = (adc_buffer.rl1 + offsetrl1) / 2;
+    offsetrl2 = (adc_buffer.rl2 + offsetrl2) / 2;
+    offsetrr1 = (adc_buffer.rr1 + offsetrr1) / 2;
+    offsetrr2 = (adc_buffer.rr2 + offsetrr2) / 2;
+    offsetdcl = (adc_buffer.dcl + offsetdcl) / 2;
+    offsetdcr = (adc_buffer.dcr + offsetdcr) / 2;
+    return;
+  }
+
+  if (buzzerTimer % 1000 == 0) {  // because you get float rounding errors if it would run every time
+    batteryVoltage = batteryVoltage * 0.99f + ((float)adc_buffer.batt1 * ((float)BAT_CALIB_REAL_VOLTAGE / (float)BAT_CALIB_ADC)) * 0.01f;
+  }
+
+  //   //disable PWM when current limit is reached (current chopping)
+  // if(ABS((adc_buffer.dcl - offsetdcl) * MOTOR_AMP_CONV_DC_AMP) > DC_CUR_LIMIT || timeout > TIMEOUT || enable == 0) {
+  //   LEFT_TIM->BDTR &= ~TIM_BDTR_MOE;
+  //   //HAL_GPIO_WritePin(LED_PORT, LED_PIN, 1);
+  // } else {
+  //   LEFT_TIM->BDTR |= TIM_BDTR_MOE;
+  //   //HAL_GPIO_WritePin(LED_PORT, LED_PIN, 0);
+  // }
+
+  // if(ABS((adc_buffer.dcr - offsetdcr) * MOTOR_AMP_CONV_DC_AMP)  > DC_CUR_LIMIT || timeout > TIMEOUT || enable == 0) {
+  //   RIGHT_TIM->BDTR &= ~TIM_BDTR_MOE;
+  // } else {
+  //   RIGHT_TIM->BDTR |= TIM_BDTR_MOE;
+  // }
+
+  //disable PWM when current limit is reached (current chopping)
+  if(timeout > TIMEOUT || enable == 0) {
+    LEFT_TIM->BDTR &= ~TIM_BDTR_MOE;
+    //HAL_GPIO_WritePin(LED_PORT, LED_PIN, 1);
+  } else {
+    LEFT_TIM->BDTR |= TIM_BDTR_MOE;
+    //HAL_GPIO_WritePin(LED_PORT, LED_PIN, 0);
+  }
+
+  if(timeout > TIMEOUT || enable == 0) {
+    RIGHT_TIM->BDTR &= ~TIM_BDTR_MOE;
+  } else {
+    RIGHT_TIM->BDTR |= TIM_BDTR_MOE;
+  }
+
+  // pwml_lim  = pwml_lim + 0.001f * (ABS((adc_buffer.dcr - offsetdcr) * MOTOR_AMP_CONV_DC_AMP) - DC_CUR_LIMIT);
+  // pwml_lim  = CLAMP(pwml_lim, 0, ABS(pwmr));
+  // pwmr      = (int) (pwmr - SIGN(pwmr) * pwml_lim);
+
+  // if (ABS((adc_buffer.dcl - offsetdcl) * MOTOR_AMP_CONV_DC_AMP) > DC_CUR_LIMIT)
+  //     pwml_lim  = pwml_lim + 0.00001f;
+  // else
+  //     pwml_lim  = pwml_lim - 0.00001f; (pwml_lim * (1.0f - FILTER) + cmd2 * FILTER)
+
+  float CUR_FILTER = 0.1f; // 0.00001f;
+  curl_filt = ((100.0f - CUR_FILTER) * curl_filt + CUR_FILTER * ABS((adc_buffer.dcl - offsetdcl) * MOTOR_AMP_CONV_DC_AMP)) / 100;
+  // curl_filt = ABS((adc_buffer.dcl - offsetdcl) * MOTOR_AMP_CONV_DC_AMP);
+  // pwml_lim  = pwml_lim + 1 * (curl_filt - DC_CUR_LIMIT);
+  pwml_lim  = 2 * (curl_filt - DC_CUR_LIMIT);
+  pwml_lim  = CLAMP(pwml_lim, 0, ABS(pwml));
+  pwml      = (int) (pwml - SIGN(pwml) * pwml_lim);
+
+  // if(curl_filt > DC_CUR_LIMIT) {
+  //   pwml_lim+=0.1f;
+  //   HAL_GPIO_WritePin(LED_PORT, LED_PIN, 1);    // Derating active
+  // } else {
+  //   pwml_lim-=0.1f;
+  //   HAL_GPIO_WritePin(LED_PORT, LED_PIN, 0);    // Derating deactive
+  // }
+  // pwml_lim  = CLAMP(pwml_lim/1000, 0, ABS(pwml));
+  // pwml      = (int) (pwml - SIGN(pwml) * pwml_lim);
+
+
+  // DC_CUR = MAX(ABS((adc_buffer.dcl - offsetdcl) * MOTOR_AMP_CONV_DC_AMP), ABS((adc_buffer.dcr - offsetdcr) * MOTOR_AMP_CONV_DC_AMP));
+
+//  CUR = curl_filt;
+ CUR = (adc_buffer.rl1 - offsetrl1) * MOTOR_AMP_CONV_DC_AMP;
+  // if(ABS((adc_buffer.dcl - offsetdcl) * MOTOR_AMP_CONV_DC_AMP) > DC_CUR_LIMIT) {
+  //   pwm_limiter--;
+  //   HAL_GPIO_WritePin(LED_PORT, LED_PIN, 1);    // Derating active
+  // } else {
+  //   pwm_limiter++;
+  //   HAL_GPIO_WritePin(LED_PORT, LED_PIN, 0);    // Derating deactive
+  // }
+  // pwm_limiter = CLAMP(pwm_limiter, 0, 1024);
+  // pwml    = (pwm_limiter*pwml) >> 10;
+  // pwmr    = CLAMP(pwmr, -pwm_lim, pwm_lim);
+
+  //create square wave for buzzer
+  buzzerTimer++;
+  if (buzzerFreq != 0 && (buzzerTimer / 5000) % (buzzerPattern + 1) == 0) {
+    if (buzzerTimer % buzzerFreq == 0) {
+      HAL_GPIO_TogglePin(BUZZER_PORT, BUZZER_PIN);
+    }
+  } else {
+      HAL_GPIO_WritePin(BUZZER_PORT, BUZZER_PIN, 0);
+  }
+
+  // ############################### MOTOR CONTROL ###############################
+
+  static boolean_T OverrunFlag = false;
+  /* Check for overrun */
+  if (OverrunFlag) {
+    return;
+  }
+  OverrunFlag = true;
+
+  int ul, vl, wl;
+  int ur, vr, wr;
+  // ========================= LEFT MOTOR ============================ 
+    // Get hall sensors values
+    uint8_t hall_ul = !(LEFT_HALL_U_PORT->IDR & LEFT_HALL_U_PIN);
+    uint8_t hall_vl = !(LEFT_HALL_V_PORT->IDR & LEFT_HALL_V_PIN);
+    uint8_t hall_wl = !(LEFT_HALL_W_PORT->IDR & LEFT_HALL_W_PIN);
+
+    /* Set motor inputs here */
+    rtU_Left.b_hallA   = hall_ul;
+    rtU_Left.b_hallB   = hall_vl;
+    rtU_Left.b_hallC   = hall_wl;
+    rtU_Left.r_DC      = pwml;
+
+    /* Step the controller */
+    BLDC_controller_step(rtM_Left);
+
+    /* Get motor outputs here */
+    ul            = rtY_Left.DC_phaA;
+    vl            = rtY_Left.DC_phaB;
+    wl            = rtY_Left.DC_phaC;
+  // motSpeedLeft = rtY_Left.n_mot;
+  // motAngleLeft = rtY_Left.a_elecAngle;
+
+    /* Apply commands */
+    LEFT_TIM->LEFT_TIM_U    = (uint16_t)CLAMP(ul + pwm_res / 2, 10, pwm_res-10);
+    LEFT_TIM->LEFT_TIM_V    = (uint16_t)CLAMP(vl + pwm_res / 2, 10, pwm_res-10);
+    LEFT_TIM->LEFT_TIM_W    = (uint16_t)CLAMP(wl + pwm_res / 2, 10, pwm_res-10);
+  // =================================================================
+
+
+  // ========================= RIGHT MOTOR ===========================  
+    // Get hall sensors values
+    uint8_t hall_ur = !(RIGHT_HALL_U_PORT->IDR & RIGHT_HALL_U_PIN);
+    uint8_t hall_vr = !(RIGHT_HALL_V_PORT->IDR & RIGHT_HALL_V_PIN);
+    uint8_t hall_wr = !(RIGHT_HALL_W_PORT->IDR & RIGHT_HALL_W_PIN);
+
+    /* Set motor inputs here */
+    rtU_Right.b_hallA  = hall_ur;
+    rtU_Right.b_hallB  = hall_vr;
+    rtU_Right.b_hallC  = hall_wr;
+    rtU_Right.r_DC     = pwmr;
+
+    /* Step the controller */
+    BLDC_controller_step(rtM_Right);
+
+    /* Get motor outputs here */
+    ur            = rtY_Right.DC_phaA;
+    vr            = rtY_Right.DC_phaB;
+    wr            = rtY_Right.DC_phaC;
+ // motSpeedRight = rtY_Right.n_mot;
+ // motAngleRight = rtY_Right.a_elecAngle;
+
+    /* Apply commands */
+    RIGHT_TIM->RIGHT_TIM_U  = (uint16_t)CLAMP(ur + pwm_res / 2, 10, pwm_res-10);
+    RIGHT_TIM->RIGHT_TIM_V  = (uint16_t)CLAMP(vr + pwm_res / 2, 10, pwm_res-10);
+    RIGHT_TIM->RIGHT_TIM_W  = (uint16_t)CLAMP(wr + pwm_res / 2, 10, pwm_res-10);
+  // =================================================================
+
+  /* Indicate task complete */
+  OverrunFlag = false;
+
+ // ###############################################################################
+
+}