sine wave approximation memory shrinking

Author: askuric

README.md

@@ -28,7 +28,7 @@ For minimal version of the code more suitable for experimenting please visit the
  # Structure
 - [Installation](#arduino-simple-foc-instalation)
   - [Installing the full Arduino Simple FOC library](#installing-simple-foc-full-library)
-  - [Installing the minimal Arduino example](#download-minimal-simple-foc-arduino-example)
+  - [Installing the minimal Arduino example](#download-simple-foc-arduino-minimal-example)
 - [Electrical connecitons and schematic](#electrical-connections)
   - [Minimal setup](#all-you-need-for-this-project-is-an-exaple-in-brackets)
   - [Arduino Simple FOC Shield V1.2](#arduino-simple-foc-shield-v12)
@@ -57,15 +57,15 @@ The simplest way to get hold of the library is direclty by using Arduino IDE and
 ### Download library directly
 If you don't want to use the Arduino IDE and Library manager you can direclty download the library from this website. 
 - Simplest way to do it is to download the `zip` aerchieve directly on the top of this webiste. Click first on `Clone or Download` and then on `Download ZIP`. Once you have the zip ardhieve downloaded, unzip it and place it in your Arduino Libraries forlder. On Windows it is usually in `Documents > Arduino > libraries`.  
-  - Now reopen your Arduino IDE and you should have the library examples in `File > Examples > Simple FOC`.
+  Now reopen your Arduino IDE and you should have the library examples in `File > Examples > Simple FOC`.
 
 - If you are more experienced with the terminal you can open your terminal in the Arduino libraries folder direclty and clone the Arduino FOC git repsitory:
-```bash
-git clone https://github.com/askuric/Arduino-FOC.git
-```
-  - Now reopen your Arduino IDE and you should have the library examples in `File > Examples > Simple FOC`.
+  ```bash
+  git clone https://github.com/askuric/Arduino-FOC.git
+  ```
+  Now reopen your Arduino IDE and you should have the library examples in `File > Examples > Simple FOC`.
 
-## Download minimal Simple FOC Arduino example
+## Download Simple FOC Arduino minimal example
 To download the minmial verison of Simple FOC intended for those willing to experiment and extend the code I suggest using this version over the full library. 
 This code is completely indepenedet and you can run it as any other Arduino Schetch without the need for any libraries. 
 The code is place in the [minimal branch](https://github.com/askuric/Arduino-FOC/tree/minimal). 
@@ -691,6 +691,7 @@ before running `motor.init()`.
 - [x] Add support for acceleration ramping
 - [x] Timer interrupt execution rather than in the `loop()`
   - FAIL: Perfromance not improved
+- [x] Sine wave lookup table implementation
 
 # Contact
 Please do not hesitate to leave an issue or contact me direclty by email.

examples/find_pole_pairs_number/find_pole_pairs_number.ino

@@ -43,37 +43,48 @@ void setup() {
   motor.init();
 
 
+
   // pole pairs calculation routine
   Serial.println("Motor pole pair number estimation example");
   Serial.println("---------------------------------------------\n");
 
-  float pp_search_voltage = 3; // maximum power_supply_voltage/2
-
+  float pp_search_voltage = 4; // maximum power_supply_voltage/2
+  float pp_search_angle = 6*M_PI; // search electrical angle to turn
+  
   // move motor to the electrical angle 0
   motor.setPhaseVoltage(pp_search_voltage,0);
   _delay(1000);
   // read the encoder angle 
-  float angle0 = encoder.getAngle();
+  float angle_begin = encoder.getAngle();
   _delay(50);
- 
-  // move the motor slowly to the electrical angle 360 -> 2*pi radians
-  for(int i =0; i<2000; i++){
-    motor.setPhaseVoltage(pp_search_voltage, 2*M_PI/2000 * i);
+  
+  // move the motor slowly to the electrical angle pp_search_angle
+  float motor_angle = 0;
+  while(motor_angle <= pp_search_angle){
+    motor_angle += 0.01;
+    motor.setPhaseVoltage(pp_search_voltage, motor_angle);
   }
   _delay(1000);
   // read the encoder value for 180
-  float angle360 = encoder.getAngle();
+  float angle_end = encoder.getAngle();
   _delay(50);
   // turn off the motor
   motor.setPhaseVoltage(0,0);
   _delay(1000);
 
   // caluclate the pole pair number
-  int pp = round((2*M_PI)/(angle360-angle0));
+  int pp = round((pp_search_angle)/(angle_end-angle_begin));
 
   Serial.print("Estimated pole pairs number is: ");
   Serial.println(pp);
-  Serial.println("");
+  Serial.println("Electrical angle / Encoder angle = Pole pairs ");
+  Serial.print(pp_search_angle*180/M_PI);
+  Serial.print("/");
+  Serial.print((angle_end-angle_begin)*180/M_PI);
+  Serial.print(" = ");
+  Serial.println((pp_search_angle)/(angle_end-angle_begin));
+  Serial.println();
+   
 
   // a bit of debugging the result
   if(pp <= 0 ){

keywords.txt

@@ -29,6 +29,7 @@ handleB	KEYWIORD2
 handleIndex	KEYWIORD2
 ISR	KEYWIORD2
 getVelocity	KEYWIORD2
+setPhaseVoltage	KEYWIORD2
 getAngle	KEYWIORD2
 setCounterZero	KEYWIORD2
 useDebugging	KEYWIORD2
@@ -43,7 +44,6 @@ driver	KEYWIORD2
 pullup	KEYWIORD2
 quadrature	KEYWIORD2
 
-index_search_u_limit	KEYWIORD2
 index_search_velocity	KEYWIORD2
 
 

src/BLDCMotor.cpp

@@ -266,16 +266,16 @@ void BLDCMotor::move(float target) {
 /*
   Method using FOC to set Uq to the motor at the optimal angle
 */
-void BLDCMotor::setPhaseVoltage(double Uq, double angle_el) {
+void BLDCMotor::setPhaseVoltage(float Uq, float angle_el) {
 
   // angle normalisation in between 0 and 2pi
   // only necessary if using _sin and _cos - approximation funcitons
   float angle = normalizeAngle(angle_el + index_electric_angle);
   // Inverse park transform
-  // regular sin + cos ~300us
-  // approx  _sin + _cos ~90us 
-  Ualpha =  -_sin(angle) * Uq;
-  Ubeta =  _cos(angle) * Uq;
+  // regular sin + cos ~300us    (no memeory usaage)
+  // approx  _sin + _cos ~110us  (400Byte ~ 20% of memory)
+  Ualpha =  -_sin(angle) * Uq;  // -sin(angle) * Uq;
+  Ubeta =  _cos(angle) * Uq;    //  cos(angle) * Uq;
 
   // Clarke transform
   Ua = Ualpha;
@@ -315,8 +315,8 @@ void BLDCMotor::setPwm(int pinPwm, float U) {
 /*
 	normalizing radian angle to [0,2PI]
 */
-double BLDCMotor::normalizeAngle(double angle){
-  double a = fmod(angle, _2PI);
+float BLDCMotor::normalizeAngle(float angle){
+  float a = fmod(angle, _2PI);
   return a >= 0 ? a : (a + _2PI);
 }
 

src/BLDCMotor.h

@@ -123,7 +123,7 @@ class BLDCMotor
 
     /** FOC methods */
     //Method using FOC to set Uq to the motor at the optimal angle
-    void setPhaseVoltage(double Uq, double angle_el);
+    void setPhaseVoltage(float Uq, float angle_el);
 
 
     // debugging 
@@ -142,7 +142,7 @@ class BLDCMotor
 
     /** Utility funcitons */
     //normalizing radian angle to [0,2PI]
-    double normalizeAngle(double angle);
+    float normalizeAngle(float angle);
     //Reference low pass filter 
     float filterLP(float u);
 

src/Encoder.cpp

@@ -219,7 +219,7 @@ void Encoder::init(void (*doA)(), void(*doB)()){
   }
 
   // if index used intialise the index interrupt
-  if(hasIndex()) {
+  if(hasIndex() || doA != nullptr) {
     *digitalPinToPCMSK(index_pin) |= bit (digitalPinToPCMSKbit(index_pin));  // enable pin
     PCIFR  |= bit (digitalPinToPCICRbit(index_pin)); // clear any outstanding interrupt
     PCICR  |= bit (digitalPinToPCICRbit(index_pin)); // enable interrupt for the group

src/FOCutils.cpp

@@ -40,30 +40,41 @@ unsigned long _micros(){
 
 
 // lookup table for sine calculation in between 0 and 90 degrees
-float sine_array[200] = {0.0000,0.0079,0.0158,0.0237,0.0316,0.0395,0.0473,0.0552,0.0631,0.0710,0.0789,0.0867,0.0946,0.1024,0.1103,0.1181,0.1260,0.1338,0.1416,0.1494,0.1572,0.1650,0.1728,0.1806,0.1883,0.1961,0.2038,0.2115,0.2192,0.2269,0.2346,0.2423,0.2499,0.2575,0.2652,0.2728,0.2804,0.2879,0.2955,0.3030,0.3105,0.3180,0.3255,0.3329,0.3404,0.3478,0.3552,0.3625,0.3699,0.3772,0.3845,0.3918,0.3990,0.4063,0.4135,0.4206,0.4278,0.4349,0.4420,0.4491,0.4561,0.4631,0.4701,0.4770,0.4840,0.4909,0.4977,0.5046,0.5113,0.5181,0.5249,0.5316,0.5382,0.5449,0.5515,0.5580,0.5646,0.5711,0.5775,0.5839,0.5903,0.5967,0.6030,0.6093,0.6155,0.6217,0.6279,0.6340,0.6401,0.6461,0.6521,0.6581,0.6640,0.6699,0.6758,0.6815,0.6873,0.6930,0.6987,0.7043,0.7099,0.7154,0.7209,0.7264,0.7318,0.7371,0.7424,0.7477,0.7529,0.7581,0.7632,0.7683,0.7733,0.7783,0.7832,0.7881,0.7930,0.7977,0.8025,0.8072,0.8118,0.8164,0.8209,0.8254,0.8298,0.8342,0.8385,0.8428,0.8470,0.8512,0.8553,0.8594,0.8634,0.8673,0.8712,0.8751,0.8789,0.8826,0.8863,0.8899,0.8935,0.8970,0.9005,0.9039,0.9072,0.9105,0.9138,0.9169,0.9201,0.9231,0.9261,0.9291,0.9320,0.9348,0.9376,0.9403,0.9429,0.9455,0.9481,0.9506,0.9530,0.9554,0.9577,0.9599,0.9621,0.9642,0.9663,0.9683,0.9702,0.9721,0.9739,0.9757,0.9774,0.9790,0.9806,0.9821,0.9836,0.9850,0.9863,0.9876,0.9888,0.9899,0.9910,0.9920,0.9930,0.9939,0.9947,0.9955,0.9962,0.9969,0.9975,0.9980,0.9985,0.9989,0.9992,0.9995,0.9997,0.9999,1.0000,1.0000};
+//float sine_array[200] = {0.0000,0.0079,0.0158,0.0237,0.0316,0.0395,0.0473,0.0552,0.0631,0.0710,0.0789,0.0867,0.0946,0.1024,0.1103,0.1181,0.1260,0.1338,0.1416,0.1494,0.1572,0.1650,0.1728,0.1806,0.1883,0.1961,0.2038,0.2115,0.2192,0.2269,0.2346,0.2423,0.2499,0.2575,0.2652,0.2728,0.2804,0.2879,0.2955,0.3030,0.3105,0.3180,0.3255,0.3329,0.3404,0.3478,0.3552,0.3625,0.3699,0.3772,0.3845,0.3918,0.3990,0.4063,0.4135,0.4206,0.4278,0.4349,0.4420,0.4491,0.4561,0.4631,0.4701,0.4770,0.4840,0.4909,0.4977,0.5046,0.5113,0.5181,0.5249,0.5316,0.5382,0.5449,0.5515,0.5580,0.5646,0.5711,0.5775,0.5839,0.5903,0.5967,0.6030,0.6093,0.6155,0.6217,0.6279,0.6340,0.6401,0.6461,0.6521,0.6581,0.6640,0.6699,0.6758,0.6815,0.6873,0.6930,0.6987,0.7043,0.7099,0.7154,0.7209,0.7264,0.7318,0.7371,0.7424,0.7477,0.7529,0.7581,0.7632,0.7683,0.7733,0.7783,0.7832,0.7881,0.7930,0.7977,0.8025,0.8072,0.8118,0.8164,0.8209,0.8254,0.8298,0.8342,0.8385,0.8428,0.8470,0.8512,0.8553,0.8594,0.8634,0.8673,0.8712,0.8751,0.8789,0.8826,0.8863,0.8899,0.8935,0.8970,0.9005,0.9039,0.9072,0.9105,0.9138,0.9169,0.9201,0.9231,0.9261,0.9291,0.9320,0.9348,0.9376,0.9403,0.9429,0.9455,0.9481,0.9506,0.9530,0.9554,0.9577,0.9599,0.9621,0.9642,0.9663,0.9683,0.9702,0.9721,0.9739,0.9757,0.9774,0.9790,0.9806,0.9821,0.9836,0.9850,0.9863,0.9876,0.9888,0.9899,0.9910,0.9920,0.9930,0.9939,0.9947,0.9955,0.9962,0.9969,0.9975,0.9980,0.9985,0.9989,0.9992,0.9995,0.9997,0.9999,1.0000,1.0000};
+
+// int array instead of float array 
+// 2x storage save (int 2Byte float 4 Byte )
+// sin*10000
+int sine_array[200] = {0,79,158,237,316,395,473,552,631,710,789,867,946,1024,1103,1181,1260,1338,1416,1494,1572,1650,1728,1806,1883,1961,2038,2115,2192,2269,2346,2423,2499,2575,2652,2728,2804,2879,2955,3030,3105,3180,3255,3329,3404,3478,3552,3625,3699,3772,3845,3918,3990,4063,4135,4206,4278,4349,4420,4491,4561,4631,4701,4770,4840,4909,4977,5046,5113,5181,5249,5316,5382,5449,5515,5580,5646,5711,5775,5839,5903,5967,6030,6093,6155,6217,6279,6340,6401,6461,6521,6581,6640,6699,6758,6815,6873,6930,6987,7043,7099,7154,7209,7264,7318,7371,7424,7477,7529,7581,7632,7683,7733,7783,7832,7881,7930,7977,8025,8072,8118,8164,8209,8254,8298,8342,8385,8428,8470,8512,8553,8594,8634,8673,8712,8751,8789,8826,8863,8899,8935,8970,9005,9039,9072,9105,9138,9169,9201,9231,9261,9291,9320,9348,9376,9403,9429,9455,9481,9506,9530,9554,9577,9599,9621,9642,9663,9683,9702,9721,9739,9757,9774,9790,9806,9821,9836,9850,9863,9876,9888,9899,9910,9920,9930,9939,9947,9955,9962,9969,9975,9980,9985,9989,9992,9995,9997,9999,10000,10000};
 
 // function approximating the sine calculation by using fixed size array
-// ~40us
+// ~40us (float array)
+// ~50us (int array)
 // precision +-0.005
 // it has to receive an angle in between 0 and 2PI
 float _sin(float a){
   if(a < _PI_2){
     //return sine_array[(int)(199.0*( a / (M_PI/2.0)))];
-    return sine_array[(int)(126.6873* a)];
+    //return sine_array[(int)(126.6873* a)];           // float array optimised
+    return 0.0001*sine_array[(int)(126.6873* a)];      // int array optimised
   }else if(a < M_PI){
     // return sine_array[(int)(199.0*(1.0 - (a-M_PI/2.0) / (M_PI/2.0)))];
-    return sine_array[398 - (int)(126.6873*a)];
+    //return sine_array[398 - (int)(126.6873*a)];          // float array optimised
+    return 0.0001*sine_array[398 - (int)(126.6873*a)];     // int array optimised
   }else if(a < _3PI_2){
     // return -sine_array[(int)(199.0*((a - M_PI) / (M_PI/2.0)))];
-    return -sine_array[-398 + (int)(126.6873*a)];
+    //return -sine_array[-398 + (int)(126.6873*a)];           // float array optimised
+    return -0.0001*sine_array[-398 + (int)(126.6873*a)];      // int array optimised
   } else {
     // return -sine_array[(int)(199.0*(1.0 - (a - 3*M_PI/2) / (M_PI/2.0)))];
-    return -sine_array[796 - (int)(126.6873*a)];
+    //return -sine_array[796 - (int)(126.6873*a)];           // float array optimised
+    return -0.0001*sine_array[796 - (int)(126.6873*a)];      // int array optimised
   }
 }
 
 // function approfimating cosine calculaiton by using fixed size array
-// ~50us
+// ~55us (float array)
+// ~56us (int array)
 // precision +-0.005
 // it has to receive an angle in between 0 and 2PI
 float _cos(float a){