├── .gitattributes
├── Drivers
    ├── CMSIS
    │   ├── Device
    │   │   └── ST
    │   │   │   └── STM32H7xx
    │   │   │       └── Include
    │   │   │           ├── stm32h7xx.h
    │   │   │           └── system_stm32h7xx.h
    │   └── Include
    │   │   ├── cmsis_version.h
    │   │   └── tz_context.h
    └── STM32H7xx_HAL_Driver
    │   ├── Inc
    │       ├── stm32h7xx_hal_spi_ex.h
    │       ├── stm32h7xx_hal_def.h
    │       └── stm32h7xx_hal_hsem.h
    │   └── Src
    │       └── stm32h7xx_hal_spi_ex.c
├── .settings
    ├── stm32cubeide.project.prefs
    ├── org.eclipse.cdt.core.prefs
    └── language.settings.xml
├── .gitignore
├── Core
    ├── Src
    │   ├── common
    │   │   ├── time_utils.cpp
    │   │   ├── time_utils.h
    │   │   ├── lowpass_filter.cpp
    │   │   ├── lowpass_filter.hpp
    │   │   ├── base_classes
    │   │   │   ├── Sensor.cpp
    │   │   │   ├── Sensor.hpp
    │   │   │   ├── BLDCDriver.hpp
    │   │   │   ├── CurrentSense.cpp
    │   │   │   ├── CurrentSense.hpp
    │   │   │   └── FOCMotor.cpp
    │   │   ├── pid.hpp
    │   │   ├── defaults.h
    │   │   ├── foc_utils.h
    │   │   ├── pid.cpp
    │   │   └── foc_utils.cpp
    │   ├── current_sense
    │   │   ├── hardware_api.h
    │   │   ├── hardware_api.cpp
    │   │   ├── InlineCurrentSense.hpp
    │   │   └── InlineCurrentSense.cpp
    │   ├── SimpleFOC.hpp
    │   ├── motor_drivers
    │   │   ├── BLDCDriver3PWM.hpp
    │   │   └── BLDCDriver3PWM.cpp
    │   ├── stm32h7xx_hal_msp.c
    │   ├── sensors
    │   │   ├── MagneticSensorSPI.hpp
    │   │   ├── MagneticSensorSPI.cpp
    │   │   ├── Encoder.hpp
    │   │   └── Encoder.cpp
    │   ├── sysmem.c
    │   ├── syscalls.c
    │   ├── BLDCMotor.hpp
    │   ├── spi.c
    │   ├── gpio.c
    │   ├── adc.c
    │   ├── tim.c
    │   └── stm32h7xx_it.c
    └── Inc
    │   ├── gpio.h
    │   ├── spi.h
    │   ├── adc.h
    │   ├── tim.h
    │   ├── stm32h7xx_it.h
    │   └── main.h
├── LICENSE
├── STM32_SimpleFOC_InlineCurrentSense.cfg
├── .project
├── STM32CubeIDE
    ├── Application
    │   └── User
    │   │   └── Core
    │   │       ├── sysmem.c
    │   │       └── syscalls.c
    ├── STM32H743ZITX_FLASH.ld
    ├── STM32H743ZITX_RAM.ld
    └── .project
├── README.md
├── Notes
├── STM32H743ZITX_RAM.ld
├── STM32H743ZITX_FLASH.ld
└── STM32_SimpleFOC_InlineCurrentSense.launch


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/Drivers/CMSIS/Device/ST/STM32H7xx/Include/stm32h7xx.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ngalin/STM32_SimpleFOC_InlineCurrentSense/HEAD/Drivers/CMSIS/Device/ST/STM32H7xx/Include/stm32h7xx.h


--------------------------------------------------------------------------------
/.settings/stm32cubeide.project.prefs:
--------------------------------------------------------------------------------
1 | 2F62501ED4689FB349E356AB974DBE57=05488FB562B314415892C0E29C0AD2A7
2 | 8DF89ED150041C4CBC7CB9A9CAA90856=05488FB562B314415892C0E29C0AD2A7
3 | DC22A860405A8BF2F2C095E5B6529F12=6DF979B751C120663785242C4964B6DB
4 | eclipse.preferences.version=1
5 | 


--------------------------------------------------------------------------------
/.settings/org.eclipse.cdt.core.prefs:
--------------------------------------------------------------------------------
1 | doxygen/doxygen_new_line_after_brief=true
2 | doxygen/doxygen_use_brief_tag=false
3 | doxygen/doxygen_use_javadoc_tags=true
4 | doxygen/doxygen_use_pre_tag=false
5 | doxygen/doxygen_use_structural_commands=false
6 | eclipse.preferences.version=1
7 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | *.elf
34 | *.launch
35 | *.xml
36 | 


--------------------------------------------------------------------------------
/Core/Src/common/time_utils.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * time_utils.cpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/time_utils.cpp
 6 |  */
 7 | 
 8 | #include "time_utils.h"
 9 | #include "stm32h7xx_hal.h"
10 | 
11 | // function buffering delay()
12 | void _delay(unsigned long ms){
13 | 	HAL_Delay(ms);
14 | }
15 | 
16 | // function buffering _micros()
17 | unsigned long _micros(void){
18 | 	//return HAL_GetTick()*1000; //get microseconds
19 | 	return TIM2->CNT; //counter should be set to 1MHz frequency
20 | }
21 | 
22 | 


--------------------------------------------------------------------------------
/Core/Src/common/time_utils.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * time_utils.h
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/time_utils.h
 6 |  */
 7 | 
 8 | #ifndef TIME_UTILS_H_
 9 | #define TIME_UTILS_H_
10 | 
11 | 
12 | 
13 | /**
14 |  * Function implementing delay() function in milliseconds
15 |  * - blocking function
16 |  * - hardware specific
17 |  * @param ms number of milliseconds to wait
18 |  */
19 | void _delay(unsigned long ms);
20 | 
21 | /**
22 |  * Function implementing timestamp getting function in microseconds
23 |  * hardware specific
24 |  */
25 | unsigned long _micros(void);
26 | 
27 | #endif /* TIME_UTILS_H_ */
28 | 


--------------------------------------------------------------------------------
/Core/Src/common/lowpass_filter.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * lowpass_filter.cpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/lowpass_filter.cpp
 6 |  */
 7 | 
 8 | #include "lowpass_filter.hpp"
 9 | 
10 | LowPassFilter::LowPassFilter(float time_constant)
11 |     : Tf(time_constant)
12 |     , y_prev(0.0f)
13 | {
14 |     timestamp_prev = _micros();
15 | }
16 | 
17 | 
18 | float LowPassFilter::operator() (float x)
19 | {
20 |     unsigned long timestamp = _micros();
21 |     float dt = (timestamp - timestamp_prev)*1e-6f;
22 | 
23 |     if (dt <= 0.0f || dt > 0.5f) //FIXME, without equals sign at dt < 0.0f the algo won't start.
24 |         dt = 1e-3f;
25 | 
26 |     float alpha = Tf/(Tf + dt);
27 |     float y = alpha*y_prev + (1.0f - alpha)*x;
28 | 
29 |     y_prev = y;
30 |     timestamp_prev = timestamp;
31 |     return y;
32 | }
33 | 


--------------------------------------------------------------------------------
/Core/Src/common/lowpass_filter.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * lowpass_filter.hpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/lowpass_filter.h
 6 |  */
 7 | 
 8 | #ifndef LOWPASS_FILTER_HPP_
 9 | #define LOWPASS_FILTER_HPP_
10 | 
11 | 
12 | #include "time_utils.h"
13 | #include "foc_utils.h"
14 | 
15 | /**
16 |  *  Low pass filter class
17 |  */
18 | class LowPassFilter
19 | {
20 | public:
21 |     /**
22 |      * @param Tf - Low pass filter time constant
23 |      */
24 |     LowPassFilter(float Tf);
25 |     ~LowPassFilter() = default;
26 | 
27 |     float operator() (float x);
28 |     float Tf; //!< Low pass filter time constant
29 | 
30 | protected:
31 |     unsigned long timestamp_prev;  //!< Last execution timestamp
32 |     float y_prev; //!< filtered value in previous execution step
33 | };
34 | 
35 | #endif /* LOWPASS_FILTER_HPP_ */
36 | 


--------------------------------------------------------------------------------
/Core/Src/current_sense/hardware_api.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * hardware_api.h
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/current_sense/hardware_api.h
 6 |  */
 7 | 
 8 | #ifndef HARDWARE_API_H_
 9 | #define HARDWARE_API_H_
10 | 
11 | #include "../common/foc_utils.h"
12 | #include "../common/time_utils.h"
13 | 
14 | /**
15 |  *  function reading an ADC value and returning the read voltage
16 |  *
17 |  * @param pinA - the arduino pin to be read (it has to be ADC pin)
18 |  */
19 | float _readADCVoltage(const int pinA);
20 | 
21 | /**
22 |  * function converting ADC reading to voltage
23 |  *
24 |  */
25 | float _ADCValueToVoltage(int raw_adc);
26 | 
27 | /**
28 |  *  function assigning ADC pins
29 |  *
30 |  * @param pinA - adc pin A
31 |  * @param pinB - adc pin B
32 |  * @param pinC - adc pin C
33 |  */
34 | void _configureADC(const int pinA,const int pinB,const int pinC = NOT_SET);
35 | 
36 | #endif /* HARDWARE_API_H_ */
37 | 


--------------------------------------------------------------------------------
/Core/Src/current_sense/hardware_api.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * hardware_api.cpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/current_sense/hardware_specific/generic_mcu.cpp
 6 |  */
 7 | 
 8 | #include "hardware_api.h"
 9 | #include "main.h"
10 | 
11 | #define _ADC_VOLTAGE 3.3
12 | #define _ADC_RESOLUTION 65536.0
13 | 
14 | // adc counts to voltage conversion ratio
15 | // some optimizing for faster execution
16 | #define _ADC_CONV ( (_ADC_VOLTAGE) / (_ADC_RESOLUTION) )
17 | 
18 | // function reading an ADC value and returning the read voltage
19 | float _readADCVoltage(const int pin){
20 | 	int raw_adc;
21 | 	if (pin == phaseA) {
22 | 		raw_adc = _readADCVoltage_pinA();
23 | 	}
24 | 	if (pin == phaseB) {
25 | 		raw_adc = _readADCVoltage_pinB();
26 | 	}
27 |   return raw_adc * _ADC_CONV;
28 | }
29 | 
30 | float _ADCValueToVoltage(int raw_adc) {
31 | 	return raw_adc * _ADC_CONV;
32 | }
33 | //// function assigning input pins to ADC
34 | //void _configureADC(const int pinA,const int pinB){
35 | //	pinA = phaseA;
36 | //	pinB = phaseB;
37 | //}
38 | 
39 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 NGalin
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Core/Src/SimpleFOC.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * SimpleFOC.hpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/SimpleFOC.h
 6 |  */
 7 | 
 8 | #ifndef SRC_SIMPLEFOC_HPP_
 9 | #define SRC_SIMPLEFOC_HPP_
10 | 
11 | /*!
12 |  * @file SimpleFOC.h ported from "https://github.com/simplefoc/Arduino-FOC/blob/v2.1"
13 |  *
14 |  * @mainpage Simple Field Oriented Control BLDC motor control library
15 |  *
16 |  * @section intro_sec Introduction
17 |  * This version only supports a single STM32 MCU development board at the moment. See README for the
18 |  * required pin configuration to support SimpleFOCShield v2.0.2
19 |  *
20 |  * @section dependencies Supported Hardware
21 |  *  - Motors
22 |  *    - BLDC motors
23 |  * - Drivers
24 |  *    - BLDC drivers
25 |  * - Position sensors
26 |  *    - Encoders
27 |  *    - Open-loop control
28 |  * - Microcontrollers
29 |  *    - STM32H743ZI2
30 |  */
31 | 
32 | 
33 | #include "BLDCMotor.hpp"
34 | #include "sensors/Encoder.hpp"
35 | #include "sensors/MagneticSensorSPI.hpp"
36 | #include "motor_drivers/BLDCDriver3PWM.hpp"
37 | #include "current_sense/InlineCurrentSense.hpp"
38 | 
39 | 
40 | 
41 | 
42 | #endif /* SRC_SIMPLEFOC_HPP_ */
43 | 


--------------------------------------------------------------------------------
/STM32_SimpleFOC_InlineCurrentSense.cfg:
--------------------------------------------------------------------------------
 1 | # This is an NUCLEO-H743ZI2 board with a single STM32H743ZITx chip
 2 | #
 3 | # Generated by STM32CubeIDE
 4 | # Take care that such file, as generated, may be overridden without any early notice. Please have a look to debug launch configuration setup(s)
 5 | 
 6 | source [find interface/stlink-dap.cfg]
 7 | 
 8 | 
 9 | set WORKAREASIZE 0x8000
10 | 
11 | transport select "dapdirect_swd"
12 | 
13 | set CHIPNAME STM32H743ZITx
14 | set BOARDNAME NUCLEO-H743ZI2
15 | 
16 | # Enable debug when in low power modes
17 | set ENABLE_LOW_POWER 1
18 | 
19 | # Stop Watchdog counters when halt
20 | set STOP_WATCHDOG 1
21 | 
22 | # STlink Debug clock frequency
23 | set CLOCK_FREQ 8000
24 | 
25 | # Reset configuration
26 | # use hardware reset, connect under reset
27 | # connect_assert_srst needed if low power mode application running (WFI...)
28 | reset_config srst_only srst_nogate connect_assert_srst
29 | set CONNECT_UNDER_RESET 1
30 | set CORE_RESET 0
31 | 
32 | # ACCESS PORT NUMBER
33 | set AP_NUM 0
34 | # GDB PORT
35 | set GDB_PORT 3333
36 | 
37 | set DUAL_BANK 1
38 | 
39 | 
40 | # BCTM CPU variables
41 | 
42 | source [find target/stm32h7x.cfg]
43 | 
44 | #SWV trace
45 | tpiu config disable 
46 | 


--------------------------------------------------------------------------------
/Core/Src/common/base_classes/Sensor.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Sensor.cpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/base_classes/Sensor.cpp
 6 |  */
 7 | 
 8 | #include "Sensor.hpp"
 9 | 
10 | #include "../foc_utils.h"
11 | #include "../time_utils.h"
12 | 
13 |  /**
14 |  * returns 0 if it does need search for absolute zero
15 |  * 0 - magnetic sensor (& encoder with index which is found)
16 |  * 1 - encoder with index (with index not found yet)
17 |  */
18 | int Sensor::needsSearch(){
19 |     return 0;
20 | }
21 | 
22 |  /** get current angular velocity (rad/s)*/
23 | float Sensor::getVelocity(){
24 | 
25 |     // calculate sample time
26 |     unsigned long now_us = _micros();
27 |     float Ts = (now_us - velocity_calc_timestamp)*1e-6;
28 |     // quick fix for strange cases (micros overflow)
29 |     if(Ts <= 0 || Ts > 0.5) Ts = 1e-3;
30 | 
31 |     // current angle
32 |     float angle_c = getAngle();
33 |     // velocity calculation
34 |     float vel = (angle_c - angle_prev)/Ts;
35 | 
36 |     // save variables for future pass
37 |     angle_prev = angle_c;
38 |     velocity_calc_timestamp = now_us;
39 |     return vel;
40 | }
41 | 
42 | void Sensor::setAngle(float angle_value) {
43 | 	angle_prev = angle_value;
44 | }
45 | 


--------------------------------------------------------------------------------
/Core/Src/common/pid.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * pid.hpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/pid.h
 6 |  */
 7 | 
 8 | 
 9 | #ifndef PID_HPP_
10 | #define PID_HPP_
11 | 
12 | 
13 | 
14 | #include "time_utils.h"
15 | #include "foc_utils.h"
16 | 
17 | /**
18 |  *  PID controller class
19 |  */
20 | class PIDController
21 | {
22 | public:
23 |     /**
24 |      *
25 |      * @param P - Proportional gain
26 |      * @param I - Integral gain
27 |      * @param D - Derivative gain
28 |      * @param ramp - Maximum speed of change of the output value
29 |      * @param limit - Maximum output value
30 |      */
31 |     PIDController(float P, float I, float D, float ramp, float limit);
32 |     ~PIDController() = default;
33 | 
34 |     float operator() (float error);
35 | 
36 |     float P; //!< Proportional gain
37 |     float I; //!< Integral gain
38 |     float D; //!< Derivative gain
39 |     float output_ramp; //!< Maximum speed of change of the output value
40 |     float limit; //!< Maximum output value
41 | 
42 | protected:
43 |     float integral_prev; //!< last integral component value
44 |     float error_prev; //!< last tracking error value
45 |     unsigned long timestamp_prev; //!< Last execution timestamp
46 |     float output_prev;  //!< last pid output value
47 |     float Ts; //!<time interval in microseconds
48 | };
49 | 
50 | 
51 | #endif /* PID_HPP_ */
52 | 


--------------------------------------------------------------------------------
/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>STM32_SimpleFOC_InlineCurrentSense</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
10 | 			<triggers>clean,full,incremental,</triggers>
11 | 			<arguments>
12 | 			</arguments>
13 | 		</buildCommand>
14 | 		<buildCommand>
15 | 			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
16 | 			<triggers>full,incremental,</triggers>
17 | 			<arguments>
18 | 			</arguments>
19 | 		</buildCommand>
20 | 	</buildSpec>
21 | 	<natures>
22 | 		<nature>com.st.stm32cube.ide.mcu.MCUProjectNature</nature>
23 | 		<nature>org.eclipse.cdt.core.cnature</nature>
24 | 		<nature>com.st.stm32cube.ide.mcu.MCUCubeIdeServicesRevAev2ProjectNature</nature>
25 | 		<nature>com.st.stm32cube.ide.mcu.MCUCubeProjectNature</nature>
26 | 		<nature>com.st.stm32cube.ide.mcu.MCUAdvancedStructureProjectNature</nature>
27 | 		<nature>com.st.stm32cube.ide.mcu.MCUEndUserDisabledTrustZoneProjectNature</nature>
28 | 		<nature>com.st.stm32cube.ide.mcu.MCUSingleCpuProjectNature</nature>
29 | 		<nature>com.st.stm32cube.ide.mcu.MCURootProjectNature</nature>
30 | 		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
31 | 		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
32 | 		<nature>org.eclipse.cdt.core.ccnature</nature>
33 | 	</natures>
34 | </projectDescription>
35 | 


--------------------------------------------------------------------------------
/Core/Inc/gpio.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |   ******************************************************************************
 3 |   * @file    gpio.h
 4 |   * @brief   This file contains all the function prototypes for
 5 |   *          the gpio.c file
 6 |   ******************************************************************************
 7 |   * @attention
 8 |   *
 9 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
10 |   * All rights reserved.</center></h2>
11 |   *
12 |   * This software component is licensed by ST under BSD 3-Clause license,
13 |   * the "License"; You may not use this file except in compliance with the
14 |   * License. You may obtain a copy of the License at:
15 |   *                        opensource.org/licenses/BSD-3-Clause
16 |   *
17 |   ******************************************************************************
18 |   */
19 | /* Define to prevent recursive inclusion -------------------------------------*/
20 | #ifndef __GPIO_H__
21 | #define __GPIO_H__
22 | 
23 | #ifdef __cplusplus
24 | extern "C" {
25 | #endif
26 | 
27 | /* Includes ------------------------------------------------------------------*/
28 | #include "main.h"
29 | 
30 | /* USER CODE BEGIN Includes */
31 | 
32 | /* USER CODE END Includes */
33 | 
34 | /* USER CODE BEGIN Private defines */
35 | 
36 | /* USER CODE END Private defines */
37 | 
38 | void MX_GPIO_Init(void);
39 | 
40 | /* USER CODE BEGIN Prototypes */
41 | 
42 | /* USER CODE END Prototypes */
43 | 
44 | #ifdef __cplusplus
45 | }
46 | #endif
47 | #endif /*__ GPIO_H__ */
48 | 
49 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
50 | 


--------------------------------------------------------------------------------
/Core/Inc/spi.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |   ******************************************************************************
 3 |   * @file    spi.h
 4 |   * @brief   This file contains all the function prototypes for
 5 |   *          the spi.c file
 6 |   ******************************************************************************
 7 |   * @attention
 8 |   *
 9 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
10 |   * All rights reserved.</center></h2>
11 |   *
12 |   * This software component is licensed by ST under BSD 3-Clause license,
13 |   * the "License"; You may not use this file except in compliance with the
14 |   * License. You may obtain a copy of the License at:
15 |   *                        opensource.org/licenses/BSD-3-Clause
16 |   *
17 |   ******************************************************************************
18 |   */
19 | /* Define to prevent recursive inclusion -------------------------------------*/
20 | #ifndef __SPI_H__
21 | #define __SPI_H__
22 | 
23 | #ifdef __cplusplus
24 | extern "C" {
25 | #endif
26 | 
27 | /* Includes ------------------------------------------------------------------*/
28 | #include "main.h"
29 | 
30 | /* USER CODE BEGIN Includes */
31 | 
32 | /* USER CODE END Includes */
33 | 
34 | extern SPI_HandleTypeDef hspi1;
35 | 
36 | /* USER CODE BEGIN Private defines */
37 | 
38 | /* USER CODE END Private defines */
39 | 
40 | void MX_SPI1_Init(void);
41 | 
42 | /* USER CODE BEGIN Prototypes */
43 | 
44 | /* USER CODE END Prototypes */
45 | 
46 | #ifdef __cplusplus
47 | }
48 | #endif
49 | 
50 | #endif /* __SPI_H__ */
51 | 
52 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
53 | 


--------------------------------------------------------------------------------
/Core/Src/common/base_classes/Sensor.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Sensor.hpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/base_classes/Sensor.h
 6 |  */
 7 | 
 8 | 
 9 | #ifndef SENSOR_HPP_
10 | #define SENSOR_HPP_
11 | 
12 | /**
13 |  *  Direction structure
14 |  */
15 | enum Direction{
16 |     CW      = 1,  //clockwise
17 |     CCW     = -1, // counter clockwise
18 |     UNKNOWN = 0   //not yet known or invalid state
19 | };
20 | 
21 | 
22 | /**
23 |  *  Pullup configuration structure
24 |  */
25 | enum Pullup{
26 |     INTERN, //!< Use internal pullups
27 |     EXTERN //!< Use external pullups
28 | };
29 | 
30 | /**
31 |  *  Sensor abstract class definition
32 |  * Each sensor needs to have these functions implemented
33 |  */
34 | class Sensor{
35 |     public:
36 | 
37 |         /** get current angle (rad) */
38 |         virtual float getAngle()=0;
39 |         /** get current angular velocity (rad/s)*/
40 |         virtual float getVelocity();
41 | 
42 |         /**
43 |          * returns 0 if it does need search for absolute zero
44 |          * 0 - magnetic sensor (& encoder with index which is found)
45 |          * 1 - encoder with index (with index not found yet)
46 |          */
47 |         virtual int needsSearch();
48 | 
49 |         /** NAT: set angle to zero:         */
50 |         virtual void setAngle(float);
51 | 
52 |     private:
53 |         // velocity calculation variables
54 |         float angle_prev=0; //!< angle in previous velocity calculation step
55 |         long velocity_calc_timestamp=0; //!< last velocity calculation timestamp
56 | };
57 | 
58 | 
59 | 
60 | #endif /* SENSOR_HPP_ */
61 | 


--------------------------------------------------------------------------------
/Core/Inc/adc.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |   ******************************************************************************
 3 |   * @file    adc.h
 4 |   * @brief   This file contains all the function prototypes for
 5 |   *          the adc.c file
 6 |   ******************************************************************************
 7 |   * @attention
 8 |   *
 9 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
10 |   * All rights reserved.</center></h2>
11 |   *
12 |   * This software component is licensed by ST under BSD 3-Clause license,
13 |   * the "License"; You may not use this file except in compliance with the
14 |   * License. You may obtain a copy of the License at:
15 |   *                        opensource.org/licenses/BSD-3-Clause
16 |   *
17 |   ******************************************************************************
18 |   */
19 | /* Define to prevent recursive inclusion -------------------------------------*/
20 | #ifndef __ADC_H__
21 | #define __ADC_H__
22 | 
23 | #ifdef __cplusplus
24 | extern "C" {
25 | #endif
26 | 
27 | /* Includes ------------------------------------------------------------------*/
28 | #include "main.h"
29 | 
30 | /* USER CODE BEGIN Includes */
31 | 
32 | /* USER CODE END Includes */
33 | 
34 | extern ADC_HandleTypeDef hadc1;
35 | extern ADC_HandleTypeDef hadc3;
36 | 
37 | /* USER CODE BEGIN Private defines */
38 | 
39 | /* USER CODE END Private defines */
40 | 
41 | void MX_ADC1_Init(void);
42 | void MX_ADC3_Init(void);
43 | 
44 | /* USER CODE BEGIN Prototypes */
45 | 
46 | /* USER CODE END Prototypes */
47 | 
48 | #ifdef __cplusplus
49 | }
50 | #endif
51 | 
52 | #endif /* __ADC_H__ */
53 | 
54 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
55 | 


--------------------------------------------------------------------------------
/Core/Src/common/base_classes/BLDCDriver.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BLDCDriver.hpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/base_classes/BLDCDriver.h
 6 |  */
 7 | 
 8 | #ifndef BLDCDRIVER_HPP_
 9 | #define BLDCDRIVER_HPP_
10 | 
11 | 
12 | class BLDCDriver{
13 |     public:
14 | 
15 |         /** Initialise hardware */
16 |         virtual int init() = 0;
17 |         /** Enable hardware */
18 |         virtual void enable() = 0;
19 |         /** Disable hardware */
20 |         virtual void disable() = 0;
21 | 
22 |         long pwm_frequency; //!< pwm frequency value in hertz
23 |         float voltage_power_supply; //!< power supply voltage
24 |         float voltage_limit; //!< limiting voltage set to the motor
25 | 
26 | 
27 |         float dc_a; //!< currently set duty cycle on phaseA
28 |         float dc_b; //!< currently set duty cycle on phaseB
29 |         float dc_c; //!< currently set duty cycle on phaseC
30 | 
31 |         /**
32 |          * Set phase voltages to the harware
33 |          *
34 |          * @param Ua - phase A voltage
35 |          * @param Ub - phase B voltage
36 |          * @param Uc - phase C voltage
37 |         */
38 |         virtual void setPwm(float Ua, float Ub, float Uc) = 0;
39 | 
40 | //        /**
41 | //         * Set phase state, enable/disable
42 | //         *
43 | //         * @param sc - phase A state : active / disabled ( high impedance )
44 | //         * @param sb - phase B state : active / disabled ( high impedance )
45 | //         * @param sa - phase C state : active / disabled ( high impedance )
46 | //        */
47 | //        virtual void setPhaseState(int sa, int sb, int sc) = 0;
48 | };
49 | 
50 | 
51 | 
52 | 
53 | #endif /* BLDCDRIVER_HPP_ */
54 | 


--------------------------------------------------------------------------------
/Core/Inc/tim.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |   ******************************************************************************
 3 |   * @file    tim.h
 4 |   * @brief   This file contains all the function prototypes for
 5 |   *          the tim.c file
 6 |   ******************************************************************************
 7 |   * @attention
 8 |   *
 9 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
10 |   * All rights reserved.</center></h2>
11 |   *
12 |   * This software component is licensed by ST under BSD 3-Clause license,
13 |   * the "License"; You may not use this file except in compliance with the
14 |   * License. You may obtain a copy of the License at:
15 |   *                        opensource.org/licenses/BSD-3-Clause
16 |   *
17 |   ******************************************************************************
18 |   */
19 | /* Define to prevent recursive inclusion -------------------------------------*/
20 | #ifndef __TIM_H__
21 | #define __TIM_H__
22 | 
23 | #ifdef __cplusplus
24 | extern "C" {
25 | #endif
26 | 
27 | /* Includes ------------------------------------------------------------------*/
28 | #include "main.h"
29 | 
30 | /* USER CODE BEGIN Includes */
31 | 
32 | /* USER CODE END Includes */
33 | 
34 | extern TIM_HandleTypeDef htim1;
35 | extern TIM_HandleTypeDef htim2;
36 | 
37 | /* USER CODE BEGIN Private defines */
38 | 
39 | /* USER CODE END Private defines */
40 | 
41 | void MX_TIM1_Init(void);
42 | void MX_TIM2_Init(void);
43 | 
44 | void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);
45 | 
46 | /* USER CODE BEGIN Prototypes */
47 | 
48 | /* USER CODE END Prototypes */
49 | 
50 | #ifdef __cplusplus
51 | }
52 | #endif
53 | 
54 | #endif /* __TIM_H__ */
55 | 
56 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
57 | 


--------------------------------------------------------------------------------
/Drivers/CMSIS/Include/cmsis_version.h:
--------------------------------------------------------------------------------
 1 | /**************************************************************************//**
 2 |  * @file     cmsis_version.h
 3 |  * @brief    CMSIS Core(M) Version definitions
 4 |  * @version  V5.0.2
 5 |  * @date     19. April 2017
 6 |  ******************************************************************************/
 7 | /*
 8 |  * Copyright (c) 2009-2017 ARM Limited. All rights reserved.
 9 |  *
10 |  * SPDX-License-Identifier: Apache-2.0
11 |  *
12 |  * Licensed under the Apache License, Version 2.0 (the License); you may
13 |  * not use this file except in compliance with the License.
14 |  * You may obtain a copy of the License at
15 |  *
16 |  * www.apache.org/licenses/LICENSE-2.0
17 |  *
18 |  * Unless required by applicable law or agreed to in writing, software
19 |  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
20 |  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21 |  * See the License for the specific language governing permissions and
22 |  * limitations under the License.
23 |  */
24 | 
25 | #if   defined ( __ICCARM__ )
26 |   #pragma system_include         /* treat file as system include file for MISRA check */
27 | #elif defined (__clang__)
28 |   #pragma clang system_header   /* treat file as system include file */
29 | #endif
30 | 
31 | #ifndef __CMSIS_VERSION_H
32 | #define __CMSIS_VERSION_H
33 | 
34 | /*  CMSIS Version definitions */
35 | #define __CM_CMSIS_VERSION_MAIN  ( 5U)                                      /*!< [31:16] CMSIS Core(M) main version */
36 | #define __CM_CMSIS_VERSION_SUB   ( 1U)                                      /*!< [15:0]  CMSIS Core(M) sub version */
37 | #define __CM_CMSIS_VERSION       ((__CM_CMSIS_VERSION_MAIN << 16U) | \
38 |                                    __CM_CMSIS_VERSION_SUB           )       /*!< CMSIS Core(M) version number */
39 | #endif
40 | 


--------------------------------------------------------------------------------
/Core/Src/motor_drivers/BLDCDriver3PWM.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BLDCDriver3PWM.hpp
 3 |  *
 4 |  *  Created on: 24 Mar 2021
 5 |  *      Author: natal
 6 |  */
 7 | 
 8 | #ifndef BLDCDRIVER3PWM_HPP_
 9 | #define BLDCDRIVER3PWM_HPP_
10 | 
11 | 
12 | #include "../common/base_classes/BLDCDriver.hpp"
13 | #include "../common/foc_utils.h"
14 | #include "../common/time_utils.h"
15 | #include "../common/defaults.h"
16 | 
17 | 
18 | /**
19 |  3 pwm bldc driver class
20 | */
21 | class BLDCDriver3PWM: public BLDCDriver
22 | {
23 |   public:
24 |     /**
25 |       BLDCDriver class constructor
26 |       @param phA A phase pwm pin
27 |       @param phB B phase pwm pin
28 |       @param phC C phase pwm pin
29 |       @param en1 enable pin (optional input)
30 |       @param en2 enable pin (optional input)
31 |       @param en3 enable pin (optional input)
32 |     */
33 |     BLDCDriver3PWM(int phA,int phB,int phC, int en1);// = NOT_SET, int en2 = NOT_SET, int en3 = NOT_SET);
34 | 
35 |     /**  Motor hardware init function */
36 |   	int init() override;
37 |     /** Motor disable function */
38 |   	void disable() override;
39 |     /** Motor enable function */
40 |     void enable() override;
41 | 
42 |     // hardware variables
43 |   	int pwmA; //!< phase A pwm pin number
44 |   	int pwmB; //!< phase B pwm pin number
45 |   	int pwmC; //!< phase C pwm pin number
46 |     int enableA_pin; //!< enable pin number
47 | //    int enableB_pin; //!< enable pin number
48 | //    int enableC_pin; //!< enable pin number
49 | 
50 |     /**
51 |      * Set phase voltages to the harware
52 |      *
53 |      * @param Ua - phase A voltage
54 |      * @param Ub - phase B voltage
55 |      * @param Uc - phase C voltage
56 |     */
57 |     void setPwm(float Ua, float Ub, float Uc) override;
58 | 
59 | //    /**
60 | //     * Set phase voltages to the harware
61 | //     *
62 | //     * @param sc - phase A state : active / disabled ( high impedance )
63 | //     * @param sb - phase B state : active / disabled ( high impedance )
64 | //     * @param sa - phase C state : active / disabled ( high impedance )
65 | //    */
66 | //    virtual void setPhaseState(int sa, int sb, int sc) override;
67 |   private:
68 | 
69 | };
70 | 
71 | 
72 | 
73 | 
74 | #endif /* BLDCDRIVER3PWM_HPP_ */
75 | 


--------------------------------------------------------------------------------
/Core/Src/common/defaults.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * defaults.h
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/defaults.h
 6 |  */
 7 | 
 8 | #ifndef DEFAULTS_H_
 9 | #define DEFAULTS_H_
10 | 
11 | // default configuration values
12 | // change this file to optimal values for your application
13 | 
14 | #define DEF_POWER_SUPPLY 24.0 //!< default power supply voltage
15 | // velocity PI controller params
16 | #define DEF_PID_VEL_P 0.5 //!< default PID controller P value
17 | #define DEF_PID_VEL_I 10.0 //!<  default PID controller I value
18 | #define DEF_PID_VEL_D 0.0 //!<  default PID controller D value
19 | #define DEF_PID_VEL_RAMP 1000.0 //!< default PID controller voltage ramp value
20 | #define DEF_PID_VEL_LIMIT (DEF_POWER_SUPPLY) //!< default PID controller voltage limit
21 | 
22 | // current sensing PID values
23 | // for stm32
24 | #define DEF_PID_CURR_P 0.01 //NAT changed this, 3 //!< default PID controller P value
25 | #define DEF_PID_CURR_I 1 //NAT changed this, 300.0 //!<  default PID controller I value
26 | #define DEF_PID_CURR_D 0.0 //!<  default PID controller D value
27 | #define DEF_PID_CURR_RAMP 50//NAT changed this, 1e11 //!< default PID controller voltage ramp value
28 | #define DEF_PID_CURR_LIMIT 4//NAT changed this, (DEF_POWER_SUPPLY) //!< default PID controller voltage limit
29 | #define DEF_CURR_FILTER_Tf 0.005 //!< default current filter time constant
30 | 
31 | // default current limit values
32 | #define DEF_CURRENT_LIM 2 //!< 2Amps current limit by default
33 | 
34 | // default monitor downsample
35 | #define DEF_MON_DOWNSMAPLE 100 //!< default monitor downsample
36 | #define DEF_MOTION_DOWNSMAPLE 0 //!< default motion downsample - disable
37 | 
38 | // angle P params
39 | #define DEF_P_ANGLE_P 20.0 //!< default P controller P value
40 | #define DEF_VEL_LIM 20.0 //!< angle velocity limit default
41 | 
42 | // index search
43 | #define DEF_INDEX_SEARCH_TARGET_VELOCITY 1.0 //!< default index search velocity
44 | // align voltage
45 | #define DEF_VOLTAGE_SENSOR_ALIGN 3.0 //!< default voltage for sensor and motor zero alignment
46 | // low pass filter velocity
47 | #define DEF_VEL_FILTER_Tf 0.005 //!< default velocity filter time constant
48 | 
49 | 
50 | 
51 | #endif /* DEFAULTS_H_ */
52 | 


--------------------------------------------------------------------------------
/Core/Src/current_sense/InlineCurrentSense.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * InlineCurrentSense.hpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/current_sense/InlineCurrentSense.h
 6 |  */
 7 | 
 8 | #ifndef INLINECURRENTSENSE_HPP_
 9 | #define INLINECURRENTSENSE_HPP_
10 | 
11 | 
12 | #include "../common/foc_utils.h"
13 | #include "../common/time_utils.h"
14 | #include "../common/base_classes/CurrentSense.hpp"
15 | #include "hardware_api.h"
16 | 
17 | 
18 | class InlineCurrentSense: public CurrentSense{
19 |   public:
20 |     /**
21 |       InlineCurrentSense class constructor
22 |       @param shunt_resistor shunt resistor value
23 |       @param gain current-sense op-amp gain
24 |       @param phA A phase adc pin
25 |       @param phB B phase adc pin
26 |       @param phC C phase adc pin (optional)
27 |     */
28 |     InlineCurrentSense(float shunt_resistor, float gain, int pinA, int pinB, int pinC = NOT_SET);
29 | 
30 |     // CurrentSense interface implementing functions
31 |     void init() override;
32 |     PhaseCurrent_s getPhaseCurrents() override;
33 |     int driverSync(BLDCDriver *driver) override;
34 |     int driverAlign(BLDCDriver *driver, float voltage) override;
35 | 
36 |     // ADC measuremnet gain for each phase
37 |     // support for different gains for different phases of more commonly - inverted phase currents
38 |     // this should be automated later
39 |   	int gain_a; //!< phase A gain
40 |   	int gain_b; //!< phase B gain
41 |   	int gain_c; //!< phase C gain
42 | 
43 |   private:
44 | 
45 |     // hardware variables
46 |   	int pinA; //!< pin A analog pin for current measurement
47 |   	int pinB; //!< pin B analog pin for current measurement
48 |   	int pinC; //!< pin C analog pin for current measurement
49 | 
50 |     // gain variables
51 |     double shunt_resistor; //!< Shunt resistor value
52 |     double amp_gain; //!< amp gain value
53 |     double volts_to_amps_ratio; //!< Volts to amps ratio
54 | 
55 |     /**
56 |      *  Function finding zero offsets of the ADC
57 |      */
58 |     void calibrateOffsets();
59 |     double offset_ia; //!< zero current A voltage value (center of the adc reading)
60 |     double offset_ib; //!< zero current B voltage value (center of the adc reading)
61 |     double offset_ic; //!< zero current C voltage value (center of the adc reading)
62 | 
63 | };
64 | 
65 | 
66 | 
67 | 
68 | #endif /* INLINECURRENTSENSE_HPP_ */
69 | 


--------------------------------------------------------------------------------
/Core/Src/common/foc_utils.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * foc_utils.h
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/foc_utils.h
 6 |  */
 7 | 
 8 | #ifndef FOC_UTILS_H_
 9 | #define FOC_UTILS_H_
10 | 
11 | // sign function
12 | #define _sign(a) ( ( (a) < 0 )  ?  -1   : ( (a) > 0 ) )
13 | #define _round(x) ((x)>=0?(long)((x)+0.5):(long)((x)-0.5))
14 | #define _constrain(amt,low,high) ((amt)<(low)?(low):((amt)>(high)?(high):(amt)))
15 | #define _sqrt(a) (_sqrtApprox(a))
16 | #define _isset(a) ( (a) != (NOT_SET) )
17 | 
18 | // utility defines
19 | #define _2_SQRT3 1.15470053838
20 | #define _SQRT3 1.73205080757
21 | #define _1_SQRT3 0.57735026919
22 | #define _SQRT3_2 0.86602540378
23 | #define _SQRT2 1.41421356237
24 | #define _120_D2R 2.09439510239
25 | #define _PI 3.14159265359
26 | #define _PI_2 1.57079632679
27 | #define _PI_3 1.0471975512
28 | #define _2PI 6.28318530718
29 | #define _3PI_2 4.71238898038
30 | #define _PI_6 0.52359877559
31 | 
32 | #define NOT_SET -12345.0
33 | #define _HIGH_IMPEDANCE 0
34 | #define _HIGH_Z _HIGH_IMPEDANCE
35 | #define _ACTIVE 1
36 | 
37 | // dq current structure
38 | struct DQCurrent_s
39 | {
40 |     float d;
41 |     float q;
42 | };
43 | // phase current structure
44 | struct PhaseCurrent_s
45 | {
46 |     float a;
47 |     float b;
48 |     float c;
49 | };
50 | // dq voltage structs
51 | struct DQVoltage_s
52 | {
53 |     float d;
54 |     float q;
55 | };
56 | 
57 | 
58 | /**
59 |  *  Function approximating the sine calculation by using fixed size array
60 |  * - execution time ~40us (Arduino UNO)
61 |  *
62 |  * @param a angle in between 0 and 2PI
63 |  */
64 | float _sin(float a);
65 | /**
66 |  * Function approximating cosine calculation by using fixed size array
67 |  * - execution time ~50us (Arduino UNO)
68 |  *
69 |  * @param a angle in between 0 and 2PI
70 |  */
71 | float _cos(float a);
72 | 
73 | /**
74 |  * normalizing radian angle to [0,2PI]
75 |  * @param angle - angle to be normalized
76 |  */
77 | float _normalizeAngle(float angle);
78 | 
79 | 
80 | /**
81 |  * Electrical angle calculation
82 |  *
83 |  * @param shaft_angle - shaft angle of the motor
84 |  * @param pole_pairs - number of pole pairs
85 |  */
86 | float _electricalAngle(float shaft_angle, int pole_pairs);
87 | 
88 | /**
89 |  * Function approximating square root function
90 |  *  - using fast inverse square root
91 |  *
92 |  * @param value - number
93 |  */
94 | float _sqrtApprox(float value);
95 | 
96 | #endif /* FOC_UTILS_H_ */
97 | 


--------------------------------------------------------------------------------
/Core/Src/common/pid.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * pid.cpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/pid.cpp
 6 |  */
 7 | 
 8 | #include "pid.hpp"
 9 | #include "main.h" //for debugging
10 | 
11 | PIDController::PIDController(float P, float I, float D, float ramp, float limit)
12 |     : P(P)
13 |     , I(I)
14 |     , D(D)
15 |     , output_ramp(ramp)    // output derivative limit [volts/second]
16 |     , limit(limit)         // output supply limit     [volts]
17 |     , integral_prev(0.0)
18 |     , error_prev(0.0)
19 |     , output_prev(0.0)
20 | {
21 |     timestamp_prev = _micros();
22 | }
23 | 
24 | // PID controller function
25 | float PIDController::operator() (float error){
26 |     // calculate the time from the last call
27 | //	HAL_GPIO_WritePin(LD1_GPIO_Port, LD1_Pin, GPIO_PIN_SET); //debug for timing the FOC loop
28 | 	//HAL_GPIO_TogglePin(LD1_GPIO_Port, LD1_Pin);
29 |     unsigned long timestamp_now = _micros();
30 |     Ts = (timestamp_now - timestamp_prev) * 1e-6;
31 |     // quick fix for strange cases (micros overflow)
32 |     if(Ts <= 0 || Ts > 0.5) Ts = 1e-3;
33 | 
34 |     // u(s) = (P + I/s + Ds)e(s)
35 |     // Discrete implementations
36 |     // proportional part
37 |     // u_p  = P *e(k)
38 |     float proportional = P * error;
39 |     // Tustin transform of the integral part
40 |     // u_ik = u_ik_1  + I*Ts/2*(ek + ek_1)
41 |     float integral = integral_prev + I*Ts*0.5*(error + error_prev);
42 |     // antiwindup - limit the output
43 |     integral = _constrain(integral, -limit, limit);
44 |     // Discrete derivation
45 |     // u_dk = D(ek - ek_1)/Ts
46 |     float derivative = D*(error - error_prev)/Ts;
47 | 
48 |     // sum all the components
49 |     float output = proportional + integral + derivative;
50 |     // antiwindup - limit the output variable
51 |     output = _constrain(output, -limit, limit);
52 | 
53 |     // limit the acceleration by ramping the output
54 |     float output_rate = (output - output_prev)/Ts;
55 |     if (output_rate > output_ramp)
56 |         output = output_prev + output_ramp*Ts;
57 |     else if (output_rate < -output_ramp)
58 |         output = output_prev - output_ramp*Ts;
59 | 
60 |     // saving for the next pass
61 |     integral_prev = integral;
62 |     output_prev = output;
63 |     error_prev = error;
64 |     timestamp_prev = timestamp_now;
65 | 
66 | 	//HAL_GPIO_WritePin(LD1_GPIO_Port, LD1_Pin, GPIO_PIN_RESET); //debug for timing the FOC loop
67 |     return output;
68 | }
69 | 


--------------------------------------------------------------------------------
/Core/Inc/stm32h7xx_it.h:
--------------------------------------------------------------------------------
 1 | /* USER CODE BEGIN Header */
 2 | /**
 3 |   ******************************************************************************
 4 |   * @file    stm32h7xx_it.h
 5 |   * @brief   This file contains the headers of the interrupt handlers.
 6 |   ******************************************************************************
 7 |   * @attention
 8 |   *
 9 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
10 |   * All rights reserved.</center></h2>
11 |   *
12 |   * This software component is licensed by ST under BSD 3-Clause license,
13 |   * the "License"; You may not use this file except in compliance with the
14 |   * License. You may obtain a copy of the License at:
15 |   *                        opensource.org/licenses/BSD-3-Clause
16 |   *
17 |  ******************************************************************************
18 |   */
19 | /* USER CODE END Header */
20 | 
21 | /* Define to prevent recursive inclusion -------------------------------------*/
22 | #ifndef __STM32H7xx_IT_H
23 | #define __STM32H7xx_IT_H
24 | 
25 | #ifdef __cplusplus
26 |  extern "C" {
27 | #endif
28 | 
29 | /* Private includes ----------------------------------------------------------*/
30 | /* USER CODE BEGIN Includes */
31 | 
32 | /* USER CODE END Includes */
33 | 
34 | /* Exported types ------------------------------------------------------------*/
35 | /* USER CODE BEGIN ET */
36 | 
37 | /* USER CODE END ET */
38 | 
39 | /* Exported constants --------------------------------------------------------*/
40 | /* USER CODE BEGIN EC */
41 | 
42 | /* USER CODE END EC */
43 | 
44 | /* Exported macro ------------------------------------------------------------*/
45 | /* USER CODE BEGIN EM */
46 | 
47 | /* USER CODE END EM */
48 | 
49 | /* Exported functions prototypes ---------------------------------------------*/
50 | void NMI_Handler(void);
51 | void HardFault_Handler(void);
52 | void MemManage_Handler(void);
53 | void BusFault_Handler(void);
54 | void UsageFault_Handler(void);
55 | void SVC_Handler(void);
56 | void DebugMon_Handler(void);
57 | void PendSV_Handler(void);
58 | void SysTick_Handler(void);
59 | void EXTI9_5_IRQHandler(void);
60 | void TIM1_UP_IRQHandler(void);
61 | void TIM2_IRQHandler(void);
62 | void SPI1_IRQHandler(void);
63 | void EXTI15_10_IRQHandler(void);
64 | /* USER CODE BEGIN EFP */
65 | 
66 | /* USER CODE END EFP */
67 | 
68 | #ifdef __cplusplus
69 | }
70 | #endif
71 | 
72 | #endif /* __STM32H7xx_IT_H */
73 | 
74 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
75 | 


--------------------------------------------------------------------------------
/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_spi_ex.h:
--------------------------------------------------------------------------------
 1 | /**
 2 |   ******************************************************************************
 3 |   * @file    stm32h7xx_hal_spi_ex.h
 4 |   * @author  MCD Application Team
 5 |   * @brief   Header file of SPI HAL Extended module.
 6 |   ******************************************************************************
 7 |   * @attention
 8 |   *
 9 |   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
10 |   * All rights reserved.</center></h2>
11 |   *
12 |   * This software component is licensed by ST under BSD 3-Clause license,
13 |   * the "License"; You may not use this file except in compliance with the
14 |   * License. You may obtain a copy of the License at:
15 |   *                        opensource.org/licenses/BSD-3-Clause
16 |   *
17 |   ******************************************************************************
18 |   */
19 | 
20 | /* Define to prevent recursive inclusion -------------------------------------*/
21 | #ifndef STM32H7xx_HAL_SPI_EX_H
22 | #define STM32H7xx_HAL_SPI_EX_H
23 | 
24 | #ifdef __cplusplus
25 | extern "C" {
26 | #endif
27 | 
28 | /* Includes ------------------------------------------------------------------*/
29 | #include "stm32h7xx_hal_def.h"
30 | 
31 | /** @addtogroup STM32H7xx_HAL_Driver
32 |   * @{
33 |   */
34 | 
35 | /** @addtogroup SPIEx
36 |   * @{
37 |   */
38 | 
39 | /* Exported types ------------------------------------------------------------*/
40 | /* Exported constants --------------------------------------------------------*/
41 | /* Exported macros -----------------------------------------------------------*/
42 | /* Exported functions --------------------------------------------------------*/
43 | /** @addtogroup SPIEx_Exported_Functions
44 |   * @{
45 |   */
46 | 
47 | /* Initialization and de-initialization functions  ****************************/
48 | /* IO operation functions *****************************************************/
49 | /** @addtogroup SPIEx_Exported_Functions_Group1
50 |   * @{
51 |   */
52 | HAL_StatusTypeDef HAL_SPIEx_FlushRxFifo(SPI_HandleTypeDef *hspi);
53 | HAL_StatusTypeDef HAL_SPIEx_EnableLockConfiguration(SPI_HandleTypeDef *hspi);
54 | HAL_StatusTypeDef HAL_SPIEx_ConfigureUnderrun(SPI_HandleTypeDef *hspi, uint32_t UnderrunDetection, uint32_t UnderrunBehaviour);
55 | /**
56 |   * @}
57 |   */
58 | 
59 | /**
60 |   * @}
61 |   */
62 | 
63 | /**
64 |   * @}
65 |   */
66 | 
67 | /**
68 |   * @}
69 |   */
70 | 
71 | #ifdef __cplusplus
72 | }
73 | #endif
74 | 
75 | #endif /* STM32H7xx_HAL_SPI_EX_H */
76 | 
77 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
78 | 


--------------------------------------------------------------------------------
/Core/Src/stm32h7xx_hal_msp.c:
--------------------------------------------------------------------------------
 1 | /* USER CODE BEGIN Header */
 2 | /**
 3 |   ******************************************************************************
 4 |   * @file         stm32h7xx_hal_msp.c
 5 |   * @brief        This file provides code for the MSP Initialization
 6 |   *               and de-Initialization codes.
 7 |   ******************************************************************************
 8 |   * @attention
 9 |   *
10 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
11 |   * All rights reserved.</center></h2>
12 |   *
13 |   * This software component is licensed by ST under BSD 3-Clause license,
14 |   * the "License"; You may not use this file except in compliance with the
15 |   * License. You may obtain a copy of the License at:
16 |   *                        opensource.org/licenses/BSD-3-Clause
17 |   *
18 |   ******************************************************************************
19 |   */
20 | /* USER CODE END Header */
21 | 
22 | /* Includes ------------------------------------------------------------------*/
23 | #include "main.h"
24 | /* USER CODE BEGIN Includes */
25 | 
26 | /* USER CODE END Includes */
27 | 
28 | /* Private typedef -----------------------------------------------------------*/
29 | /* USER CODE BEGIN TD */
30 | 
31 | /* USER CODE END TD */
32 | 
33 | /* Private define ------------------------------------------------------------*/
34 | /* USER CODE BEGIN Define */
35 | 
36 | /* USER CODE END Define */
37 | 
38 | /* Private macro -------------------------------------------------------------*/
39 | /* USER CODE BEGIN Macro */
40 | 
41 | /* USER CODE END Macro */
42 | 
43 | /* Private variables ---------------------------------------------------------*/
44 | /* USER CODE BEGIN PV */
45 | 
46 | /* USER CODE END PV */
47 | 
48 | /* Private function prototypes -----------------------------------------------*/
49 | /* USER CODE BEGIN PFP */
50 | 
51 | /* USER CODE END PFP */
52 | 
53 | /* External functions --------------------------------------------------------*/
54 | /* USER CODE BEGIN ExternalFunctions */
55 | 
56 | /* USER CODE END ExternalFunctions */
57 | 
58 | /* USER CODE BEGIN 0 */
59 | 
60 | /* USER CODE END 0 */
61 | /**
62 |   * Initializes the Global MSP.
63 |   */
64 | void HAL_MspInit(void)
65 | {
66 |   /* USER CODE BEGIN MspInit 0 */
67 | 
68 |   /* USER CODE END MspInit 0 */
69 | 
70 |   __HAL_RCC_SYSCFG_CLK_ENABLE();
71 | 
72 |   /* System interrupt init*/
73 | 
74 |   /* USER CODE BEGIN MspInit 1 */
75 | 
76 |   /* USER CODE END MspInit 1 */
77 | }
78 | 
79 | /* USER CODE BEGIN 1 */
80 | 
81 | /* USER CODE END 1 */
82 | 
83 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
84 | 


--------------------------------------------------------------------------------
/Core/Src/sensors/MagneticSensorSPI.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * MagneticSensorSPI.hpp
 3 |  *
 4 |  *  Created on: 25 Jun 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/master/src/sensors/MagneticSensorSPI.h
 6 |  */
 7 | 
 8 | 
 9 | #ifndef MAGNETICSENSORSPI_HPP_
10 | #define MAGNETICSENSORSPI_HPP_
11 | 
12 | #include "math.h"
13 | #include "stdint.h"
14 | #include "main.h"
15 | 
16 | #include "../common/base_classes/Sensor.hpp"
17 | #include "../common/foc_utils.h"
18 | #include "../common/time_utils.h"
19 | 
20 | //AS5048A datasheet: https://media.digikey.com/pdf/Data%20Sheets/Austriamicrosystems%20PDFs/AS5048A,B.pdf
21 | #define AS5048A_CPR 16384
22 | #define AS5048A_ANGLE_REG 0x3FFF
23 | #define AS5048A_ERROR_REG 0x0001
24 | #define AS5048A_PROGCTL_REG 0x0003
25 | #define AS5048A_OTPHIGH_REG 0x0016
26 | #define AS5048A_OTPLOW_REG 0x0017
27 | #define AS5048A_DIAGNOSTICS_REG 0x3FFD
28 | #define AS5048A_MAGNITUDE_REG 0x3FFE
29 | #define AS5048A_PARITY 0x8000
30 | #define AS5048A_RW 0x4000
31 | #define AS5048A_ERRFLG 0x4000
32 | #define AS5048A_RESULT_MASK 0x3FFF
33 | 
34 | class MagneticSensorSPI: public Sensor{
35 |  public:
36 |     /**
37 |      *  MagneticSensorSPI class constructor
38 |      * SPI chip select pin == D10 (PD14 on STM32H743)
39 |      * sensor resolution bit number == 14 for AS5048A magnetic sensor
40 |      * angle read register == 0x3FFF for AS5048A magnetic sensor,
41 |      * basically, this is a dummy constructor - to remind myself that am using magnetic sensor and not encoder or some other position sensor
42 |      */
43 |     MagneticSensorSPI(void);
44 | 
45 |     void init(void);
46 | 
47 |     // implementation of abstract functions of the Sensor class
48 |     /** get current angle (rad) */
49 |     float getAngle() override;
50 |     /** get current angular velocity (rad/s) **/
51 |     float getVelocity() override;
52 | 
53 | 
54 |   private:
55 |     float cpr = AS5048A_CPR; //!< Maximum range of the magnetic sensor
56 |     int angle_register = AS5048A_ANGLE_REG; //!< SPI angle register to read
57 |       /** Read one SPI register value */
58 |     uint16_t read(uint16_t angle_register);
59 |     /**
60 |      * Function getting current angle register value
61 |      * it uses angle_register variable
62 |      */
63 |     int getRawCount();
64 | 
65 |     // total angle tracking variables
66 |     float full_rotation_offset; //!<number of full rotations made
67 |     float angle_data_prev; //!< angle in previous position calculation step
68 | 
69 |     // velocity calculation variables
70 |     float angle_prev; //!< angle in previous velocity calculation step
71 |     long velocity_calc_timestamp; //!< last velocity calculation timestamp
72 | };
73 | 
74 | 
75 | #endif /* MAGNETICSENSORSPI_HPP_ */
76 | 


--------------------------------------------------------------------------------
/Core/Src/sensors/MagneticSensorSPI.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * MagneticSensorSPI.hpp
 3 |  *
 4 |  *  Created on: 25 Jun 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/master/src/sensors/MagneticSensorSPI.cpp
 6 |  */
 7 | 
 8 | #include "MagneticSensorSPI.hpp"
 9 | 
10 | // MagneticSensorSPI() //dummy constructor - just to remind myself that am using magnetic sensor, and not encoder
11 | MagneticSensorSPI::MagneticSensorSPI(void){
12 | }
13 | 
14 | //void MagneticSensorSPI::init(SPIClass* _spi){
15 | void MagneticSensorSPI::init(void) {
16 | 	// velocity calculation init
17 | 	angle_prev = 0;
18 | 	velocity_calc_timestamp = _micros();
19 | 
20 | 	// full rotations tracking number
21 | 	full_rotation_offset = 0;
22 | 	angle_data_prev = getRawCount();
23 | }
24 | 
25 | //  Shaft angle calculation
26 | //  angle is in radians [rad]
27 | float MagneticSensorSPI::getAngle(){
28 |   // raw data from the sensor
29 |   float angle_data = getRawCount();
30 | 
31 |   // tracking the number of rotations
32 |   // in order to expand angle range form [0,2PI]
33 |   // to basically infinity
34 |   float d_angle = angle_data - angle_data_prev;
35 |   // if overflow happened track it as full rotation
36 |   if(abs(d_angle) > (0.8*cpr) ) full_rotation_offset += d_angle > 0 ? -_2PI : _2PI;
37 |   // save the current angle value for the next steps
38 |   // in order to know if overflow happened
39 |   angle_data_prev = angle_data;
40 | 
41 |   // return the full angle
42 |   // (number of full rotations)*2PI + current sensor angle
43 |   return full_rotation_offset + ( angle_data / (float)cpr) * _2PI;
44 | }
45 | 
46 | // Shaft velocity calculation
47 | float MagneticSensorSPI::getVelocity(){
48 |   // calculate sample time
49 |   unsigned long now_us = _micros();
50 |   float Ts = (now_us - velocity_calc_timestamp)*1e-6;
51 |   // quick fix for strange cases (micros overflow)
52 |   if(Ts <= 0 || Ts > 0.5) Ts = 1e-3;
53 | 
54 |   // current angle
55 |   float angle_c = getAngle();
56 |   // velocity calculation
57 |   float vel = (angle_c - angle_prev)/Ts;
58 | 
59 |   // save variables for future pass
60 |   angle_prev = angle_c;
61 |   velocity_calc_timestamp = now_us;
62 |   return vel;
63 | }
64 | 
65 | 
66 | // function reading the raw counter of the magnetic sensor
67 | int MagneticSensorSPI::getRawCount(){
68 | 	return (int) MagneticSensorSPI::read(angle_register);
69 | }
70 | 
71 |   /*
72 |   * Read a register from the sensor
73 |   * Takes the address of the register as a 16 bit word
74 |   * Returns the value of the register
75 |   */
76 | uint16_t MagneticSensorSPI::read(uint16_t address_register){
77 | 	uint16_t command = address_register | AS5048A_PARITY | AS5048A_RW; // set r=1 and parity=1, result is 0xFFFF
78 | 	return _SPI_read(command)&AS5048A_RESULT_MASK;
79 | }
80 | 


--------------------------------------------------------------------------------
/Core/Src/common/base_classes/CurrentSense.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * CurrentSense.cpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/base_classes/CurrentSense.cpp
 6 |  */
 7 | 
 8 | #include "CurrentSense.hpp"
 9 | #include "main.h" //for debugging
10 | 
11 | // get current magnitude
12 | //   - absolute  - if no electrical_angle provided
13 | //   - signed    - if angle provided
14 | float CurrentSense::getDCCurrent(float motor_electrical_angle){
15 |     // read current phase currents
16 |     PhaseCurrent_s current = getPhaseCurrents();
17 |     // currnet sign - if motor angle not provided the magnitude is always positive
18 |     float sign = 1;
19 | 
20 |     // calculate clarke transform
21 |     float i_alpha, i_beta;
22 |     if(!current.c){
23 |         // if only two measured currents
24 |         i_alpha = current.a;
25 |         i_beta = _1_SQRT3 * current.a + _2_SQRT3 * current.b;
26 |     }else{
27 |         i_alpha = 2*(current.a - (current.b - current.c))/3.0;
28 |         i_beta = _2_SQRT3 *( current.b  - current.c );
29 |     }
30 | 
31 |     // if motor angle provided function returns signed value of the current
32 |     // determine the sign of the current
33 |     // sign(atan2(current.q, current.d)) is the same as c.q > 0 ? 1 : -1
34 |     if(motor_electrical_angle)
35 |         sign = (i_beta * _cos(motor_electrical_angle) - i_alpha*_sin(motor_electrical_angle)) > 0 ? 1 : -1;
36 |     // return current magnitude
37 |     return sign*_sqrt(i_alpha*i_alpha + i_beta*i_beta);
38 | }
39 | 
40 | // function used with the foc algorihtm
41 | //   calculating DQ currents from phase currents
42 | //   - function calculating park and clarke transform of the phase currents
43 | //   - using getPhaseCurrents internally
44 | DQCurrent_s CurrentSense::getFOCCurrents(float angle_el){
45 |     // read current phase currents
46 | 	//HAL_GPIO_WritePin(LD1_GPIO_Port, LD1_Pin, GPIO_PIN_SET); //debug for timing the FOC loop
47 |     PhaseCurrent_s current = getPhaseCurrents();
48 | 
49 |     // calculate clarke transform
50 |     float i_alpha, i_beta;
51 |     if(!current.c){
52 |         // if only two measured currents
53 |         i_alpha = current.a;
54 |         i_beta = _1_SQRT3 * current.a + _2_SQRT3 * current.b;
55 |     }else{
56 |         i_alpha = 0.6666667*(current.a - (current.b - current.c));
57 |         i_beta = _2_SQRT3 *( current.b  - current.c );
58 |     }
59 | 
60 |     // calculate park transform
61 |     float ct = _cos(angle_el);
62 |     float st = _sin(angle_el);
63 |     DQCurrent_s return_current;
64 |     return_current.d = i_alpha * ct + i_beta * st;
65 |     return_current.q = i_beta * ct - i_alpha * st;
66 | 	//HAL_GPIO_WritePin(LD1_GPIO_Port, LD1_Pin, GPIO_PIN_RESET); //debug for timing the FOC loop
67 |     return return_current;
68 | }
69 | 


--------------------------------------------------------------------------------
/Core/Src/common/base_classes/CurrentSense.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * CurrentSense.hpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/base_classes/CurrentSense.h
 6 |  */
 7 | 
 8 | #ifndef CURRENTSENSE_HPP_
 9 | #define CURRENTSENSE_HPP_
10 | 
11 | 
12 | #include "BLDCDriver.hpp"
13 | #include "../foc_utils.h"
14 | 
15 | /**
16 |  *  Current sensing abstract class definition
17 |  * Each current sensoring implementation needs to extend this interface
18 |  */
19 | class CurrentSense{
20 |     public:
21 | 
22 |     /**
23 |      *  Function intialising the CurrentSense class
24 |      *   All the necessary intialisations of adc and sync should be implemented here
25 |      */
26 |     virtual void init() = 0;
27 | 
28 |     /**
29 |      * Function intended to implement all that is needed to sync and current sensing with the driver.
30 |      * If no such thing is needed it can be left empty (return 1)
31 |      * @returns -  0 - for failure &  1 - for success
32 |      */
33 |     virtual int driverSync(BLDCDriver *driver) = 0;
34 | 
35 |     // calibration variables
36 |     bool skip_align = false; //!< variable signaling that the phase current direction should be verified during initFOC()
37 |     /**
38 |      * Function intended to verify if:
39 |      *   - phase current are oriented properly
40 |      *   - if their order is the same as driver phases
41 |      *
42 |      * This function corrects the alignment errors if possible ans if no such thing is needed it can be left empty (return 1)
43 |      * @returns -  0 - for failure &  positive number (with status) - for success
44 |      */
45 |     virtual int driverAlign(BLDCDriver *driver, float voltage) = 0;
46 | 
47 |     /**
48 |      *  Function reading the phase currents a, b and c
49 |      *   This function will be used with the foc control throughout the function
50 |      *   CurrentSense::getFOCCurrents(electrical_angle)
51 |      *   - it returns current c equal to 0 if only two phase measurements available
52 |      *
53 |      *  @return PhaseCurrent_s current values
54 |      */
55 |     virtual PhaseCurrent_s getPhaseCurrents() = 0;
56 |     /**
57 |      * Function reading the magnitude of the current set to the motor
58 |      *  It returns the absolute or signed magnitude if possible
59 |      *  It can receive the motor electrical angle to help with calculation
60 |      *  This function is used with the current control  (not foc)
61 |      *
62 |      * @param angle_el - electrical angle of the motor (optional)
63 |      */
64 |     virtual float getDCCurrent(float angle_el = 0);
65 | 
66 |     /**
67 |      * Function used for FOC control, it reads the DQ currents of the motor
68 |      *   It uses the function getPhaseCurrents internally
69 |      *
70 |      * @param angle_el - motor electrical angle
71 |      */
72 |     DQCurrent_s getFOCCurrents(float angle_el);
73 | };
74 | 
75 | 
76 | 
77 | #endif /* CURRENTSENSE_HPP_ */
78 | 


--------------------------------------------------------------------------------
/Drivers/CMSIS/Include/tz_context.h:
--------------------------------------------------------------------------------
 1 | /******************************************************************************
 2 |  * @file     tz_context.h
 3 |  * @brief    Context Management for Armv8-M TrustZone
 4 |  * @version  V1.0.1
 5 |  * @date     10. January 2018
 6 |  ******************************************************************************/
 7 | /*
 8 |  * Copyright (c) 2017-2018 Arm Limited. All rights reserved.
 9 |  *
10 |  * SPDX-License-Identifier: Apache-2.0
11 |  *
12 |  * Licensed under the Apache License, Version 2.0 (the License); you may
13 |  * not use this file except in compliance with the License.
14 |  * You may obtain a copy of the License at
15 |  *
16 |  * www.apache.org/licenses/LICENSE-2.0
17 |  *
18 |  * Unless required by applicable law or agreed to in writing, software
19 |  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
20 |  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21 |  * See the License for the specific language governing permissions and
22 |  * limitations under the License.
23 |  */
24 | 
25 | #if   defined ( __ICCARM__ )
26 |   #pragma system_include         /* treat file as system include file for MISRA check */
27 | #elif defined (__clang__)
28 |   #pragma clang system_header   /* treat file as system include file */
29 | #endif
30 | 
31 | #ifndef TZ_CONTEXT_H
32 | #define TZ_CONTEXT_H
33 |  
34 | #include <stdint.h>
35 |  
36 | #ifndef TZ_MODULEID_T
37 | #define TZ_MODULEID_T
38 | /// \details Data type that identifies secure software modules called by a process.
39 | typedef uint32_t TZ_ModuleId_t;
40 | #endif
41 |  
42 | /// \details TZ Memory ID identifies an allocated memory slot.
43 | typedef uint32_t TZ_MemoryId_t;
44 |   
45 | /// Initialize secure context memory system
46 | /// \return execution status (1: success, 0: error)
47 | uint32_t TZ_InitContextSystem_S (void);
48 |  
49 | /// Allocate context memory for calling secure software modules in TrustZone
50 | /// \param[in]  module   identifies software modules called from non-secure mode
51 | /// \return value != 0 id TrustZone memory slot identifier
52 | /// \return value 0    no memory available or internal error
53 | TZ_MemoryId_t TZ_AllocModuleContext_S (TZ_ModuleId_t module);
54 |  
55 | /// Free context memory that was previously allocated with \ref TZ_AllocModuleContext_S
56 | /// \param[in]  id  TrustZone memory slot identifier
57 | /// \return execution status (1: success, 0: error)
58 | uint32_t TZ_FreeModuleContext_S (TZ_MemoryId_t id);
59 |  
60 | /// Load secure context (called on RTOS thread context switch)
61 | /// \param[in]  id  TrustZone memory slot identifier
62 | /// \return execution status (1: success, 0: error)
63 | uint32_t TZ_LoadContext_S (TZ_MemoryId_t id);
64 |  
65 | /// Store secure context (called on RTOS thread context switch)
66 | /// \param[in]  id  TrustZone memory slot identifier
67 | /// \return execution status (1: success, 0: error)
68 | uint32_t TZ_StoreContext_S (TZ_MemoryId_t id);
69 |  
70 | #endif  // TZ_CONTEXT_H
71 | 


--------------------------------------------------------------------------------
/Drivers/CMSIS/Device/ST/STM32H7xx/Include/system_stm32h7xx.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |   ******************************************************************************
  3 |   * @file    system_stm32h7xx.h
  4 |   * @author  MCD Application Team
  5 |   * @brief   CMSIS Cortex-Mx Device System Source File for STM32H7xx devices.
  6 |   ******************************************************************************
  7 |   * @attention
  8 |   *
  9 |   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
 10 |   * All rights reserved.</center></h2>
 11 |   *
 12 |   * This software component is licensed by ST under BSD 3-Clause license,
 13 |   * the "License"; You may not use this file except in compliance with the
 14 |   * License. You may obtain a copy of the License at:
 15 |   *                        opensource.org/licenses/BSD-3-Clause
 16 |   *
 17 |   ******************************************************************************
 18 |   */
 19 | 
 20 | /** @addtogroup CMSIS
 21 |   * @{
 22 |   */
 23 | 
 24 | /** @addtogroup stm32h7xx_system
 25 |   * @{
 26 |   */
 27 | 
 28 | /**
 29 |   * @brief Define to prevent recursive inclusion
 30 |   */
 31 | #ifndef SYSTEM_STM32H7XX_H
 32 | #define SYSTEM_STM32H7XX_H
 33 | 
 34 | #ifdef __cplusplus
 35 |  extern "C" {
 36 | #endif
 37 | 
 38 | /** @addtogroup STM32H7xx_System_Includes
 39 |   * @{
 40 |   */
 41 | 
 42 | /**
 43 |   * @}
 44 |   */
 45 | 
 46 | 
 47 | /** @addtogroup STM32H7xx_System_Exported_types
 48 |   * @{
 49 |   */
 50 |   /* This variable is updated in three ways:
 51 |       1) by calling CMSIS function SystemCoreClockUpdate()
 52 |       2) by calling HAL API function HAL_RCC_GetSysClockFreq()
 53 |       3) each time HAL_RCC_ClockConfig() is called to configure the system clock frequency
 54 |          Note: If you use this function to configure the system clock; then there
 55 |                is no need to call the 2 first functions listed above, since SystemCoreClock
 56 |                variable is updated automatically.
 57 |   */
 58 | extern uint32_t SystemCoreClock;             /*!< System Domain1 Clock Frequency  */
 59 | extern uint32_t SystemD2Clock;               /*!< System Domain2 Clock Frequency  */
 60 | extern const  uint8_t D1CorePrescTable[16] ; /*!< D1CorePrescTable prescalers table values */
 61 | 
 62 | /**
 63 |   * @}
 64 |   */
 65 | 
 66 | /** @addtogroup STM32H7xx_System_Exported_Constants
 67 |   * @{
 68 |   */
 69 | 
 70 | /**
 71 |   * @}
 72 |   */
 73 | 
 74 | /** @addtogroup STM32H7xx_System_Exported_Macros
 75 |   * @{
 76 |   */
 77 | 
 78 | /**
 79 |   * @}
 80 |   */
 81 | 
 82 | /** @addtogroup STM32H7xx_System_Exported_Functions
 83 |   * @{
 84 |   */
 85 | 
 86 | extern void SystemInit(void);
 87 | extern void SystemCoreClockUpdate(void);
 88 | /**
 89 |   * @}
 90 |   */
 91 | 
 92 | #ifdef __cplusplus
 93 | }
 94 | #endif
 95 | 
 96 | #endif /* SYSTEM_STM32H7XX_H */
 97 | 
 98 | /**
 99 |   * @}
100 |   */
101 | 
102 | /**
103 |   * @}
104 |   */
105 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
106 | 


--------------------------------------------------------------------------------
/Core/Src/motor_drivers/BLDCDriver3PWM.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * BLDCDriver3PWM.cpp
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/drivers/BLDCDriver3PWM.cpp
 6 |  */
 7 | 
 8 | 
 9 | #include "BLDCDriver3PWM.hpp"
10 | #include "main.h"
11 | 
12 | BLDCDriver3PWM::BLDCDriver3PWM(int phA, int phB, int phC, int en1) {//, int en2, int en3){
13 |   // Pin initialization
14 |   pwmA = phA;
15 |   pwmB = phB;
16 |   pwmC = phC;
17 | 
18 |   // enable_pin pin
19 |   enableA_pin = en1;
20 | //  enableB_pin = en2;
21 | //  enableC_pin = en3;
22 | 
23 |   // default power-supply value
24 |   voltage_power_supply = DEF_POWER_SUPPLY;
25 |   voltage_limit = NOT_SET;
26 | 
27 | }
28 | 
29 | // enable motor driver
30 | void  BLDCDriver3PWM::enable(){
31 |     // enable_pin the driver - if enable_pin pin available
32 | 	HAL_GPIO_WritePin(Enable_Pin8_GPIO_Port, Enable_Pin8_Pin, GPIO_PIN_SET);
33 |     // set zero to PWM
34 |     setPwm(0,0,0);
35 | }
36 | 
37 | // disable motor driver
38 | void BLDCDriver3PWM::disable()
39 | {
40 |   // set zero to PWM
41 | 	setPwm(0, 0, 0);
42 | 	// disable the driver - if enable_pin pin available
43 | 	HAL_GPIO_WritePin(Enable_Pin8_GPIO_Port, Enable_Pin8_Pin, GPIO_PIN_RESET);
44 | 
45 | }
46 | 
47 | // init hardware pins
48 | int BLDCDriver3PWM::init() {
49 | 	  // a bit of separation
50 | 	  _delay(1000);
51 | 
52 | 	//  // PWM pins
53 | 	//  pinMode(pwmA, OUTPUT);
54 | 	//  pinMode(pwmB, OUTPUT);
55 | 	//  pinMode(pwmC, OUTPUT);
56 | 	//  if( _isset(enableA_pin)) pinMode(enableA_pin, OUTPUT);
57 | 
58 | 
59 | 	  // sanity check for the voltage limit configuration
60 | 	  if(voltage_limit == NOT_SET || voltage_limit > voltage_power_supply) voltage_limit =  voltage_power_supply;
61 | 
62 | 	  // Set the pwm frequency to the pins
63 | 	  // hardware specific function - depending on driver and mcu
64 | 	 // _configure3PWM(pwm_frequency, pwmA, pwmB, pwmC);
65 | 	  return 0;
66 | }
67 | 
68 | 
69 | 
70 | //// Set voltage to the pwm pin
71 | //void BLDCDriver3PWM::setPhaseState(int sa, int sb, int sc) {
72 | //  // disable if needed
73 | //  if( _isset(enableA_pin) &&  _isset(enableB_pin)  && _isset(enableC_pin) ){
74 | //    digitalWrite(enableA_pin, sa == _HIGH_IMPEDANCE ? LOW : HIGH);
75 | //    digitalWrite(enableB_pin, sb == _HIGH_IMPEDANCE ? LOW : HIGH);
76 | //    digitalWrite(enableC_pin, sc == _HIGH_IMPEDANCE ? LOW : HIGH);
77 | //  }
78 | //}
79 | 
80 | // Set voltage to the pwm pin
81 | void BLDCDriver3PWM::setPwm(float Ua, float Ub, float Uc) {
82 | 
83 |   // limit the voltage in driver
84 |   Ua = _constrain(Ua, 0.0, voltage_limit);
85 |   Ub = _constrain(Ub, 0.0, voltage_limit);
86 |   Uc = _constrain(Uc, 0.0, voltage_limit);
87 |   // calculate duty cycle
88 |   // limited in [0,1]
89 |   dc_a = _constrain(Ua / voltage_power_supply, 0.0 , 1.0 );
90 |   dc_b = _constrain(Ub / voltage_power_supply, 0.0 , 1.0 );
91 |   dc_c = _constrain(Uc / voltage_power_supply, 0.0 , 1.0 );
92 | 
93 |   // hardware specific writing
94 |   // hardware specific function - depending on driver and mcu
95 |   _writeDutyCycle3PWM(dc_a, dc_b, dc_c, pwmA, pwmB, pwmC);
96 | }
97 | 


--------------------------------------------------------------------------------
/.settings/language.settings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 2 | <project>
 3 |     	
 4 |     <configuration id="com.st.stm32cube.ide.mcu.gnu.managedbuild.config.exe.debug.1460927330" name="Debug">
 5 |         		
 6 |         <extension point="org.eclipse.cdt.core.LanguageSettingsProvider">
 7 |             			
 8 |             <provider-reference id="org.eclipse.cdt.ui.UserLanguageSettingsProvider" ref="shared-provider"/>
 9 |             			
10 |             <provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
11 |             			
12 |             <provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
13 |             			
14 |             <provider copy-of="extension" id="org.eclipse.cdt.managedbuilder.core.GCCBuildCommandParser"/>
15 |             			
16 |             <provider class="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" console="false" env-hash="1326562850409376214" id="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" keep-relative-paths="false" name="MCU ARM GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
17 |                 				
18 |                 <language-scope id="org.eclipse.cdt.core.gcc"/>
19 |                 				
20 |                 <language-scope id="org.eclipse.cdt.core.g++"/>
21 |                 			
22 |             </provider>
23 |             		
24 |         </extension>
25 |         	
26 |     </configuration>
27 |     	
28 |     <configuration id="com.st.stm32cube.ide.mcu.gnu.managedbuild.config.exe.release.1949917888" name="Release">
29 |         		
30 |         <extension point="org.eclipse.cdt.core.LanguageSettingsProvider">
31 |             			
32 |             <provider-reference id="org.eclipse.cdt.ui.UserLanguageSettingsProvider" ref="shared-provider"/>
33 |             			
34 |             <provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
35 |             			
36 |             <provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
37 |             			
38 |             <provider copy-of="extension" id="org.eclipse.cdt.managedbuilder.core.GCCBuildCommandParser"/>
39 |             			
40 |             <provider class="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" console="false" env-hash="1326562850409376214" id="com.st.stm32cube.ide.mcu.toolchain.armnone.setup.CrossBuiltinSpecsDetector" keep-relative-paths="false" name="MCU ARM GCC Built-in Compiler Settings" parameter="${COMMAND} ${FLAGS} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
41 |                 				
42 |                 <language-scope id="org.eclipse.cdt.core.gcc"/>
43 |                 				
44 |                 <language-scope id="org.eclipse.cdt.core.g++"/>
45 |                 			
46 |             </provider>
47 |             		
48 |         </extension>
49 |         	
50 |     </configuration>
51 |     
52 | </project>
53 | 


--------------------------------------------------------------------------------
/Core/Src/sysmem.c:
--------------------------------------------------------------------------------
 1 | /**
 2 |  ******************************************************************************
 3 |  * @file      sysmem.c
 4 |  * @author    Generated by STM32CubeIDE
 5 |  * @brief     STM32CubeIDE System Memory calls file
 6 |  *
 7 |  *            For more information about which C functions
 8 |  *            need which of these lowlevel functions
 9 |  *            please consult the newlib libc manual
10 |  ******************************************************************************
11 |  * @attention
12 |  *
13 |  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
14 |  * All rights reserved.</center></h2>
15 |  *
16 |  * This software component is licensed by ST under BSD 3-Clause license,
17 |  * the "License"; You may not use this file except in compliance with the
18 |  * License. You may obtain a copy of the License at:
19 |  *                        opensource.org/licenses/BSD-3-Clause
20 |  *
21 |  ******************************************************************************
22 |  */
23 | 
24 | /* Includes */
25 | #include <errno.h>
26 | #include <stdint.h>
27 | 
28 | /**
29 |  * Pointer to the current high watermark of the heap usage
30 |  */
31 | static uint8_t *__sbrk_heap_end = NULL;
32 | 
33 | /**
34 |  * @brief _sbrk() allocates memory to the newlib heap and is used by malloc
35 |  *        and others from the C library
36 |  *
37 |  * @verbatim
38 |  * ############################################################################
39 |  * #  .data  #  .bss  #       newlib heap       #          MSP stack          #
40 |  * #         #        #                         # Reserved by _Min_Stack_Size #
41 |  * ############################################################################
42 |  * ^-- RAM start      ^-- _end                             _estack, RAM end --^
43 |  * @endverbatim
44 |  *
45 |  * This implementation starts allocating at the '_end' linker symbol
46 |  * The '_Min_Stack_Size' linker symbol reserves a memory for the MSP stack
47 |  * The implementation considers '_estack' linker symbol to be RAM end
48 |  * NOTE: If the MSP stack, at any point during execution, grows larger than the
49 |  * reserved size, please increase the '_Min_Stack_Size'.
50 |  *
51 |  * @param incr Memory size
52 |  * @return Pointer to allocated memory
53 |  */
54 | void *_sbrk(ptrdiff_t incr)
55 | {
56 |   extern uint8_t _end; /* Symbol defined in the linker script */
57 |   extern uint8_t _estack; /* Symbol defined in the linker script */
58 |   extern uint32_t _Min_Stack_Size; /* Symbol defined in the linker script */
59 |   const uint32_t stack_limit = (uint32_t)&_estack - (uint32_t)&_Min_Stack_Size;
60 |   const uint8_t *max_heap = (uint8_t *)stack_limit;
61 |   uint8_t *prev_heap_end;
62 | 
63 |   /* Initialize heap end at first call */
64 |   if (NULL == __sbrk_heap_end)
65 |   {
66 |     __sbrk_heap_end = &_end;
67 |   }
68 | 
69 |   /* Protect heap from growing into the reserved MSP stack */
70 |   if (__sbrk_heap_end + incr > max_heap)
71 |   {
72 |     errno = ENOMEM;
73 |     return (void *)-1;
74 |   }
75 | 
76 |   prev_heap_end = __sbrk_heap_end;
77 |   __sbrk_heap_end += incr;
78 | 
79 |   return (void *)prev_heap_end;
80 | }
81 | 


--------------------------------------------------------------------------------
/STM32CubeIDE/Application/User/Core/sysmem.c:
--------------------------------------------------------------------------------
 1 | /**
 2 |  ******************************************************************************
 3 |  * @file      sysmem.c
 4 |  * @author    Generated by STM32CubeIDE
 5 |  * @brief     STM32CubeIDE System Memory calls file
 6 |  *
 7 |  *            For more information about which C functions
 8 |  *            need which of these lowlevel functions
 9 |  *            please consult the newlib libc manual
10 |  ******************************************************************************
11 |  * @attention
12 |  *
13 |  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
14 |  * All rights reserved.</center></h2>
15 |  *
16 |  * This software component is licensed by ST under BSD 3-Clause license,
17 |  * the "License"; You may not use this file except in compliance with the
18 |  * License. You may obtain a copy of the License at:
19 |  *                        opensource.org/licenses/BSD-3-Clause
20 |  *
21 |  ******************************************************************************
22 |  */
23 | 
24 | /* Includes */
25 | #include <errno.h>
26 | #include <stdint.h>
27 | 
28 | /**
29 |  * Pointer to the current high watermark of the heap usage
30 |  */
31 | static uint8_t *__sbrk_heap_end = NULL;
32 | 
33 | /**
34 |  * @brief _sbrk() allocates memory to the newlib heap and is used by malloc
35 |  *        and others from the C library
36 |  *
37 |  * @verbatim
38 |  * ############################################################################
39 |  * #  .data  #  .bss  #       newlib heap       #          MSP stack          #
40 |  * #         #        #                         # Reserved by _Min_Stack_Size #
41 |  * ############################################################################
42 |  * ^-- RAM start      ^-- _end                             _estack, RAM end --^
43 |  * @endverbatim
44 |  *
45 |  * This implementation starts allocating at the '_end' linker symbol
46 |  * The '_Min_Stack_Size' linker symbol reserves a memory for the MSP stack
47 |  * The implementation considers '_estack' linker symbol to be RAM end
48 |  * NOTE: If the MSP stack, at any point during execution, grows larger than the
49 |  * reserved size, please increase the '_Min_Stack_Size'.
50 |  *
51 |  * @param incr Memory size
52 |  * @return Pointer to allocated memory
53 |  */
54 | void *_sbrk(ptrdiff_t incr)
55 | {
56 |   extern uint8_t _end; /* Symbol defined in the linker script */
57 |   extern uint8_t _estack; /* Symbol defined in the linker script */
58 |   extern uint32_t _Min_Stack_Size; /* Symbol defined in the linker script */
59 |   const uint32_t stack_limit = (uint32_t)&_estack - (uint32_t)&_Min_Stack_Size;
60 |   const uint8_t *max_heap = (uint8_t *)stack_limit;
61 |   uint8_t *prev_heap_end;
62 | 
63 |   /* Initialize heap end at first call */
64 |   if (NULL == __sbrk_heap_end)
65 |   {
66 |     __sbrk_heap_end = &_end;
67 |   }
68 | 
69 |   /* Protect heap from growing into the reserved MSP stack */
70 |   if (__sbrk_heap_end + incr > max_heap)
71 |   {
72 |     errno = ENOMEM;
73 |     return (void *)-1;
74 |   }
75 | 
76 |   prev_heap_end = __sbrk_heap_end;
77 |   __sbrk_heap_end += incr;
78 | 
79 |   return (void *)prev_heap_end;
80 | }
81 | 


--------------------------------------------------------------------------------
/Core/Src/syscalls.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |  ******************************************************************************
  3 |  * @file      syscalls.c
  4 |  * @author    Auto-generated by STM32CubeIDE
  5 |  * @brief     STM32CubeIDE Minimal System calls file
  6 |  *
  7 |  *            For more information about which c-functions
  8 |  *            need which of these lowlevel functions
  9 |  *            please consult the Newlib libc-manual
 10 |  ******************************************************************************
 11 |  * @attention
 12 |  *
 13 |  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
 14 |  * All rights reserved.</center></h2>
 15 |  *
 16 |  * This software component is licensed by ST under BSD 3-Clause license,
 17 |  * the "License"; You may not use this file except in compliance with the
 18 |  * License. You may obtain a copy of the License at:
 19 |  *                        opensource.org/licenses/BSD-3-Clause
 20 |  *
 21 |  ******************************************************************************
 22 |  */
 23 | 
 24 | /* Includes */
 25 | #include <sys/stat.h>
 26 | #include <stdlib.h>
 27 | #include <errno.h>
 28 | #include <stdio.h>
 29 | #include <signal.h>
 30 | #include <time.h>
 31 | #include <sys/time.h>
 32 | #include <sys/times.h>
 33 | 
 34 | 
 35 | /* Variables */
 36 | //#undef errno
 37 | extern int errno;
 38 | extern int __io_putchar(int ch) __attribute__((weak));
 39 | extern int __io_getchar(void) __attribute__((weak));
 40 | 
 41 | register char * stack_ptr asm("sp");
 42 | 
 43 | char *__env[1] = { 0 };
 44 | char **environ = __env;
 45 | 
 46 | 
 47 | /* Functions */
 48 | void initialise_monitor_handles()
 49 | {
 50 | }
 51 | 
 52 | int _getpid(void)
 53 | {
 54 | 	return 1;
 55 | }
 56 | 
 57 | int _kill(int pid, int sig)
 58 | {
 59 | 	errno = EINVAL;
 60 | 	return -1;
 61 | }
 62 | 
 63 | void _exit (int status)
 64 | {
 65 | 	_kill(status, -1);
 66 | 	while (1) {}		/* Make sure we hang here */
 67 | }
 68 | 
 69 | __attribute__((weak)) int _read(int file, char *ptr, int len)
 70 | {
 71 | 	int DataIdx;
 72 | 
 73 | 	for (DataIdx = 0; DataIdx < len; DataIdx++)
 74 | 	{
 75 | 		*ptr++ = __io_getchar();
 76 | 	}
 77 | 
 78 | return len;
 79 | }
 80 | 
 81 | __attribute__((weak)) int _write(int file, char *ptr, int len)
 82 | {
 83 | 	int DataIdx;
 84 | 
 85 | 	for (DataIdx = 0; DataIdx < len; DataIdx++)
 86 | 	{
 87 | 		__io_putchar(*ptr++);
 88 | 	}
 89 | 	return len;
 90 | }
 91 | 
 92 | int _close(int file)
 93 | {
 94 | 	return -1;
 95 | }
 96 | 
 97 | 
 98 | int _fstat(int file, struct stat *st)
 99 | {
100 | 	st->st_mode = S_IFCHR;
101 | 	return 0;
102 | }
103 | 
104 | int _isatty(int file)
105 | {
106 | 	return 1;
107 | }
108 | 
109 | int _lseek(int file, int ptr, int dir)
110 | {
111 | 	return 0;
112 | }
113 | 
114 | int _open(char *path, int flags, ...)
115 | {
116 | 	/* Pretend like we always fail */
117 | 	return -1;
118 | }
119 | 
120 | int _wait(int *status)
121 | {
122 | 	errno = ECHILD;
123 | 	return -1;
124 | }
125 | 
126 | int _unlink(char *name)
127 | {
128 | 	errno = ENOENT;
129 | 	return -1;
130 | }
131 | 
132 | int _times(struct tms *buf)
133 | {
134 | 	return -1;
135 | }
136 | 
137 | int _stat(char *file, struct stat *st)
138 | {
139 | 	st->st_mode = S_IFCHR;
140 | 	return 0;
141 | }
142 | 
143 | int _link(char *old, char *new)
144 | {
145 | 	errno = EMLINK;
146 | 	return -1;
147 | }
148 | 
149 | int _fork(void)
150 | {
151 | 	errno = EAGAIN;
152 | 	return -1;
153 | }
154 | 
155 | int _execve(char *name, char **argv, char **env)
156 | {
157 | 	errno = ENOMEM;
158 | 	return -1;
159 | }
160 | 


--------------------------------------------------------------------------------
/STM32CubeIDE/Application/User/Core/syscalls.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |  ******************************************************************************
  3 |  * @file      syscalls.c
  4 |  * @author    Auto-generated by STM32CubeIDE
  5 |  * @brief     STM32CubeIDE Minimal System calls file
  6 |  *
  7 |  *            For more information about which c-functions
  8 |  *            need which of these lowlevel functions
  9 |  *            please consult the Newlib libc-manual
 10 |  ******************************************************************************
 11 |  * @attention
 12 |  *
 13 |  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
 14 |  * All rights reserved.</center></h2>
 15 |  *
 16 |  * This software component is licensed by ST under BSD 3-Clause license,
 17 |  * the "License"; You may not use this file except in compliance with the
 18 |  * License. You may obtain a copy of the License at:
 19 |  *                        opensource.org/licenses/BSD-3-Clause
 20 |  *
 21 |  ******************************************************************************
 22 |  */
 23 | 
 24 | /* Includes */
 25 | #include <sys/stat.h>
 26 | #include <stdlib.h>
 27 | #include <errno.h>
 28 | #include <stdio.h>
 29 | #include <signal.h>
 30 | #include <time.h>
 31 | #include <sys/time.h>
 32 | #include <sys/times.h>
 33 | 
 34 | 
 35 | /* Variables */
 36 | //#undef errno
 37 | extern int errno;
 38 | extern int __io_putchar(int ch) __attribute__((weak));
 39 | extern int __io_getchar(void) __attribute__((weak));
 40 | 
 41 | register char * stack_ptr asm("sp");
 42 | 
 43 | char *__env[1] = { 0 };
 44 | char **environ = __env;
 45 | 
 46 | 
 47 | /* Functions */
 48 | void initialise_monitor_handles()
 49 | {
 50 | }
 51 | 
 52 | int _getpid(void)
 53 | {
 54 | 	return 1;
 55 | }
 56 | 
 57 | int _kill(int pid, int sig)
 58 | {
 59 | 	errno = EINVAL;
 60 | 	return -1;
 61 | }
 62 | 
 63 | void _exit (int status)
 64 | {
 65 | 	_kill(status, -1);
 66 | 	while (1) {}		/* Make sure we hang here */
 67 | }
 68 | 
 69 | __attribute__((weak)) int _read(int file, char *ptr, int len)
 70 | {
 71 | 	int DataIdx;
 72 | 
 73 | 	for (DataIdx = 0; DataIdx < len; DataIdx++)
 74 | 	{
 75 | 		*ptr++ = __io_getchar();
 76 | 	}
 77 | 
 78 | return len;
 79 | }
 80 | 
 81 | __attribute__((weak)) int _write(int file, char *ptr, int len)
 82 | {
 83 | 	int DataIdx;
 84 | 
 85 | 	for (DataIdx = 0; DataIdx < len; DataIdx++)
 86 | 	{
 87 | 		__io_putchar(*ptr++);
 88 | 	}
 89 | 	return len;
 90 | }
 91 | 
 92 | int _close(int file)
 93 | {
 94 | 	return -1;
 95 | }
 96 | 
 97 | 
 98 | int _fstat(int file, struct stat *st)
 99 | {
100 | 	st->st_mode = S_IFCHR;
101 | 	return 0;
102 | }
103 | 
104 | int _isatty(int file)
105 | {
106 | 	return 1;
107 | }
108 | 
109 | int _lseek(int file, int ptr, int dir)
110 | {
111 | 	return 0;
112 | }
113 | 
114 | int _open(char *path, int flags, ...)
115 | {
116 | 	/* Pretend like we always fail */
117 | 	return -1;
118 | }
119 | 
120 | int _wait(int *status)
121 | {
122 | 	errno = ECHILD;
123 | 	return -1;
124 | }
125 | 
126 | int _unlink(char *name)
127 | {
128 | 	errno = ENOENT;
129 | 	return -1;
130 | }
131 | 
132 | int _times(struct tms *buf)
133 | {
134 | 	return -1;
135 | }
136 | 
137 | int _stat(char *file, struct stat *st)
138 | {
139 | 	st->st_mode = S_IFCHR;
140 | 	return 0;
141 | }
142 | 
143 | int _link(char *old, char *new)
144 | {
145 | 	errno = EMLINK;
146 | 	return -1;
147 | }
148 | 
149 | int _fork(void)
150 | {
151 | 	errno = EAGAIN;
152 | 	return -1;
153 | }
154 | 
155 | int _execve(char *name, char **argv, char **env)
156 | {
157 | 	errno = ENOMEM;
158 | 	return -1;
159 | }
160 | 


--------------------------------------------------------------------------------
/Core/Src/sensors/Encoder.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Encoder.hpp
  3 |  *
  4 |  *  Created on: 23 Mar 2021
  5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/sensors/Encoder.h
  6 |  */
  7 | 
  8 | #ifndef ENCODER_HPP_
  9 | #define ENCODER_HPP_
 10 | 
 11 | 
 12 | #include "../common/foc_utils.h"
 13 | #include "../common/time_utils.h"
 14 | #include "main.h"
 15 | #include "../common/base_classes/Sensor.hpp"
 16 | 
 17 | /**
 18 |  *  Quadrature mode configuration structure
 19 |  */
 20 | enum Quadrature{
 21 |   ON, //!<  Enable quadrature mode CPR = 4xPPR
 22 |   OFF //!<  Disable quadrature mode / CPR = PPR
 23 | };
 24 | 
 25 | class Encoder: public Sensor{
 26 |  public:
 27 |     /**
 28 |     Encoder class constructor
 29 |     @param encA  encoder B pin
 30 |     @param encB  encoder B pin
 31 |     @param ppr  impulses per rotation  (cpr=ppr*4)
 32 |     @param index index pin number (optional input)
 33 |     */
 34 |     Encoder(int encA, int encB , float ppr, int index = 0);
 35 | 
 36 |     /** encoder initialise pins */
 37 |     void init();
 38 |     /**
 39 |      *  function enabling hardware interrupts for the encoder channels with provided callback functions
 40 |      *  if callback is not provided then the interrupt is not enabled
 41 |      *
 42 |      * @param doA pointer to the A channel interrupt handler function
 43 |      * @param doB pointer to the B channel interrupt handler function
 44 |      * @param doIndex pointer to the Index channel interrupt handler function
 45 |      *
 46 |      */
 47 |     void enableInterrupts(void (*doA)() = nullptr, void(*doB)() = nullptr, void(*doIndex)() = nullptr);
 48 | 
 49 |     //  Encoder interrupt callback functions
 50 |     /** A channel callback function */
 51 |     void handleA();
 52 |     /** B channel callback function */
 53 |     void handleB();
 54 |     /** Index channel callback function */
 55 |     void handleIndex();
 56 | 
 57 | 
 58 |     // pins A and B
 59 |     int pinA; //!< encoder hardware pin A
 60 |     int pinB; //!< encoder hardware pin B
 61 |     int index_pin; //!< index pin
 62 | 
 63 |     // Encoder configuration
 64 |     Pullup pullup; //!< Configuration parameter internal or external pullups
 65 |     Quadrature quadrature;//!< Configuration parameter enable or disable quadrature mode
 66 |     float cpr;//!< encoder cpr number
 67 | 
 68 |     // Abstract functions of the Sensor class implementation
 69 |     /** get current angle (rad) */
 70 |     float getAngle() override;
 71 |     /**  get current angular velocity (rad/s) */
 72 |     float getVelocity() override;
 73 |     /**
 74 |      * returns 0 if it does need search for absolute zero
 75 |      * 0 - encoder without index
 76 |      * 1 - ecoder with index
 77 |      */
 78 |     int needsSearch() override;
 79 | 
 80 |     void setAngle(float) override; //NAT
 81 | 
 82 |   private:
 83 |     int hasIndex(); //!< function returning 1 if encoder has index pin and 0 if not.
 84 | 
 85 |     volatile long pulse_counter;//!< current pulse counter
 86 |     volatile long pulse_timestamp;//!< last impulse timestamp in us
 87 |     volatile int A_active; //!< current active states of A channel
 88 |     volatile int B_active; //!< current active states of B channel
 89 |     volatile int I_active; //!< current active states of Index channel
 90 |     volatile bool index_found = false; //!< flag stating that the index has been found
 91 | 
 92 |     // velocity calculation variables
 93 |     float prev_Th, pulse_per_second;
 94 |     volatile long prev_pulse_counter, prev_timestamp_us;
 95 | };
 96 | 
 97 | 
 98 | 
 99 | 
100 | #endif /* ENCODER_HPP_ */
101 | 


--------------------------------------------------------------------------------
/Core/Inc/main.h:
--------------------------------------------------------------------------------
  1 | /* USER CODE BEGIN Header */
  2 | /**
  3 |   ******************************************************************************
  4 |   * @file           : main.h
  5 |   * @brief          : Header for main.c file.
  6 |   *                   This file contains the common defines of the application.
  7 |   ******************************************************************************
  8 |   * @attention
  9 |   *
 10 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
 11 |   * All rights reserved.</center></h2>
 12 |   *
 13 |   * This software component is licensed by ST under BSD 3-Clause license,
 14 |   * the "License"; You may not use this file except in compliance with the
 15 |   * License. You may obtain a copy of the License at:
 16 |   *                        opensource.org/licenses/BSD-3-Clause
 17 |   *
 18 |   ******************************************************************************
 19 |   */
 20 | /* USER CODE END Header */
 21 | 
 22 | /* Define to prevent recursive inclusion -------------------------------------*/
 23 | #ifndef __MAIN_H
 24 | #define __MAIN_H
 25 | 
 26 | #ifdef __cplusplus
 27 | extern "C" {
 28 | #endif
 29 | 
 30 | /* Includes ------------------------------------------------------------------*/
 31 | #include "stm32h7xx_hal.h"
 32 | 
 33 | /* Private includes ----------------------------------------------------------*/
 34 | /* USER CODE BEGIN Includes */
 35 | 
 36 | /* USER CODE END Includes */
 37 | 
 38 | /* Exported types ------------------------------------------------------------*/
 39 | /* USER CODE BEGIN ET */
 40 | 
 41 | /* USER CODE END ET */
 42 | 
 43 | /* Exported constants --------------------------------------------------------*/
 44 | /* USER CODE BEGIN EC */
 45 | 
 46 | /* USER CODE END EC */
 47 | 
 48 | /* Exported macro ------------------------------------------------------------*/
 49 | /* USER CODE BEGIN EM */
 50 | 
 51 | /* USER CODE END EM */
 52 | 
 53 | /* Exported functions prototypes ---------------------------------------------*/
 54 | void Error_Handler(void);
 55 | 
 56 | /* USER CODE BEGIN EFP */
 57 | void _writeDutyCycle3PWM(float dc_a,  float dc_b, float dc_c, int pinA, int pinB, int pinC);
 58 | float _readADCVoltage_pinA(void);
 59 | float _readADCVoltage_pinB(void);
 60 | int _calibrate_phaseA(void);
 61 | int _calibrate_phaseB(void);
 62 | uint16_t _SPI_read(uint16_t _spi_data);
 63 | /* USER CODE END EFP */
 64 | 
 65 | /* Private defines -----------------------------------------------------------*/
 66 | #define B1_Pin GPIO_PIN_13
 67 | #define B1_GPIO_Port GPIOC
 68 | #define Enable_Pin8_Pin GPIO_PIN_3
 69 | #define Enable_Pin8_GPIO_Port GPIOF
 70 | #define Current_PhaseB_A2_Pin GPIO_PIN_3
 71 | #define Current_PhaseB_A2_GPIO_Port GPIOC
 72 | #define Current_PhaseB_A0_Pin GPIO_PIN_3
 73 | #define Current_PhaseB_A0_GPIO_Port GPIOA
 74 | #define LD1_Pin GPIO_PIN_0
 75 | #define LD1_GPIO_Port GPIOB
 76 | #define PWMC_Pin6_Pin GPIO_PIN_9
 77 | #define PWMC_Pin6_GPIO_Port GPIOE
 78 | #define PWMB_Pin5_Pin GPIO_PIN_11
 79 | #define PWMB_Pin5_GPIO_Port GPIOE
 80 | #define EncoderAU_Pin3_Pin GPIO_PIN_13
 81 | #define EncoderAU_Pin3_GPIO_Port GPIOE
 82 | #define EncoderAU_Pin3_EXTI_IRQn EXTI15_10_IRQn
 83 | #define PWMA_Pin9_Pin GPIO_PIN_14
 84 | #define PWMA_Pin9_GPIO_Port GPIOE
 85 | #define LD3_Pin GPIO_PIN_14
 86 | #define LD3_GPIO_Port GPIOB
 87 | #define SPI1_CS_Pin GPIO_PIN_14
 88 | #define SPI1_CS_GPIO_Port GPIOD
 89 | #define EncoderBV_Pin2_Pin GPIO_PIN_14
 90 | #define EncoderBV_Pin2_GPIO_Port GPIOG
 91 | #define EncoderBV_Pin2_EXTI_IRQn EXTI15_10_IRQn
 92 | #define EncoderIW_Pin11_Pin GPIO_PIN_5
 93 | #define EncoderIW_Pin11_GPIO_Port GPIOB
 94 | #define EncoderIW_Pin11_EXTI_IRQn EXTI9_5_IRQn
 95 | #define LD2_Pin GPIO_PIN_1
 96 | #define LD2_GPIO_Port GPIOE
 97 | /* USER CODE BEGIN Private defines */
 98 | #define phaseA 1
 99 | #define phaseB 2
100 | /* USER CODE END Private defines */
101 | 
102 | #ifdef __cplusplus
103 | }
104 | #endif
105 | 
106 | #endif /* __MAIN_H */
107 | 
108 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
109 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # STM32_SimpleFOC_InlineCurrentSense
 2 | [UPDATE 30/06/21]: Added support for AS5048A position sensor.
 3 | 
 4 | 
 5 | 
 6 | Port of the SimpleFOC code to STM32 environment. (Original code here: https://github.com/simplefoc/Arduino-FOC/tree/v2.1)
 7 | 
 8 | Current hardware used:
 9 | 
10 | * Nucleo-H743ZI2,  caution board number is: MB1364, which means the correct user manual is: 
11 |   https://www.st.com/resource/en/user_manual/dm00499160-stm32h7-nucleo144-boards-mb1364-stmicroelectronics.pdf
12 | * SimpleFOCShield v2.0.2
13 | * Motor: low resistance (39mOhm phase resistance) [D5065](https://odriverobotics.com/shop/odrive-custom-motor-d5065) with 7 pole pairs
14 | * Motor: gimbal iPower [GM2804 with AS5048A](https://shop.iflight-rc.com/ipower-gm2804-gimbal-motor-with-as5048a-encoder-pro288) encoder
15 | 
16 | 
17 | 
18 | SimpleFOCShield is configured with the following connections: 
19 | 
20 | | Signal                 | Arduino pin name            | STM32 pin name | Function    |
21 | | ---------------------- | --------------------------- | -------------- | ----------- |
22 | | PWM A                  | 9 (**broken off, see below) | PE14           | TIM1(CH4)   |
23 | | PWM B                  | 5                           | PE11           | TIM1(CH2)   |
24 | | PWM C                  | 6                           | PE9            | TIM1(CH1)   |
25 | | Enable                 | 8                           | PF3            | GPIO_Output |
26 | | Encoder A              | 3                           | PE13           | GPIO_EXTI3  |
27 | | Encoder B              | 2                           | PG14           | GPIO_EXTI14 |
28 | | Encoder Idx            | 11                          | PB5            | GPIO_EXTI5  |
29 | | Phase A                | A0                          | PA3            | ADC1_INP15  |
30 | | Phase B                | A2                          | PC3_c          | ADC3_INP1   |
31 | | SCK (CLK to SPI slave) | D13                         | PA5            | SPI1_CLK    |
32 | | MISO                   | D12                         | PA6            | SPI1_MISO   |
33 | | MOSI                   | n/a (*** can't use D11)     | PA7            | SPI1_MOSI   |
34 | | CS (chip select)       | D10                         | PD14           | SPI1_CS     |
35 | | Range                  | (3.3V)                      | n/a            | n/a         |
36 | | Enable 8V regulator    | (true)                      | n/a            | n/a         |
37 | 
38 | ** In order to route the TIM1(CH4) PWM signal which is configure to be output onto pin PE14 of the STM board, pin 9 on the SimpleFOC shield is removed and a jumper lead is used to Arduino pin D4 to Arduino pin D9. 
39 | 
40 | *** On Arduino SPI for MOSI would be D11. In our setup EncoderIdx uses this pin. So we route SPI1 MOSI to PA7 of STM32H743 chip instead. For this to work we need to remove the D11 pin from SimpleFOC shield - in the same way we broke off pin9. 
41 | 
42 | Issues:
43 | 
44 | * [Resolved] phase current measurement is not accurate, hence cannot use true FOC
45 |   - current limit has to be set ~1-2Amps, and the PID parameters of the Q/D current loops need to be adjusted to accommodate a low-resistance motor. Table included [here](https://community.simplefoc.com/t/simplefoc-v2-understanding-sensor-align/806/22) records working values. 
46 | 
47 | 
48 | Improvements to be made:
49 | 
50 | * avoid pulse_counter overflow. Count number of rotations, and keep pulse_counter between 0 - CPR
51 | 
52 | * switch to dedicated timer hardware for encoder pulse count. Requires hardware signal re-routing
53 | 
54 | * implement cogging torque measurements in voltage mode
55 | 
56 | 
57 | Unresolved questions:
58 | * operating in FOC position control, encoder pulse counter does not increment properly when motor is externally pushed out of position. Hence, motor can be successfully pushed away from target position set point. Would expect this not to happen
59 | * regeneration support
60 | * bandwidth of control loop - probably affects the maximum update position rate
61 | 
62 | 
63 | 
64 | TODO:
65 | 
66 | * simulate motion of engine under external combustion torques with pre-defined position changes
67 | * update enclosure design to fit onto motor shaft.
68 | 


--------------------------------------------------------------------------------
/Core/Src/common/foc_utils.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * foc_utils.c
 3 |  *
 4 |  *  Created on: 23 Mar 2021
 5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/foc_utils.cpp
 6 |  */
 7 | 
 8 | #include "foc_utils.h"
 9 | #include "math.h"
10 | // int array instead of float array
11 | // 4x200 points per 360 deg
12 | // 2x storage save (int 2Byte float 4 Byte )
13 | // sin*10000
14 | const int sine_array[200] = { 0, 79, 158, 237, 316, 395, 473, 552, 631, 710,
15 | 		789, 867, 946, 1024, 1103, 1181, 1260, 1338, 1416, 1494, 1572, 1650,
16 | 		1728, 1806, 1883, 1961, 2038, 2115, 2192, 2269, 2346, 2423, 2499, 2575,
17 | 		2652, 2728, 2804, 2879, 2955, 3030, 3105, 3180, 3255, 3329, 3404, 3478,
18 | 		3552, 3625, 3699, 3772, 3845, 3918, 3990, 4063, 4135, 4206, 4278, 4349,
19 | 		4420, 4491, 4561, 4631, 4701, 4770, 4840, 4909, 4977, 5046, 5113, 5181,
20 | 		5249, 5316, 5382, 5449, 5515, 5580, 5646, 5711, 5775, 5839, 5903, 5967,
21 | 		6030, 6093, 6155, 6217, 6279, 6340, 6401, 6461, 6521, 6581, 6640, 6699,
22 | 		6758, 6815, 6873, 6930, 6987, 7043, 7099, 7154, 7209, 7264, 7318, 7371,
23 | 		7424, 7477, 7529, 7581, 7632, 7683, 7733, 7783, 7832, 7881, 7930, 7977,
24 | 		8025, 8072, 8118, 8164, 8209, 8254, 8298, 8342, 8385, 8428, 8470, 8512,
25 | 		8553, 8594, 8634, 8673, 8712, 8751, 8789, 8826, 8863, 8899, 8935, 8970,
26 | 		9005, 9039, 9072, 9105, 9138, 9169, 9201, 9231, 9261, 9291, 9320, 9348,
27 | 		9376, 9403, 9429, 9455, 9481, 9506, 9530, 9554, 9577, 9599, 9621, 9642,
28 | 		9663, 9683, 9702, 9721, 9739, 9757, 9774, 9790, 9806, 9821, 9836, 9850,
29 | 		9863, 9876, 9888, 9899, 9910, 9920, 9930, 9939, 9947, 9955, 9962, 9969,
30 | 		9975, 9980, 9985, 9989, 9992, 9995, 9997, 9999, 10000, 10000 };
31 | 
32 | // function approximating the sine calculation by using fixed size array
33 | // ~40us (float array)
34 | // ~50us (int array)
35 | // precision +-0.005
36 | // it has to receive an angle in between 0 and 2PI
37 | float _sin(float a){
38 |   if(a < _PI_2){
39 |     //return sine_array[(int)(199.0*( a / (_PI/2.0)))];
40 |     //return sine_array[(int)(126.6873* a)];           // float array optimized
41 |     return 0.0001*sine_array[_round(126.6873* a)];      // int array optimized
42 |   }else if(a < _PI){
43 |     // return sine_array[(int)(199.0*(1.0 - (a-_PI/2.0) / (_PI/2.0)))];
44 |     //return sine_array[398 - (int)(126.6873*a)];          // float array optimized
45 |     return 0.0001*sine_array[398 - _round(126.6873*a)];     // int array optimized
46 |   }else if(a < _3PI_2){
47 |     // return -sine_array[(int)(199.0*((a - _PI) / (_PI/2.0)))];
48 |     //return -sine_array[-398 + (int)(126.6873*a)];           // float array optimized
49 |     return -0.0001*sine_array[-398 + _round(126.6873*a)];      // int array optimized
50 |   } else {
51 |     // return -sine_array[(int)(199.0*(1.0 - (a - 3*_PI/2) / (_PI/2.0)))];
52 |     //return -sine_array[796 - (int)(126.6873*a)];           // float array optimized
53 |     return -0.0001*sine_array[796 - _round(126.6873*a)];      // int array optimized
54 |   }
55 | }
56 | 
57 | // function approximating cosine calculation by using fixed size array
58 | // ~55us (float array)
59 | // ~56us (int array)
60 | // precision +-0.005
61 | // it has to receive an angle in between 0 and 2PI
62 | float _cos(float a){
63 |   float a_sin = a + _PI_2;
64 |   a_sin = a_sin > _2PI ? a_sin - _2PI : a_sin;
65 |   return _sin(a_sin);
66 | }
67 | 
68 | 
69 | // normalizing radian angle to [0,2PI]
70 | float _normalizeAngle(float angle){
71 |   float a = fmod(angle, _2PI);
72 |   return a >= 0 ? a : (a + _2PI);
73 | }
74 | 
75 | // Electrical angle calculation
76 | float _electricalAngle(float shaft_angle, int pole_pairs) {
77 |   return (shaft_angle * pole_pairs);
78 | }
79 | 
80 | // square root approximation function using
81 | // https://reprap.org/forum/read.php?147,219210
82 | // https://en.wikipedia.org/wiki/Fast_inverse_square_root
83 | float _sqrtApprox(float number) {//low in fat
84 |   long i;
85 |   float y;
86 |   // float x;
87 |   // const float f = 1.5F; // better precision
88 | 
89 |   // x = number * 0.5F;
90 |   y = number;
91 |   i = * ( long * ) &y;
92 |   i = 0x5f375a86 - ( i >> 1 );
93 |   y = * ( float * ) &i;
94 |   // y = y * ( f - ( x * y * y ) ); // better precision
95 |   return number * y;
96 | }
97 | 
98 | 


--------------------------------------------------------------------------------
/Core/Src/BLDCMotor.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * BLDCMotor.hpp
  3 |  *
  4 |  *  Created on: 23 Mar 2021
  5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/BLDCMotor.h
  6 |  */
  7 | 
  8 | #ifndef SRC_BLDCMOTOR_HPP_
  9 | #define SRC_BLDCMOTOR_HPP_
 10 | 
 11 | #include "common/base_classes/FOCMotor.hpp"
 12 | #include "common/base_classes/Sensor.hpp"
 13 | #include "common/base_classes/BLDCDriver.hpp"
 14 | #include "common/foc_utils.h"
 15 | #include "common/time_utils.h"
 16 | #include "common/defaults.h"
 17 | 
 18 | /**
 19 |  BLDC motor class
 20 | */
 21 | class BLDCMotor: public FOCMotor
 22 | {
 23 |   public:
 24 |     /**
 25 |      BLDCMotor class constructor
 26 |      @param pp pole pairs number
 27 |      @param R  motor phase resistance
 28 |      */
 29 |     BLDCMotor(int pp,  float R = NOT_SET);
 30 | 
 31 |     /**
 32 |      * Function linking a motor and a foc driver
 33 |      *
 34 |      * @param driver BLDCDriver class implementing all the hardware specific functions necessary PWM setting
 35 |      */
 36 |     void linkDriver(BLDCDriver* driver);
 37 | 
 38 |     /**
 39 |       * BLDCDriver link:
 40 |       * - 3PWM
 41 |       * - 6PWM
 42 |     */
 43 |     BLDCDriver* driver;
 44 | 
 45 |     /**  Motor hardware init function */
 46 |   	void init() override;
 47 |     /** Motor disable function */
 48 |   	void disable() override;
 49 |     /** Motor enable function */
 50 |     void enable() override;
 51 | 
 52 |     /**
 53 |      * Function initializing FOC algorithm
 54 |      * and aligning sensor's and motors' zero position
 55 |      */
 56 |     int initFOC( float zero_electric_offset = NOT_SET , Direction sensor_direction = Direction::CW) override;
 57 |     /**
 58 |      * Function running FOC algorithm in real-time
 59 |      * it calculates the gets motor angle and sets the appropriate voltages
 60 |      * to the phase pwm signals
 61 |      * - the faster you can run it the better Arduino UNO ~1ms, Bluepill ~ 100us
 62 |      */
 63 |     void loopFOC() override;
 64 | 
 65 |     /**
 66 |      * Function executing the control loops set by the controller parameter of the BLDCMotor.
 67 |      *
 68 |      * @param target  Either voltage, angle or velocity based on the motor.controller
 69 |      *                If it is not set the motor will use the target set in its variable motor.target
 70 |      *
 71 |      * This function doesn't need to be run upon each loop execution - depends of the use case
 72 |      */
 73 |     void move(float target = NOT_SET) override;
 74 | 
 75 |     float Ua, Ub, Uc;//!< Current phase voltages Ua,Ub and Uc set to motor
 76 |     float Ualpha, Ubeta; //!< Phase voltages U alpha and U beta used for inverse Park and Clarke transform
 77 | 
 78 |     /**
 79 |      * Anti-cogging calibration flag
 80 |      */
 81 |     bool anti_cogging;
 82 | 
 83 |   private:
 84 |     // FOC methods
 85 |     /**
 86 |     * Method using FOC to set Uq to the motor at the optimal angle
 87 |     * Heart of the FOC algorithm
 88 |     *
 89 |     * @param Uq Current voltage in q axis to set to the motor
 90 |     * @param Ud Current voltage in d axis to set to the motor
 91 |     * @param angle_el current electrical angle of the motor
 92 |     */
 93 |     void setPhaseVoltage(float Uq, float Ud, float angle_el);
 94 |     /** Sensor alignment to electrical 0 angle of the motor */
 95 |     int alignSensor();
 96 |     /** Current sense and motor phase alignment */
 97 |     int alignCurrentSense();
 98 |     /** Motor and sensor alignment to the sensors absolute 0 angle  */
 99 |     int absoluteZeroSearch();
100 | 
101 | 
102 |     // Open loop motion control
103 |     /**
104 |      * Function (iterative) generating open loop movement for target velocity
105 |      * it uses voltage_limit variable
106 |      *
107 |      * @param target_velocity - rad/s
108 |      */
109 |     float velocityOpenloop(float target_velocity);
110 |     /**
111 |      * Function (iterative) generating open loop movement towards the target angle
112 |      * it uses voltage_limit and velocity_limit variables
113 |      *
114 |      * @param target_angle - rad
115 |      */
116 |     float angleOpenloop(float target_angle);
117 |     // open loop variables
118 |     long open_loop_timestamp;
119 | 
120 |     //Anti-cogging calibration methods:
121 |     int antiCoggingCalibration();
122 | 
123 | };
124 | 
125 | 
126 | 
127 | 
128 | 
129 | #endif /* SRC_BLDCMOTOR_HPP_ */
130 | 


--------------------------------------------------------------------------------
/Core/Src/common/base_classes/FOCMotor.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * FOCMotor.cpp
  3 |  *
  4 |  *  Created on: 23 Mar 2021
  5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/common/base_classes/FOCMotor.cpp
  6 |  */
  7 | 
  8 | #include "FOCMotor.hpp"
  9 | /**
 10 |  * Default constructor - setting all variables to default values
 11 |  */
 12 | FOCMotor::FOCMotor()
 13 | {
 14 |   // maximum angular velocity to be used for positioning
 15 |   velocity_limit = DEF_VEL_LIM;
 16 |   // maximum voltage to be set to the motor
 17 |   voltage_limit = DEF_POWER_SUPPLY;
 18 |   // not set on the beginning
 19 |   current_limit = DEF_CURRENT_LIM;
 20 | 
 21 |   // index search velocity
 22 |   velocity_index_search = DEF_INDEX_SEARCH_TARGET_VELOCITY;
 23 |   // sensor and motor align voltage
 24 |   voltage_sensor_align = DEF_VOLTAGE_SENSOR_ALIGN;
 25 | 
 26 |   // default modulation is SinePWM
 27 |   foc_modulation = FOCModulationType::SinePWM;
 28 | 
 29 |   // default target value
 30 |   target = 0;
 31 |   voltage.d = 0;
 32 |   voltage.q = 0;
 33 |   // current target values
 34 |   current_sp = 0;
 35 |   current.q = 0;
 36 |   current.d = 0;
 37 | 
 38 | //  //monitor_port
 39 | //  monitor_port = nullptr;
 40 |   //sensor
 41 |   sensor = nullptr;
 42 |   //current sensor
 43 |   current_sense = nullptr;
 44 | }
 45 | 
 46 | 
 47 | /**
 48 | 	Sensor linking method
 49 | */
 50 | void FOCMotor::linkSensor(Sensor* _sensor) {
 51 |   sensor = _sensor;
 52 | }
 53 | 
 54 | /**
 55 | 	CurrentSense linking method
 56 | */
 57 | void FOCMotor::linkCurrentSense(CurrentSense* _current_sense) {
 58 |   current_sense = _current_sense;
 59 | }
 60 | 
 61 | // shaft angle calculation
 62 | float FOCMotor::shaftAngle() {
 63 |   // if no sensor linked return previous value ( for open loop )
 64 |   if(!sensor) return shaft_angle;
 65 |   return sensor_direction*LPF_angle(sensor->getAngle()) - sensor_offset;
 66 | }
 67 | // shaft velocity calculation
 68 | float FOCMotor::shaftVelocity() {
 69 |   // if no sensor linked return previous value ( for open loop )
 70 |   if(!sensor) return shaft_velocity;
 71 |   return sensor_direction*LPF_velocity(sensor->getVelocity());
 72 | }
 73 | 
 74 | float FOCMotor::electricalAngle(){
 75 |   return _normalizeAngle((shaft_angle + sensor_offset) * pole_pairs - zero_electric_angle);
 76 | }
 77 | 
 78 | ///**
 79 | // *  Monitoring functions
 80 | // */
 81 | //// function implementing the monitor_port setter
 82 | //void FOCMotor::useMonitoring(Print &print){
 83 | //  monitor_port = &print; //operate on the address of print
 84 | //  if(monitor_port ) monitor_port->println(F("MOT: Monitor enabled!"));
 85 | //}
 86 | 
 87 | //// utility function intended to be used with serial plotter to monitor motor variables
 88 | //// significantly slowing the execution down!!!!
 89 | //void FOCMotor::monitor() {
 90 | //  if( !monitor_downsample || monitor_cnt++ < monitor_downsample ) return;
 91 | //  monitor_cnt = 0;
 92 | //  if(!monitor_port) return;
 93 | //  bool printed = 0;
 94 | //
 95 | //  if(monitor_variables & _MON_TARGET){
 96 | //    monitor_port->print(target,4);
 97 | //    monitor_port->print("\t");
 98 | //    printed= true;
 99 | //  }
100 | //  if(monitor_variables & _MON_VOLT_Q) {
101 | //    monitor_port->print(voltage.q,4);
102 | //    monitor_port->print("\t");
103 | //    printed= true;
104 | //  }
105 | //  if(monitor_variables & _MON_VOLT_D) {
106 | //    monitor_port->print(voltage.d,4);
107 | //    monitor_port->print("\t");
108 | //    printed= true;
109 | //  }
110 | //  // read currents if possible - even in voltage mode (if current_sense available)
111 | //  if(monitor_variables & _MON_CURR_Q || monitor_variables & _MON_CURR_D) {
112 | //    DQCurrent_s c{0,0};
113 | //    if(current_sense){
114 | //      if(torque_controller == TorqueControlType::foc_current) c = current;
115 | //      else c = current_sense->getFOCCurrents(electrical_angle);
116 | //    }
117 | //    if(monitor_variables & _MON_CURR_Q) {
118 | //      monitor_port->print(c.q*1000,2); // mAmps
119 | //      monitor_port->print("\t");
120 | //      printed= true;
121 | //    }
122 | //    if(monitor_variables & _MON_CURR_D) {
123 | //      monitor_port->print(c.d*1000,2); // mAmps
124 | //      monitor_port->print("\t");
125 | //      printed= true;
126 | //    }
127 | //  }
128 | //
129 | //  if(monitor_variables & _MON_VEL) {
130 | //    monitor_port->print(shaft_velocity,4);
131 | //    monitor_port->print("\t");
132 | //    printed= true;
133 | //  }
134 | //  if(monitor_variables & _MON_ANGLE) {
135 | //    monitor_port->print(shaft_angle,4);
136 | //    printed= true;
137 | //  }
138 | //  if(printed) monitor_port->println();
139 | //
140 | //}
141 | 


--------------------------------------------------------------------------------
/Core/Src/spi.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |   ******************************************************************************
  3 |   * @file    spi.c
  4 |   * @brief   This file provides code for the configuration
  5 |   *          of the SPI instances.
  6 |   ******************************************************************************
  7 |   * @attention
  8 |   *
  9 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
 10 |   * All rights reserved.</center></h2>
 11 |   *
 12 |   * This software component is licensed by ST under BSD 3-Clause license,
 13 |   * the "License"; You may not use this file except in compliance with the
 14 |   * License. You may obtain a copy of the License at:
 15 |   *                        opensource.org/licenses/BSD-3-Clause
 16 |   *
 17 |   ******************************************************************************
 18 |   */
 19 | 
 20 | /* Includes ------------------------------------------------------------------*/
 21 | #include "spi.h"
 22 | 
 23 | /* USER CODE BEGIN 0 */
 24 | 
 25 | /* USER CODE END 0 */
 26 | 
 27 | SPI_HandleTypeDef hspi1;
 28 | 
 29 | /* SPI1 init function */
 30 | void MX_SPI1_Init(void)
 31 | {
 32 | 
 33 |   hspi1.Instance = SPI1;
 34 |   hspi1.Init.Mode = SPI_MODE_MASTER;
 35 |   hspi1.Init.Direction = SPI_DIRECTION_2LINES;
 36 |   hspi1.Init.DataSize = SPI_DATASIZE_16BIT;
 37 |   hspi1.Init.CLKPolarity = SPI_POLARITY_LOW; //must be low
 38 |   hspi1.Init.CLKPhase = SPI_PHASE_2EDGE;
 39 |   hspi1.Init.NSS = SPI_NSS_SOFT;
 40 |   hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
 41 |   hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
 42 |   hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
 43 |   hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
 44 |   hspi1.Init.CRCPolynomial = 0x0;
 45 |   hspi1.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
 46 |   hspi1.Init.NSSPolarity = SPI_NSS_POLARITY_HIGH;
 47 |   hspi1.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
 48 |   hspi1.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
 49 |   hspi1.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
 50 |   hspi1.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
 51 |   hspi1.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
 52 |   hspi1.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
 53 |   hspi1.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
 54 |   hspi1.Init.IOSwap = SPI_IO_SWAP_DISABLE;
 55 |   if (HAL_SPI_Init(&hspi1) != HAL_OK)
 56 |   {
 57 |     Error_Handler();
 58 |   }
 59 | 
 60 | }
 61 | 
 62 | void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
 63 | {
 64 | 
 65 |   GPIO_InitTypeDef GPIO_InitStruct = {0};
 66 |   if(spiHandle->Instance==SPI1)
 67 |   {
 68 |   /* USER CODE BEGIN SPI1_MspInit 0 */
 69 | 
 70 |   /* USER CODE END SPI1_MspInit 0 */
 71 |     /* SPI1 clock enable */
 72 |     __HAL_RCC_SPI1_CLK_ENABLE();
 73 | 
 74 |     __HAL_RCC_GPIOA_CLK_ENABLE();
 75 |     /**SPI1 GPIO Configuration
 76 |     PA5     ------> SPI1_SCK
 77 |     PA6     ------> SPI1_MISO
 78 |     PA7     ------> SPI1_MOSI
 79 |     */
 80 |     GPIO_InitStruct.Pin = GPIO_PIN_5;
 81 |     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 82 |     GPIO_InitStruct.Pull = GPIO_PULLUP;
 83 |     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 84 |     GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
 85 |     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 86 | 
 87 |     GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7;
 88 |     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
 89 |     GPIO_InitStruct.Pull = GPIO_PULLUP;
 90 |     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
 91 |     GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
 92 |     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 93 | 
 94 |     /* SPI1 interrupt Init */
 95 |     HAL_NVIC_SetPriority(SPI1_IRQn, 0, 0);
 96 |     HAL_NVIC_EnableIRQ(SPI1_IRQn);
 97 |   /* USER CODE BEGIN SPI1_MspInit 1 */
 98 | 
 99 |   /* USER CODE END SPI1_MspInit 1 */
100 |   }
101 | }
102 | 
103 | void HAL_SPI_MspDeInit(SPI_HandleTypeDef* spiHandle)
104 | {
105 | 
106 |   if(spiHandle->Instance==SPI1)
107 |   {
108 |   /* USER CODE BEGIN SPI1_MspDeInit 0 */
109 | 
110 |   /* USER CODE END SPI1_MspDeInit 0 */
111 |     /* Peripheral clock disable */
112 |     __HAL_RCC_SPI1_CLK_DISABLE();
113 | 
114 |     /**SPI1 GPIO Configuration
115 |     PA5     ------> SPI1_SCK
116 |     PA6     ------> SPI1_MISO
117 |     PA7     ------> SPI1_MOSI
118 |     */
119 |     HAL_GPIO_DeInit(GPIOA, GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);
120 | 
121 |     /* SPI1 interrupt Deinit */
122 |     HAL_NVIC_DisableIRQ(SPI1_IRQn);
123 |   /* USER CODE BEGIN SPI1_MspDeInit 1 */
124 | 
125 |   /* USER CODE END SPI1_MspDeInit 1 */
126 |   }
127 | }
128 | 
129 | /* USER CODE BEGIN 1 */
130 | 
131 | /* USER CODE END 1 */
132 | 
133 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
134 | 


--------------------------------------------------------------------------------
/Core/Src/sensors/Encoder.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Encoder.cpp
  3 |  *
  4 |  *  Created on: 23 Mar 2021
  5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/blob/v2.1/src/sensors/Encoder.cpp
  6 |  */
  7 | 
  8 | #include "Encoder.hpp"
  9 | 
 10 | 
 11 | /*
 12 |   Encoder(int encA, int encB , int cpr, int index)
 13 |   - encA, encB    - encoder A and B pins
 14 |   - cpr           - counts per rotation number (cpm=ppm*4)
 15 |   - index pin     - (optional input)
 16 | */
 17 | 
 18 | Encoder::Encoder(int _encA, int _encB , float _ppr, int _index){
 19 | 
 20 |   // Encoder measurement structure init
 21 |   // hardware pins
 22 |   pinA = _encA;
 23 |   pinB = _encB;
 24 |   // counter setup
 25 |   pulse_counter = 0;
 26 |   pulse_timestamp = 0;
 27 | 
 28 |   cpr = _ppr;
 29 |   A_active = 0;
 30 |   B_active = 0;
 31 |   I_active = 0;
 32 |   // index pin
 33 |   index_pin = _index; // its 0 if not used
 34 | 
 35 |   // velocity calculation variables
 36 |   prev_Th = 0;
 37 |   pulse_per_second = 0;
 38 |   prev_pulse_counter = 0;
 39 |   prev_timestamp_us = _micros();
 40 | 
 41 |   // extern pullup as default
 42 |   pullup = Pullup::EXTERN;
 43 |   // enable quadrature encoder by default
 44 |   quadrature = Quadrature::ON;
 45 | }
 46 | 
 47 | //  Encoder interrupt callback functions
 48 | // A channel
 49 | void Encoder::handleA() {
 50 | 	unsigned short A = HAL_GPIO_ReadPin(EncoderAU_Pin3_GPIO_Port, EncoderAU_Pin3_Pin);
 51 | 
 52 | 	if (A != A_active) {
 53 | 		pulse_counter += (A_active == B_active) ? 1 : -1;
 54 | 		pulse_timestamp = _micros();
 55 | 		A_active = A;
 56 | 	}
 57 | }
 58 | // B channel
 59 | void Encoder::handleB() {
 60 | 	unsigned short B = HAL_GPIO_ReadPin(EncoderBV_Pin2_GPIO_Port, EncoderBV_Pin2_Pin);
 61 | 
 62 | 	if (B != B_active) {
 63 | 		pulse_counter += (A_active != B_active) ? 1 : -1;
 64 | 		pulse_timestamp = _micros();
 65 | 		B_active = B;
 66 | 	}
 67 | }
 68 | 
 69 | // I channel (index)
 70 | void Encoder::handleIndex() {
 71 | 	if (hasIndex()) {
 72 | 		unsigned short I = HAL_GPIO_ReadPin(EncoderIW_Pin11_GPIO_Port, EncoderIW_Pin11_Pin);
 73 | 
 74 | 		if (I && !I_active) {
 75 | 			index_found = 1;
 76 | 			//align encoder on each index
 77 | 			long tmp = pulse_counter;
 78 | 			//current counter value
 79 | 			pulse_counter = round((double)pulse_counter / (double)cpr)*cpr;
 80 | 			//preserve relative speed
 81 | 			prev_pulse_counter += pulse_counter - tmp;
 82 | 		}
 83 | 		I_active = I;
 84 | 	}
 85 | }
 86 | 
 87 | //// Index channel
 88 | //void Encoder::handleIndex() {
 89 | //  if(hasIndex()){
 90 | //    bool I = digitalRead(index_pin);
 91 | //    if(I && !I_active){
 92 | //      index_found = true;
 93 | //      // align encoder on each index
 94 | //      long tmp = pulse_counter;
 95 | //      // corrent the counter value
 96 | //      pulse_counter = round((double)pulse_counter/(double)cpr)*cpr;
 97 | //      // preserve relative speed
 98 | //      prev_pulse_counter += pulse_counter - tmp;
 99 | //    }
100 | //    I_active = I;
101 | //  }
102 | //}
103 | 
104 | /*
105 | 	Shaft angle calculation
106 | */
107 | float Encoder::getAngle(){
108 |   return  _2PI * (pulse_counter) / ((float)cpr);
109 | }
110 | /*
111 |   Shaft velocity calculation
112 |   function using mixed time and frequency measurement technique
113 | */
114 | float Encoder::getVelocity(){
115 |   // timestamp
116 |   long timestamp_us = _micros();
117 |   // sampling time calculation
118 |   float Ts = (timestamp_us - prev_timestamp_us) * 1e-6;
119 |   // quick fix for strange cases (micros overflow)
120 |   if(Ts <= 0 || Ts > 0.5) Ts = 1e-3;
121 | 
122 |   // time from last impulse
123 |   float Th = (timestamp_us - pulse_timestamp) * 1e-6;
124 |   long dN = pulse_counter - prev_pulse_counter;
125 | 
126 |   // Pulse per second calculation (Eq.3.)
127 |   // dN - impulses received
128 |   // Ts - sampling time - time in between function calls
129 |   // Th - time from last impulse
130 |   // Th_1 - time form last impulse of the previous call
131 |   // only increment if some impulses received
132 |   float dt = Ts + prev_Th - Th;
133 |   pulse_per_second = (dN != 0 && dt > Ts/2) ? dN / dt : pulse_per_second;
134 | 
135 |   // if more than 0.05 passed in between impulses
136 |   if ( Th > 0.1) pulse_per_second = 0;
137 | 
138 |   // velocity calculation
139 |   float velocity = pulse_per_second / ((float)cpr) * (_2PI);
140 | 
141 |   // save variables for next pass
142 |   prev_timestamp_us = timestamp_us;
143 |   // save velocity calculation variables
144 |   prev_Th = Th;
145 |   prev_pulse_counter = pulse_counter;
146 |   return velocity;
147 | }
148 | 
149 | // getter for index pin
150 | // return -1 if no index
151 | int Encoder::needsSearch(){
152 |   return hasIndex() && !index_found;
153 | }
154 | 
155 | // private function used to determine if encoder has index
156 | int Encoder::hasIndex(){
157 |   return index_pin != 0;
158 | }
159 | 
160 | void Encoder::setAngle(float pulse_value) {
161 | 	pulse_counter = 0;
162 | }
163 | 
164 | // encoder initialisation of the hardware pins
165 | // and calculation variables
166 | void Encoder::init(){
167 | 
168 |   // counter setup
169 |   pulse_counter = 0;
170 |   pulse_timestamp = _micros();
171 |   // velocity calculation variables
172 |   prev_Th = 0;
173 |   pulse_per_second = 0;
174 |   prev_pulse_counter = 0;
175 |   prev_timestamp_us = _micros();
176 | 
177 |   // initial cpr = PPR
178 |   // change it if the mode is quadrature
179 |   if(quadrature == Quadrature::ON) cpr = 4*cpr;
180 | 
181 | }
182 | 
183 | 


--------------------------------------------------------------------------------
/Notes:
--------------------------------------------------------------------------------
 1 | Notes:
 2 |  //9th April, 2021:
 3 |  //TODO - here, align Iq - this may already be done with zero_angle, but should not this come before phase/driver alignment?
 4 |  //why index search doesn't work?
 5 |  //--seems like index search fails due to speed of index search set too high (20rad/s) causing
 6 |  //--motor not to be able to move to requested angle, before next position call was mad.
 7 |  //--either adding during index search while loop: BLDCMotor::absoluteZeroSearch()
 8 |  //--or decreasing "motor.velocity_index_search" to 0.1 fixes this problem.
 9 | 
10 |  //Reset pulse counter to 0 on index detection? this would affect the velocity calculations
11 |  //but resetting the pulse counter at some point is necessary otherwise counter will overflow.
12 | 
13 |  //* Implement anti-cogging - i.e. cogging compensation
14 |  //* Check why "pulse_per_second" fluctuates between 999 and 1999 when motor spinning
15 | 
16 |  //10th April, 2021:
17 |  /* working on the anti-cogging feature. Can't get the angle/foc_current control to work w/i the calibration loop
18 |   * so tried to bring it out into the while(1) loop below, but can't get the motor to iterate through a set of
19 |   * target angles here either - why? Is the _delay(2000) necessary? Why can't I set the motor.target value at
20 |   * a lower rate then loopFOC and have motor.move() also running at a lower rate than loopFOC()?
21 |   *
22 |   */
23 | 
24 |  //16th April, 2021:
25 |  /* Looking into the functions loopFOC() and move([target optional]) it seems that in velocity mode, they are
26 |   * best run at the same freq. Within the move() function, in angle control mode both the velocity set point (based on error
27 |   * between angle set point and measured angle) and current (based on error between new velocity set point and measured
28 |   * velocity). However, it is probably best to have the current set point
29 |   * set points are calculated within the same function. However, it is
30 |   */
31 | 
32 |  //22nd April, 2021:
33 |  /* Working on getting parity between Arduino and STM32 environments.
34 |   * The 'natural' directions of spin were found to be different. Had to switch the assignment of encoder to GPIO pins in
35 |   * main.h to get matching (CCW) estimates.
36 |   * Next need to make sure that the zero-offset angle is calculated the same. Why/how can it be different?
37 |   */
38 | 
39 |  //23rd April, 2021:
40 |  /* Removed TIM4, now using TIM1CH4 for PWMA_Pin9 (which is actually pin D4). This is so that I don't need to synchronise
41 |   * the timer channels. As all three PWM channels are now driven by the same clock, they should always be in sync.
42 |   * Undid the switching of encoder pin assignment. The better way to achieve the same effect is to switch the pins the
43 |   * three PWM signals are assigned - see function: _writeDutyCycle3PWM().
44 |   * Am still not sure what PWM (1 or 2) mode is used, the code is not clear: https://github.com/simplefoc/Arduino-FOC/blob/40336919658f35790c96164dc37a6395fe8b4526/src/drivers/hardware_specific/stm32_mcu.cpp
45 |   * Tried both PWM1 and PWM2, but neither lead to the same (as arduino) zero angle offset. In arduino I get 2.9877 radians, and
46 |   * with this code for all possible combinations of a/b/c to U/V/W channels (and PWM1 or PWM2) I can't get the same offset angle.
47 |   *
48 |   * Also, need to look at correctly sampling the current from the phases. Maybe sampling many times quickly and smoothing out the
49 |   * values, or integrating over a long(er) time...
50 |   */
51 | 
52 | 
53 |  //4th May, 2021:
54 |  /* Currently code causes the motor to short circuit during enable where setPwm(0,0,0) - don't understand why.
55 |   *
56 |   */
57 | 
58 |  //6th May, 2021:
59 |  /* The cause of motor short (noted above) is due to the fact that had moved the PWM signals for the motor phases
60 |   * from D15/E11/E14 on STM board to E9/E11/E14 so that they could all be driven by the same clock. However, this
61 |   * change also needed to include a hardware change - physically connecting pin E9 (arduino D4) to pin D15 (arduino D9).
62 |   *
63 |   * Okay, so motor calibrating, and finding zero-offset angle of 2.05 radians. Doesn't match with Arduino code.
64 |   *
65 |   * Motor also doesn't spin properly when motor.target = 1, which in Arduino causes a smooth spin. Will investigate
66 |   * possible poor current estimates.
67 |   *
68 |   * Problem with current readings may be to do with the fact that the timing of readings is falling at different times within
69 |   * the PWM signal causing various inaccurate readings. Need to trigger the ADC sampling every time a PWM pulse is triggered.
70 |   * Tried to setup ADC to trigger on TIM1 counter overflow - added callback function, with LED toggle code to verify that this works.
71 |   * Tomorrow need to debug, and get working.
72 |   *
73 |   */
74 | 
75 |  //7th May, 2021:
76 |  /* Working on getting the current readings accurately - timed by the PWM freq. signal (TIMx_ARR).
77 |   *
78 |   */
79 | 
80 |  //10th May, 2021:
81 |  /* fix current measurement calculations.
82 |   * Why does motor 'click' and current steps high to low?
83 |   */
84 |   
85 |   //20th May, 2021:
86 |   Motor clicking and generally FOC (foc_current/dc_current) control not working because PID parameters for I/Q loops and current limits where set too high 
87 |   for the low-resistance motor that I am using. 
88 |  
89 |  Replacing the HAL_GetTick()*1000 with 32-bit timer (TIM2->CH1) which is set to 1MHz improves the control loop for the I/Q currents. 
90 |  


--------------------------------------------------------------------------------
/STM32H743ZITX_RAM.ld:
--------------------------------------------------------------------------------
  1 | /**
  2 |  ******************************************************************************
  3 |  * @file      LinkerScript.ld
  4 |  * @author    Auto-generated by STM32CubeIDE
  5 |  *  Abstract    : Linker script for NUCLEO-H743ZI2 Board embedding STM32H743ZITx Device from stm32h7 series
  6 |  *                      2048Kbytes FLASH
  7 |  *                      128Kbytes DTCMRAM
  8 |  *                      64Kbytes ITCMRAM
  9 |  *                      512Kbytes RAM_D1
 10 |  *                      288Kbytes RAM_D2
 11 |  *                      64Kbytes RAM_D3
 12 |  *
 13 |  *            Set heap size, stack size and stack location according
 14 |  *            to application requirements.
 15 |  *
 16 |  *            Set memory bank area and size if external memory is used
 17 |  ******************************************************************************
 18 |  * @attention
 19 |  *
 20 |  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
 21 |  * All rights reserved.</center></h2>
 22 |  *
 23 |  * This software component is licensed by ST under BSD 3-Clause license,
 24 |  * the "License"; You may not use this file except in compliance with the
 25 |  * License. You may obtain a copy of the License at:
 26 |  *                        opensource.org/licenses/BSD-3-Clause
 27 |  *
 28 |  ******************************************************************************
 29 |  */
 30 | 
 31 | /* Entry Point */
 32 | ENTRY(Reset_Handler)
 33 | 
 34 | /* Highest address of the user mode stack */
 35 | _estack = ORIGIN(RAM_D1) + LENGTH(RAM_D1);	/* end of "RAM_D1" Ram type memory */
 36 | 
 37 | _Min_Heap_Size = 0x200;	/* required amount of heap  */
 38 | _Min_Stack_Size = 0x400;	/* required amount of stack */
 39 | 
 40 | /* Memories definition */
 41 | MEMORY
 42 | {
 43 |   DTCMRAM    (xrw)    : ORIGIN = 0x20000000,   LENGTH = 128K
 44 |   ITCMRAM    (xrw)    : ORIGIN = 0x00000000,   LENGTH = 64K
 45 |   RAM_D1    (xrw)    : ORIGIN = 0x24000000,   LENGTH = 512K
 46 |   RAM_D2    (xrw)    : ORIGIN = 0x30000000,   LENGTH = 288K
 47 |   RAM_D3    (xrw)    : ORIGIN = 0x38000000,   LENGTH = 64K
 48 |   FLASH    (rx)    : ORIGIN = 0x8000000,   LENGTH = 2048K
 49 | }
 50 | 
 51 | /* Sections */
 52 | SECTIONS
 53 | {
 54 |   /* The startup code into "RAM_D1" Ram type memory */
 55 |   .isr_vector :
 56 |   {
 57 |     . = ALIGN(4);
 58 |     KEEP(*(.isr_vector)) /* Startup code */
 59 |     . = ALIGN(4);
 60 |   } >RAM_D1
 61 | 
 62 |   /* The program code and other data into "RAM_D1" Ram type memory */
 63 |   .text :
 64 |   {
 65 |     . = ALIGN(4);
 66 |     *(.text)           /* .text sections (code) */
 67 |     *(.text*)          /* .text* sections (code) */
 68 |     *(.glue_7)         /* glue arm to thumb code */
 69 |     *(.glue_7t)        /* glue thumb to arm code */
 70 |     *(.eh_frame)
 71 | 
 72 |     KEEP (*(.init))
 73 |     KEEP (*(.fini))
 74 | 
 75 |     . = ALIGN(4);
 76 |     _etext = .;        /* define a global symbols at end of code */
 77 |   } >RAM_D1
 78 | 
 79 |   /* Constant data into "RAM_D1" Ram type memory */
 80 |   .rodata :
 81 |   {
 82 |     . = ALIGN(4);
 83 |     *(.rodata)         /* .rodata sections (constants, strings, etc.) */
 84 |     *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
 85 |     . = ALIGN(4);
 86 |   } >RAM_D1
 87 | 
 88 |   .ARM.extab   : {
 89 |     . = ALIGN(4);
 90 |     *(.ARM.extab* .gnu.linkonce.armextab.*)
 91 |     . = ALIGN(4);
 92 |   } >RAM_D1
 93 | 
 94 |   .ARM : {
 95 |     . = ALIGN(4);
 96 |     __exidx_start = .;
 97 |     *(.ARM.exidx*)
 98 |     __exidx_end = .;
 99 |     . = ALIGN(4);
100 |   } >RAM_D1
101 | 
102 |   .preinit_array     :
103 |   {
104 |     . = ALIGN(4);
105 |     PROVIDE_HIDDEN (__preinit_array_start = .);
106 |     KEEP (*(.preinit_array*))
107 |     PROVIDE_HIDDEN (__preinit_array_end = .);
108 |     . = ALIGN(4);
109 |   } >RAM_D1
110 | 
111 |   .init_array :
112 |   {
113 |     . = ALIGN(4);
114 |     PROVIDE_HIDDEN (__init_array_start = .);
115 |     KEEP (*(SORT(.init_array.*)))
116 |     KEEP (*(.init_array*))
117 |     PROVIDE_HIDDEN (__init_array_end = .);
118 |     . = ALIGN(4);
119 |   } >RAM_D1
120 | 
121 |   .fini_array :
122 |   {
123 |     . = ALIGN(4);
124 |     PROVIDE_HIDDEN (__fini_array_start = .);
125 |     KEEP (*(SORT(.fini_array.*)))
126 |     KEEP (*(.fini_array*))
127 |     PROVIDE_HIDDEN (__fini_array_end = .);
128 |     . = ALIGN(4);
129 |   } >RAM_D1
130 | 
131 |   /* Used by the startup to initialize data */
132 |   _sidata = LOADADDR(.data);
133 | 
134 |   /* Initialized data sections into "RAM_D1" Ram type memory */
135 |   .data :
136 |   {
137 |     . = ALIGN(4);
138 |     _sdata = .;        /* create a global symbol at data start */
139 |     *(.data)           /* .data sections */
140 |     *(.data*)          /* .data* sections */
141 | 
142 |     . = ALIGN(4);
143 |     _edata = .;        /* define a global symbol at data end */
144 | 
145 |   } >RAM_D1
146 | 
147 |   /* Uninitialized data section into "RAM_D1" Ram type memory */
148 |   . = ALIGN(4);
149 |   .bss :
150 |   {
151 |     /* This is used by the startup in order to initialize the .bss section */
152 |     _sbss = .;         /* define a global symbol at bss start */
153 |     __bss_start__ = _sbss;
154 |     *(.bss)
155 |     *(.bss*)
156 |     *(COMMON)
157 | 
158 |     . = ALIGN(4);
159 |     _ebss = .;         /* define a global symbol at bss end */
160 |     __bss_end__ = _ebss;
161 |   } >RAM_D1
162 | 
163 |   /* User_heap_stack section, used to check that there is enough "RAM_D1" Ram  type memory left */
164 |   ._user_heap_stack :
165 |   {
166 |     . = ALIGN(8);
167 |     PROVIDE ( end = . );
168 |     PROVIDE ( _end = . );
169 |     . = . + _Min_Heap_Size;
170 |     . = . + _Min_Stack_Size;
171 |     . = ALIGN(8);
172 |   } >RAM_D1
173 | 
174 |   /* Remove information from the compiler libraries */
175 |   /DISCARD/ :
176 |   {
177 |     libc.a ( * )
178 |     libm.a ( * )
179 |     libgcc.a ( * )
180 |   }
181 | 
182 |   .ARM.attributes 0 : { *(.ARM.attributes) }
183 | }
184 | 


--------------------------------------------------------------------------------
/STM32H743ZITX_FLASH.ld:
--------------------------------------------------------------------------------
  1 | /**
  2 |  ******************************************************************************
  3 |  * @file      LinkerScript.ld
  4 |  * @author    Auto-generated by STM32CubeIDE
  5 |  *  Abstract    : Linker script for NUCLEO-H743ZI2 Board embedding STM32H743ZITx Device from stm32h7 series
  6 |  *                      2048Kbytes FLASH
  7 |  *                      128Kbytes DTCMRAM
  8 |  *                      64Kbytes ITCMRAM
  9 |  *                      512Kbytes RAM_D1
 10 |  *                      288Kbytes RAM_D2
 11 |  *                      64Kbytes RAM_D3
 12 |  *
 13 |  *            Set heap size, stack size and stack location according
 14 |  *            to application requirements.
 15 |  *
 16 |  *            Set memory bank area and size if external memory is used
 17 |  ******************************************************************************
 18 |  * @attention
 19 |  *
 20 |  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
 21 |  * All rights reserved.</center></h2>
 22 |  *
 23 |  * This software component is licensed by ST under BSD 3-Clause license,
 24 |  * the "License"; You may not use this file except in compliance with the
 25 |  * License. You may obtain a copy of the License at:
 26 |  *                        opensource.org/licenses/BSD-3-Clause
 27 |  *
 28 |  ******************************************************************************
 29 |  */
 30 | 
 31 | /* Entry Point */
 32 | ENTRY(Reset_Handler)
 33 | 
 34 | /* Highest address of the user mode stack */
 35 | _estack = ORIGIN(RAM_D1) + LENGTH(RAM_D1);	/* end of "RAM_D1" Ram type memory */
 36 | 
 37 | _Min_Heap_Size = 0x200 ;	/* required amount of heap  */
 38 | _Min_Stack_Size = 0x400 ;	/* required amount of stack */
 39 | 
 40 | /* Memories definition */
 41 | MEMORY
 42 | {
 43 |   DTCMRAM    (xrw)    : ORIGIN = 0x20000000,   LENGTH = 128K
 44 |   ITCMRAM    (xrw)    : ORIGIN = 0x00000000,   LENGTH = 64K
 45 |   RAM_D1    (xrw)    : ORIGIN = 0x24000000,   LENGTH = 512K
 46 |   RAM_D2    (xrw)    : ORIGIN = 0x30000000,   LENGTH = 288K
 47 |   RAM_D3    (xrw)    : ORIGIN = 0x38000000,   LENGTH = 64K
 48 |   FLASH    (rx)    : ORIGIN = 0x8000000,   LENGTH = 2048K
 49 | }
 50 | 
 51 | /* Sections */
 52 | SECTIONS
 53 | {
 54 |   /* The startup code into "FLASH" Rom type memory */
 55 |   .isr_vector :
 56 |   {
 57 |     . = ALIGN(4);
 58 |     KEEP(*(.isr_vector)) /* Startup code */
 59 |     . = ALIGN(4);
 60 |   } >FLASH
 61 | 
 62 |   /* The program code and other data into "FLASH" Rom type memory */
 63 |   .text :
 64 |   {
 65 |     . = ALIGN(4);
 66 |     *(.text)           /* .text sections (code) */
 67 |     *(.text*)          /* .text* sections (code) */
 68 |     *(.glue_7)         /* glue arm to thumb code */
 69 |     *(.glue_7t)        /* glue thumb to arm code */
 70 |     *(.eh_frame)
 71 | 
 72 |     KEEP (*(.init))
 73 |     KEEP (*(.fini))
 74 | 
 75 |     . = ALIGN(4);
 76 |     _etext = .;        /* define a global symbols at end of code */
 77 |   } >FLASH
 78 | 
 79 |   /* Constant data into "FLASH" Rom type memory */
 80 |   .rodata :
 81 |   {
 82 |     . = ALIGN(4);
 83 |     *(.rodata)         /* .rodata sections (constants, strings, etc.) */
 84 |     *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
 85 |     . = ALIGN(4);
 86 |   } >FLASH
 87 | 
 88 |   .ARM.extab   : {
 89 |     . = ALIGN(4);
 90 |     *(.ARM.extab* .gnu.linkonce.armextab.*)
 91 |     . = ALIGN(4);
 92 |   } >FLASH
 93 | 
 94 |   .ARM : {
 95 |     . = ALIGN(4);
 96 |     __exidx_start = .;
 97 |     *(.ARM.exidx*)
 98 |     __exidx_end = .;
 99 |     . = ALIGN(4);
100 |   } >FLASH
101 | 
102 |   .preinit_array     :
103 |   {
104 |     . = ALIGN(4);
105 |     PROVIDE_HIDDEN (__preinit_array_start = .);
106 |     KEEP (*(.preinit_array*))
107 |     PROVIDE_HIDDEN (__preinit_array_end = .);
108 |     . = ALIGN(4);
109 |   } >FLASH
110 | 
111 |   .init_array :
112 |   {
113 |     . = ALIGN(4);
114 |     PROVIDE_HIDDEN (__init_array_start = .);
115 |     KEEP (*(SORT(.init_array.*)))
116 |     KEEP (*(.init_array*))
117 |     PROVIDE_HIDDEN (__init_array_end = .);
118 |     . = ALIGN(4);
119 |   } >FLASH
120 | 
121 |   .fini_array :
122 |   {
123 |     . = ALIGN(4);
124 |     PROVIDE_HIDDEN (__fini_array_start = .);
125 |     KEEP (*(SORT(.fini_array.*)))
126 |     KEEP (*(.fini_array*))
127 |     PROVIDE_HIDDEN (__fini_array_end = .);
128 |     . = ALIGN(4);
129 |   } >FLASH
130 | 
131 |   /* Used by the startup to initialize data */
132 |   _sidata = LOADADDR(.data);
133 | 
134 |   /* Initialized data sections into "RAM_D1" Ram type memory */
135 |   .data :
136 |   {
137 |     . = ALIGN(4);
138 |     _sdata = .;        /* create a global symbol at data start */
139 |     *(.data)           /* .data sections */
140 |     *(.data*)          /* .data* sections */
141 | 
142 |     . = ALIGN(4);
143 |     _edata = .;        /* define a global symbol at data end */
144 | 
145 |   } >RAM_D1 AT> FLASH
146 | 
147 |   /* Uninitialized data section into "RAM_D1" Ram type memory */
148 |   . = ALIGN(4);
149 |   .bss :
150 |   {
151 |     /* This is used by the startup in order to initialize the .bss section */
152 |     _sbss = .;         /* define a global symbol at bss start */
153 |     __bss_start__ = _sbss;
154 |     *(.bss)
155 |     *(.bss*)
156 |     *(COMMON)
157 | 
158 |     . = ALIGN(4);
159 |     _ebss = .;         /* define a global symbol at bss end */
160 |     __bss_end__ = _ebss;
161 |   } >RAM_D1
162 | 
163 |   /* User_heap_stack section, used to check that there is enough "RAM_D1" Ram  type memory left */
164 |   ._user_heap_stack :
165 |   {
166 |     . = ALIGN(8);
167 |     PROVIDE ( end = . );
168 |     PROVIDE ( _end = . );
169 |     . = . + _Min_Heap_Size;
170 |     . = . + _Min_Stack_Size;
171 |     . = ALIGN(8);
172 |   } >RAM_D1
173 | 
174 |   /* Remove information from the compiler libraries */
175 |   /DISCARD/ :
176 |   {
177 |     libc.a ( * )
178 |     libm.a ( * )
179 |     libgcc.a ( * )
180 |   }
181 | 
182 |   .ARM.attributes 0 : { *(.ARM.attributes) }
183 | }
184 | 


--------------------------------------------------------------------------------
/STM32CubeIDE/STM32H743ZITX_FLASH.ld:
--------------------------------------------------------------------------------
  1 | /**
  2 |  ******************************************************************************
  3 |  * @file      LinkerScript.ld
  4 |  * @author    Auto-generated by STM32CubeIDE
  5 |  *  Abstract    : Linker script for NUCLEO-H743ZI2 Board embedding STM32H743ZITx Device from stm32h7 series
  6 |  *                      2048Kbytes FLASH
  7 |  *                      128Kbytes DTCMRAM
  8 |  *                      64Kbytes ITCMRAM
  9 |  *                      512Kbytes RAM_D1
 10 |  *                      288Kbytes RAM_D2
 11 |  *                      64Kbytes RAM_D3
 12 |  *
 13 |  *            Set heap size, stack size and stack location according
 14 |  *            to application requirements.
 15 |  *
 16 |  *            Set memory bank area and size if external memory is used
 17 |  ******************************************************************************
 18 |  * @attention
 19 |  *
 20 |  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
 21 |  * All rights reserved.</center></h2>
 22 |  *
 23 |  * This software component is licensed by ST under BSD 3-Clause license,
 24 |  * the "License"; You may not use this file except in compliance with the
 25 |  * License. You may obtain a copy of the License at:
 26 |  *                        opensource.org/licenses/BSD-3-Clause
 27 |  *
 28 |  ******************************************************************************
 29 |  */
 30 | 
 31 | /* Entry Point */
 32 | ENTRY(Reset_Handler)
 33 | 
 34 | /* Highest address of the user mode stack */
 35 | _estack = ORIGIN(RAM_D1) + LENGTH(RAM_D1);	/* end of "RAM_D1" Ram type memory */
 36 | 
 37 | _Min_Heap_Size = 0x200 ;	/* required amount of heap  */
 38 | _Min_Stack_Size = 0x400 ;	/* required amount of stack */
 39 | 
 40 | /* Memories definition */
 41 | MEMORY
 42 | {
 43 |   DTCMRAM    (xrw)    : ORIGIN = 0x20000000,   LENGTH = 128K
 44 |   ITCMRAM    (xrw)    : ORIGIN = 0x00000000,   LENGTH = 64K
 45 |   RAM_D1    (xrw)    : ORIGIN = 0x24000000,   LENGTH = 512K
 46 |   RAM_D2    (xrw)    : ORIGIN = 0x30000000,   LENGTH = 288K
 47 |   RAM_D3    (xrw)    : ORIGIN = 0x38000000,   LENGTH = 64K
 48 |   FLASH    (rx)    : ORIGIN = 0x8000000,   LENGTH = 2048K
 49 | }
 50 | 
 51 | /* Sections */
 52 | SECTIONS
 53 | {
 54 |   /* The startup code into "FLASH" Rom type memory */
 55 |   .isr_vector :
 56 |   {
 57 |     . = ALIGN(4);
 58 |     KEEP(*(.isr_vector)) /* Startup code */
 59 |     . = ALIGN(4);
 60 |   } >FLASH
 61 | 
 62 |   /* The program code and other data into "FLASH" Rom type memory */
 63 |   .text :
 64 |   {
 65 |     . = ALIGN(4);
 66 |     *(.text)           /* .text sections (code) */
 67 |     *(.text*)          /* .text* sections (code) */
 68 |     *(.glue_7)         /* glue arm to thumb code */
 69 |     *(.glue_7t)        /* glue thumb to arm code */
 70 |     *(.eh_frame)
 71 | 
 72 |     KEEP (*(.init))
 73 |     KEEP (*(.fini))
 74 | 
 75 |     . = ALIGN(4);
 76 |     _etext = .;        /* define a global symbols at end of code */
 77 |   } >FLASH
 78 | 
 79 |   /* Constant data into "FLASH" Rom type memory */
 80 |   .rodata :
 81 |   {
 82 |     . = ALIGN(4);
 83 |     *(.rodata)         /* .rodata sections (constants, strings, etc.) */
 84 |     *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
 85 |     . = ALIGN(4);
 86 |   } >FLASH
 87 | 
 88 |   .ARM.extab   : {
 89 |     . = ALIGN(4);
 90 |     *(.ARM.extab* .gnu.linkonce.armextab.*)
 91 |     . = ALIGN(4);
 92 |   } >FLASH
 93 | 
 94 |   .ARM : {
 95 |     . = ALIGN(4);
 96 |     __exidx_start = .;
 97 |     *(.ARM.exidx*)
 98 |     __exidx_end = .;
 99 |     . = ALIGN(4);
100 |   } >FLASH
101 | 
102 |   .preinit_array     :
103 |   {
104 |     . = ALIGN(4);
105 |     PROVIDE_HIDDEN (__preinit_array_start = .);
106 |     KEEP (*(.preinit_array*))
107 |     PROVIDE_HIDDEN (__preinit_array_end = .);
108 |     . = ALIGN(4);
109 |   } >FLASH
110 | 
111 |   .init_array :
112 |   {
113 |     . = ALIGN(4);
114 |     PROVIDE_HIDDEN (__init_array_start = .);
115 |     KEEP (*(SORT(.init_array.*)))
116 |     KEEP (*(.init_array*))
117 |     PROVIDE_HIDDEN (__init_array_end = .);
118 |     . = ALIGN(4);
119 |   } >FLASH
120 | 
121 |   .fini_array :
122 |   {
123 |     . = ALIGN(4);
124 |     PROVIDE_HIDDEN (__fini_array_start = .);
125 |     KEEP (*(SORT(.fini_array.*)))
126 |     KEEP (*(.fini_array*))
127 |     PROVIDE_HIDDEN (__fini_array_end = .);
128 |     . = ALIGN(4);
129 |   } >FLASH
130 | 
131 |   /* Used by the startup to initialize data */
132 |   _sidata = LOADADDR(.data);
133 | 
134 |   /* Initialized data sections into "RAM_D1" Ram type memory */
135 |   .data :
136 |   {
137 |     . = ALIGN(4);
138 |     _sdata = .;        /* create a global symbol at data start */
139 |     *(.data)           /* .data sections */
140 |     *(.data*)          /* .data* sections */
141 | 
142 |     . = ALIGN(4);
143 |     _edata = .;        /* define a global symbol at data end */
144 | 
145 |   } >RAM_D1 AT> FLASH
146 | 
147 |   /* Uninitialized data section into "RAM_D1" Ram type memory */
148 |   . = ALIGN(4);
149 |   .bss :
150 |   {
151 |     /* This is used by the startup in order to initialize the .bss section */
152 |     _sbss = .;         /* define a global symbol at bss start */
153 |     __bss_start__ = _sbss;
154 |     *(.bss)
155 |     *(.bss*)
156 |     *(COMMON)
157 | 
158 |     . = ALIGN(4);
159 |     _ebss = .;         /* define a global symbol at bss end */
160 |     __bss_end__ = _ebss;
161 |   } >RAM_D1
162 | 
163 |   /* User_heap_stack section, used to check that there is enough "RAM_D1" Ram  type memory left */
164 |   ._user_heap_stack :
165 |   {
166 |     . = ALIGN(8);
167 |     PROVIDE ( end = . );
168 |     PROVIDE ( _end = . );
169 |     . = . + _Min_Heap_Size;
170 |     . = . + _Min_Stack_Size;
171 |     . = ALIGN(8);
172 |   } >RAM_D1
173 | 
174 |   /* Remove information from the compiler libraries */
175 |   /DISCARD/ :
176 |   {
177 |     libc.a ( * )
178 |     libm.a ( * )
179 |     libgcc.a ( * )
180 |   }
181 | 
182 |   .ARM.attributes 0 : { *(.ARM.attributes) }
183 | }
184 | 


--------------------------------------------------------------------------------
/STM32CubeIDE/STM32H743ZITX_RAM.ld:
--------------------------------------------------------------------------------
  1 | /**
  2 |  ******************************************************************************
  3 |  * @file      LinkerScript.ld
  4 |  * @author    Auto-generated by STM32CubeIDE
  5 |  *  Abstract    : Linker script for NUCLEO-H743ZI2 Board embedding STM32H743ZITx Device from stm32h7 series
  6 |  *                      2048Kbytes FLASH
  7 |  *                      128Kbytes DTCMRAM
  8 |  *                      64Kbytes ITCMRAM
  9 |  *                      512Kbytes RAM_D1
 10 |  *                      288Kbytes RAM_D2
 11 |  *                      64Kbytes RAM_D3
 12 |  *
 13 |  *            Set heap size, stack size and stack location according
 14 |  *            to application requirements.
 15 |  *
 16 |  *            Set memory bank area and size if external memory is used
 17 |  ******************************************************************************
 18 |  * @attention
 19 |  *
 20 |  * <h2><center>&copy; Copyright (c) 2020 STMicroelectronics.
 21 |  * All rights reserved.</center></h2>
 22 |  *
 23 |  * This software component is licensed by ST under BSD 3-Clause license,
 24 |  * the "License"; You may not use this file except in compliance with the
 25 |  * License. You may obtain a copy of the License at:
 26 |  *                        opensource.org/licenses/BSD-3-Clause
 27 |  *
 28 |  ******************************************************************************
 29 |  */
 30 | 
 31 | /* Entry Point */
 32 | ENTRY(Reset_Handler)
 33 | 
 34 | /* Highest address of the user mode stack */
 35 | _estack = ORIGIN(RAM_D1) + LENGTH(RAM_D1);	/* end of "RAM_D1" Ram type memory */
 36 | 
 37 | _Min_Heap_Size = 0x200;	/* required amount of heap  */
 38 | _Min_Stack_Size = 0x400;	/* required amount of stack */
 39 | 
 40 | /* Memories definition */
 41 | MEMORY
 42 | {
 43 |   DTCMRAM    (xrw)    : ORIGIN = 0x20000000,   LENGTH = 128K
 44 |   ITCMRAM    (xrw)    : ORIGIN = 0x00000000,   LENGTH = 64K
 45 |   RAM_D1    (xrw)    : ORIGIN = 0x24000000,   LENGTH = 512K
 46 |   RAM_D2    (xrw)    : ORIGIN = 0x30000000,   LENGTH = 288K
 47 |   RAM_D3    (xrw)    : ORIGIN = 0x38000000,   LENGTH = 64K
 48 |   FLASH    (rx)    : ORIGIN = 0x8000000,   LENGTH = 2048K
 49 | }
 50 | 
 51 | /* Sections */
 52 | SECTIONS
 53 | {
 54 |   /* The startup code into "RAM_D1" Ram type memory */
 55 |   .isr_vector :
 56 |   {
 57 |     . = ALIGN(4);
 58 |     KEEP(*(.isr_vector)) /* Startup code */
 59 |     . = ALIGN(4);
 60 |   } >RAM_D1
 61 | 
 62 |   /* The program code and other data into "RAM_D1" Ram type memory */
 63 |   .text :
 64 |   {
 65 |     . = ALIGN(4);
 66 |     *(.text)           /* .text sections (code) */
 67 |     *(.text*)          /* .text* sections (code) */
 68 |     *(.glue_7)         /* glue arm to thumb code */
 69 |     *(.glue_7t)        /* glue thumb to arm code */
 70 |     *(.eh_frame)
 71 | 
 72 |     KEEP (*(.init))
 73 |     KEEP (*(.fini))
 74 | 
 75 |     . = ALIGN(4);
 76 |     _etext = .;        /* define a global symbols at end of code */
 77 |   } >RAM_D1
 78 | 
 79 |   /* Constant data into "RAM_D1" Ram type memory */
 80 |   .rodata :
 81 |   {
 82 |     . = ALIGN(4);
 83 |     *(.rodata)         /* .rodata sections (constants, strings, etc.) */
 84 |     *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
 85 |     . = ALIGN(4);
 86 |   } >RAM_D1
 87 | 
 88 |   .ARM.extab   : {
 89 |     . = ALIGN(4);
 90 |     *(.ARM.extab* .gnu.linkonce.armextab.*)
 91 |     . = ALIGN(4);
 92 |   } >RAM_D1
 93 | 
 94 |   .ARM : {
 95 |     . = ALIGN(4);
 96 |     __exidx_start = .;
 97 |     *(.ARM.exidx*)
 98 |     __exidx_end = .;
 99 |     . = ALIGN(4);
100 |   } >RAM_D1
101 | 
102 |   .preinit_array     :
103 |   {
104 |     . = ALIGN(4);
105 |     PROVIDE_HIDDEN (__preinit_array_start = .);
106 |     KEEP (*(.preinit_array*))
107 |     PROVIDE_HIDDEN (__preinit_array_end = .);
108 |     . = ALIGN(4);
109 |   } >RAM_D1
110 | 
111 |   .init_array :
112 |   {
113 |     . = ALIGN(4);
114 |     PROVIDE_HIDDEN (__init_array_start = .);
115 |     KEEP (*(SORT(.init_array.*)))
116 |     KEEP (*(.init_array*))
117 |     PROVIDE_HIDDEN (__init_array_end = .);
118 |     . = ALIGN(4);
119 |   } >RAM_D1
120 | 
121 |   .fini_array :
122 |   {
123 |     . = ALIGN(4);
124 |     PROVIDE_HIDDEN (__fini_array_start = .);
125 |     KEEP (*(SORT(.fini_array.*)))
126 |     KEEP (*(.fini_array*))
127 |     PROVIDE_HIDDEN (__fini_array_end = .);
128 |     . = ALIGN(4);
129 |   } >RAM_D1
130 | 
131 |   /* Used by the startup to initialize data */
132 |   _sidata = LOADADDR(.data);
133 | 
134 |   /* Initialized data sections into "RAM_D1" Ram type memory */
135 |   .data :
136 |   {
137 |     . = ALIGN(4);
138 |     _sdata = .;        /* create a global symbol at data start */
139 |     *(.data)           /* .data sections */
140 |     *(.data*)          /* .data* sections */
141 | 
142 |     . = ALIGN(4);
143 |     _edata = .;        /* define a global symbol at data end */
144 | 
145 |   } >RAM_D1
146 | 
147 |   /* Uninitialized data section into "RAM_D1" Ram type memory */
148 |   . = ALIGN(4);
149 |   .bss :
150 |   {
151 |     /* This is used by the startup in order to initialize the .bss section */
152 |     _sbss = .;         /* define a global symbol at bss start */
153 |     __bss_start__ = _sbss;
154 |     *(.bss)
155 |     *(.bss*)
156 |     *(COMMON)
157 | 
158 |     . = ALIGN(4);
159 |     _ebss = .;         /* define a global symbol at bss end */
160 |     __bss_end__ = _ebss;
161 |   } >RAM_D1
162 | 
163 |   /* User_heap_stack section, used to check that there is enough "RAM_D1" Ram  type memory left */
164 |   ._user_heap_stack :
165 |   {
166 |     . = ALIGN(8);
167 |     PROVIDE ( end = . );
168 |     PROVIDE ( _end = . );
169 |     . = . + _Min_Heap_Size;
170 |     . = . + _Min_Stack_Size;
171 |     . = ALIGN(8);
172 |   } >RAM_D1
173 | 
174 |   /* Remove information from the compiler libraries */
175 |   /DISCARD/ :
176 |   {
177 |     libc.a ( * )
178 |     libm.a ( * )
179 |     libgcc.a ( * )
180 |   }
181 | 
182 |   .ARM.attributes 0 : { *(.ARM.attributes) }
183 | }
184 | 


--------------------------------------------------------------------------------
/Core/Src/gpio.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |   ******************************************************************************
  3 |   * @file    gpio.c
  4 |   * @brief   This file provides code for the configuration
  5 |   *          of all used GPIO pins.
  6 |   ******************************************************************************
  7 |   * @attention
  8 |   *
  9 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
 10 |   * All rights reserved.</center></h2>
 11 |   *
 12 |   * This software component is licensed by ST under BSD 3-Clause license,
 13 |   * the "License"; You may not use this file except in compliance with the
 14 |   * License. You may obtain a copy of the License at:
 15 |   *                        opensource.org/licenses/BSD-3-Clause
 16 |   *
 17 |   ******************************************************************************
 18 |   */
 19 | 
 20 | /* Includes ------------------------------------------------------------------*/
 21 | #include "gpio.h"
 22 | 
 23 | /* USER CODE BEGIN 0 */
 24 | 
 25 | /* USER CODE END 0 */
 26 | 
 27 | /*----------------------------------------------------------------------------*/
 28 | /* Configure GPIO                                                             */
 29 | /*----------------------------------------------------------------------------*/
 30 | /* USER CODE BEGIN 1 */
 31 | 
 32 | /* USER CODE END 1 */
 33 | 
 34 | /** Configure pins
 35 |      PC14-OSC32_IN (OSC32_IN)   ------> RCC_OSC32_IN
 36 |      PC15-OSC32_OUT (OSC32_OUT)   ------> RCC_OSC32_OUT
 37 |      PH0-OSC_IN (PH0)   ------> RCC_OSC_IN
 38 |      PC9   ------> RCC_MCO_2
 39 |      PA8   ------> RCC_MCO_1
 40 | */
 41 | void MX_GPIO_Init(void)
 42 | {
 43 | 
 44 |   GPIO_InitTypeDef GPIO_InitStruct = {0};
 45 | 
 46 |   /* GPIO Ports Clock Enable */
 47 |   __HAL_RCC_GPIOC_CLK_ENABLE();
 48 |   __HAL_RCC_GPIOF_CLK_ENABLE();
 49 |   __HAL_RCC_GPIOH_CLK_ENABLE();
 50 |   __HAL_RCC_GPIOA_CLK_ENABLE();
 51 |   __HAL_RCC_GPIOB_CLK_ENABLE();
 52 |   __HAL_RCC_GPIOE_CLK_ENABLE();
 53 |   __HAL_RCC_GPIOD_CLK_ENABLE();
 54 |   __HAL_RCC_GPIOG_CLK_ENABLE();
 55 | 
 56 |   /*Configure GPIO pin Output Level */
 57 |   HAL_GPIO_WritePin(Enable_Pin8_GPIO_Port, Enable_Pin8_Pin, GPIO_PIN_RESET);
 58 | 
 59 |   /*Configure GPIO pin Output Level */
 60 |   HAL_GPIO_WritePin(GPIOB, LD1_Pin|LD3_Pin, GPIO_PIN_RESET);
 61 | 
 62 |   /*Configure GPIO pin Output Level */
 63 |   HAL_GPIO_WritePin(SPI1_CS_GPIO_Port, SPI1_CS_Pin, GPIO_PIN_SET);
 64 | 
 65 |   /*Configure GPIO pin Output Level */
 66 |   HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);
 67 | 
 68 |   /*Configure GPIO pin : PtPin */
 69 |   GPIO_InitStruct.Pin = B1_Pin;
 70 |   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
 71 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
 72 |   HAL_GPIO_Init(B1_GPIO_Port, &GPIO_InitStruct);
 73 | 
 74 |   /*Configure GPIO pin : PtPin */
 75 |   GPIO_InitStruct.Pin = Enable_Pin8_Pin;
 76 |   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 77 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
 78 |   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 79 |   HAL_GPIO_Init(Enable_Pin8_GPIO_Port, &GPIO_InitStruct);
 80 | 
 81 |   /*Configure GPIO pin : PtPin */
 82 |   GPIO_InitStruct.Pin = LD1_Pin;
 83 |   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 84 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
 85 |   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
 86 |   HAL_GPIO_Init(LD1_GPIO_Port, &GPIO_InitStruct);
 87 | 
 88 |   /*Configure GPIO pin : PtPin */
 89 |   GPIO_InitStruct.Pin = EncoderAU_Pin3_Pin;
 90 |   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
 91 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
 92 |   HAL_GPIO_Init(EncoderAU_Pin3_GPIO_Port, &GPIO_InitStruct);
 93 | 
 94 |   /*Configure GPIO pin : PtPin */
 95 |   GPIO_InitStruct.Pin = LD3_Pin;
 96 |   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
 97 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
 98 |   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
 99 |   HAL_GPIO_Init(LD3_GPIO_Port, &GPIO_InitStruct);
100 | 
101 |   /*Configure GPIO pin : PtPin */
102 |   GPIO_InitStruct.Pin = SPI1_CS_Pin;
103 |   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
104 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
105 |   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
106 |   HAL_GPIO_Init(SPI1_CS_GPIO_Port, &GPIO_InitStruct);
107 | 
108 |   /*Configure GPIO pin : PC9 */
109 |   GPIO_InitStruct.Pin = GPIO_PIN_9;
110 |   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
111 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
112 |   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
113 |   GPIO_InitStruct.Alternate = GPIO_AF0_MCO;
114 |   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
115 | 
116 |   /*Configure GPIO pin : PA8 */
117 |   GPIO_InitStruct.Pin = GPIO_PIN_8;
118 |   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
119 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
120 |   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
121 |   GPIO_InitStruct.Alternate = GPIO_AF0_MCO;
122 |   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
123 | 
124 |   /*Configure GPIO pin : PtPin */
125 |   GPIO_InitStruct.Pin = EncoderBV_Pin2_Pin;
126 |   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
127 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
128 |   HAL_GPIO_Init(EncoderBV_Pin2_GPIO_Port, &GPIO_InitStruct);
129 | 
130 |   /*Configure GPIO pin : PtPin */
131 |   GPIO_InitStruct.Pin = EncoderIW_Pin11_Pin;
132 |   GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
133 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
134 |   HAL_GPIO_Init(EncoderIW_Pin11_GPIO_Port, &GPIO_InitStruct);
135 | 
136 |   /*Configure GPIO pin : PtPin */
137 |   GPIO_InitStruct.Pin = LD2_Pin;
138 |   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
139 |   GPIO_InitStruct.Pull = GPIO_NOPULL;
140 |   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
141 |   HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);
142 | 
143 |   /* EXTI interrupt init*/
144 |   HAL_NVIC_SetPriority(EXTI9_5_IRQn, 0, 0);
145 |   HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);
146 | 
147 |   HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0, 0);
148 |   HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
149 | 
150 | }
151 | 
152 | /* USER CODE BEGIN 2 */
153 | 
154 | /* USER CODE END 2 */
155 | 
156 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
157 | 


--------------------------------------------------------------------------------
/Core/Src/adc.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |   ******************************************************************************
  3 |   * @file    adc.c
  4 |   * @brief   This file provides code for the configuration
  5 |   *          of the ADC instances.
  6 |   ******************************************************************************
  7 |   * @attention
  8 |   *
  9 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
 10 |   * All rights reserved.</center></h2>
 11 |   *
 12 |   * This software component is licensed by ST under BSD 3-Clause license,
 13 |   * the "License"; You may not use this file except in compliance with the
 14 |   * License. You may obtain a copy of the License at:
 15 |   *                        opensource.org/licenses/BSD-3-Clause
 16 |   *
 17 |   ******************************************************************************
 18 |   */
 19 | 
 20 | /* Includes ------------------------------------------------------------------*/
 21 | #include "adc.h"
 22 | 
 23 | /* USER CODE BEGIN 0 */
 24 | 
 25 | /* USER CODE END 0 */
 26 | 
 27 | ADC_HandleTypeDef hadc1;
 28 | ADC_HandleTypeDef hadc3;
 29 | 
 30 | /* ADC1 init function */
 31 | void MX_ADC1_Init(void)
 32 | {
 33 |   ADC_MultiModeTypeDef multimode = {0};
 34 |   ADC_ChannelConfTypeDef sConfig = {0};
 35 | 
 36 |   /** Common config
 37 |   */
 38 |   hadc1.Instance = ADC1;
 39 |   hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
 40 |   hadc1.Init.Resolution = ADC_RESOLUTION_16B;
 41 |   hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
 42 |   hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
 43 |   hadc1.Init.LowPowerAutoWait = DISABLE;
 44 |   hadc1.Init.ContinuousConvMode = ENABLE;
 45 |   hadc1.Init.NbrOfConversion = 1;
 46 |   hadc1.Init.DiscontinuousConvMode = DISABLE;
 47 |   hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
 48 |   hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
 49 |   hadc1.Init.ConversionDataManagement = ADC_CONVERSIONDATA_DR;
 50 |   hadc1.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
 51 |   hadc1.Init.LeftBitShift = ADC_LEFTBITSHIFT_NONE;
 52 |   hadc1.Init.OversamplingMode = DISABLE;
 53 |   if (HAL_ADC_Init(&hadc1) != HAL_OK)
 54 |   {
 55 |     Error_Handler();
 56 |   }
 57 |   /** Configure the ADC multi-mode
 58 |   */
 59 |   multimode.Mode = ADC_MODE_INDEPENDENT;
 60 |   if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK)
 61 |   {
 62 |     Error_Handler();
 63 |   }
 64 |   /** Configure Regular Channel
 65 |   */
 66 |   sConfig.Channel = ADC_CHANNEL_15;
 67 |   sConfig.Rank = ADC_REGULAR_RANK_1;
 68 |   sConfig.SamplingTime = ADC_SAMPLETIME_16CYCLES_5;
 69 |   sConfig.SingleDiff = ADC_SINGLE_ENDED;
 70 |   sConfig.OffsetNumber = ADC_OFFSET_NONE;
 71 |   sConfig.Offset = 0;
 72 |   sConfig.OffsetSignedSaturation = DISABLE;
 73 |   if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 74 |   {
 75 |     Error_Handler();
 76 |   }
 77 | 
 78 | }
 79 | /* ADC3 init function */
 80 | void MX_ADC3_Init(void)
 81 | {
 82 |   ADC_ChannelConfTypeDef sConfig = {0};
 83 | 
 84 |   /** Common config
 85 |   */
 86 |   hadc3.Instance = ADC3;
 87 |   hadc3.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
 88 |   hadc3.Init.Resolution = ADC_RESOLUTION_16B;
 89 |   hadc3.Init.ScanConvMode = ADC_SCAN_DISABLE;
 90 |   hadc3.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
 91 |   hadc3.Init.LowPowerAutoWait = DISABLE;
 92 |   hadc3.Init.ContinuousConvMode = ENABLE;
 93 |   hadc3.Init.NbrOfConversion = 1;
 94 |   hadc3.Init.DiscontinuousConvMode = DISABLE;
 95 |   hadc3.Init.ExternalTrigConv = ADC_SOFTWARE_START;
 96 |   hadc3.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
 97 |   hadc3.Init.ConversionDataManagement = ADC_CONVERSIONDATA_DR;
 98 |   hadc3.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
 99 |   hadc3.Init.LeftBitShift = ADC_LEFTBITSHIFT_NONE;
100 |   hadc3.Init.OversamplingMode = DISABLE;
101 |   if (HAL_ADC_Init(&hadc3) != HAL_OK)
102 |   {
103 |     Error_Handler();
104 |   }
105 |   /** Configure Regular Channel
106 |   */
107 |   sConfig.Channel = ADC_CHANNEL_1;
108 |   sConfig.Rank = ADC_REGULAR_RANK_1;
109 |   sConfig.SamplingTime = ADC_SAMPLETIME_16CYCLES_5;
110 |   sConfig.SingleDiff = ADC_SINGLE_ENDED;
111 |   sConfig.OffsetNumber = ADC_OFFSET_NONE;
112 |   sConfig.Offset = 0;
113 |   sConfig.OffsetSignedSaturation = DISABLE;
114 |   if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
115 |   {
116 |     Error_Handler();
117 |   }
118 | 
119 | }
120 | 
121 | void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
122 | {
123 | 
124 |   GPIO_InitTypeDef GPIO_InitStruct = {0};
125 |   if(adcHandle->Instance==ADC1)
126 |   {
127 |   /* USER CODE BEGIN ADC1_MspInit 0 */
128 | 
129 |   /* USER CODE END ADC1_MspInit 0 */
130 |     /* ADC1 clock enable */
131 |     __HAL_RCC_ADC12_CLK_ENABLE();
132 | 
133 |     __HAL_RCC_GPIOA_CLK_ENABLE();
134 |     /**ADC1 GPIO Configuration
135 |     PA3     ------> ADC1_INP15
136 |     */
137 |     GPIO_InitStruct.Pin = Current_PhaseB_A0_Pin;
138 |     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
139 |     GPIO_InitStruct.Pull = GPIO_NOPULL;
140 |     HAL_GPIO_Init(Current_PhaseB_A0_GPIO_Port, &GPIO_InitStruct);
141 | 
142 |   /* USER CODE BEGIN ADC1_MspInit 1 */
143 | 
144 |   /* USER CODE END ADC1_MspInit 1 */
145 |   }
146 |   else if(adcHandle->Instance==ADC3)
147 |   {
148 |   /* USER CODE BEGIN ADC3_MspInit 0 */
149 | 
150 |   /* USER CODE END ADC3_MspInit 0 */
151 |     /* ADC3 clock enable */
152 |     __HAL_RCC_ADC3_CLK_ENABLE();
153 | 
154 |     __HAL_RCC_GPIOC_CLK_ENABLE();
155 |     /**ADC3 GPIO Configuration
156 |     PC3_C     ------> ADC3_INP1
157 |     */
158 |     HAL_SYSCFG_AnalogSwitchConfig(SYSCFG_SWITCH_PC3, SYSCFG_SWITCH_PC3_OPEN);
159 | 
160 |   /* USER CODE BEGIN ADC3_MspInit 1 */
161 | 
162 |   /* USER CODE END ADC3_MspInit 1 */
163 |   }
164 | }
165 | 
166 | void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle)
167 | {
168 | 
169 |   if(adcHandle->Instance==ADC1)
170 |   {
171 |   /* USER CODE BEGIN ADC1_MspDeInit 0 */
172 | 
173 |   /* USER CODE END ADC1_MspDeInit 0 */
174 |     /* Peripheral clock disable */
175 |     __HAL_RCC_ADC12_CLK_DISABLE();
176 | 
177 |     /**ADC1 GPIO Configuration
178 |     PA3     ------> ADC1_INP15
179 |     */
180 |     HAL_GPIO_DeInit(Current_PhaseB_A0_GPIO_Port, Current_PhaseB_A0_Pin);
181 | 
182 |   /* USER CODE BEGIN ADC1_MspDeInit 1 */
183 | 
184 |   /* USER CODE END ADC1_MspDeInit 1 */
185 |   }
186 |   else if(adcHandle->Instance==ADC3)
187 |   {
188 |   /* USER CODE BEGIN ADC3_MspDeInit 0 */
189 | 
190 |   /* USER CODE END ADC3_MspDeInit 0 */
191 |     /* Peripheral clock disable */
192 |     __HAL_RCC_ADC3_CLK_DISABLE();
193 | 
194 |   /* USER CODE BEGIN ADC3_MspDeInit 1 */
195 | 
196 |   /* USER CODE END ADC3_MspDeInit 1 */
197 |   }
198 | }
199 | 
200 | /* USER CODE BEGIN 1 */
201 | 
202 | /* USER CODE END 1 */
203 | 
204 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
205 | 


--------------------------------------------------------------------------------
/Core/Src/current_sense/InlineCurrentSense.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * InlineCurrentSense.cpp
  3 |  *
  4 |  *  Created on: 23 Mar 2021
  5 |  *  Ported from: https://github.com/simplefoc/Arduino-FOC/tree/v2.1/src/current_sense
  6 |  */
  7 | 
  8 | #include "InlineCurrentSense.hpp"
  9 | #include "math.h"
 10 | #include "main.h"
 11 | 
 12 | // InlineCurrentSensor constructor
 13 | //  - shunt_resistor  - shunt resistor value
 14 | //  - gain  - current-sense op-amp gain
 15 | //  - phA   - A phase adc pin
 16 | //  - phB   - B phase adc pin
 17 | //  - phC   - C phase adc pin (optional)
 18 | InlineCurrentSense::InlineCurrentSense(float _shunt_resistor, float _gain, int _pinA, int _pinB, int _pinC){
 19 |     pinA = _pinA;
 20 |     pinB = _pinB;
 21 |     pinC = _pinC;
 22 | 
 23 |     shunt_resistor = _shunt_resistor;
 24 |     amp_gain  = _gain;
 25 |     volts_to_amps_ratio = 1.0 /_shunt_resistor / _gain; // volts to amps
 26 |     // gains for each phase
 27 |     gain_a = volts_to_amps_ratio;
 28 |     gain_b = volts_to_amps_ratio;
 29 |     gain_c = volts_to_amps_ratio;
 30 | }
 31 | 
 32 | // Inline sensor init function
 33 | void InlineCurrentSense::init(){
 34 | //    // configure ADC variables
 35 | //    _configureADC(pinA,pinB);
 36 |     // calibrate zero offsets
 37 |     calibrateOffsets();
 38 | 
 39 | }
 40 | // Function finding zero offsets of the ADC
 41 | void InlineCurrentSense::calibrateOffsets(){
 42 |     // find adc offset = zero current voltage
 43 |     offset_ia = 0;
 44 |     offset_ib = 0;
 45 |     offset_ic = 0;
 46 |     // call built-in ADC calibration function:
 47 |     offset_ia = _ADCValueToVoltage(_calibrate_phaseA());
 48 |     offset_ib = _ADCValueToVoltage(_calibrate_phaseB());
 49 | }
 50 | 
 51 | // read all three phase currents (if possible 2 or 3)
 52 | PhaseCurrent_s InlineCurrentSense::getPhaseCurrents(){
 53 |     PhaseCurrent_s current;
 54 |     float tmp = _readADCVoltage(pinA);
 55 | 
 56 |     current.a = (tmp - offset_ia)*gain_a;// amps
 57 |     tmp = _readADCVoltage(pinB);
 58 |     current.b = (tmp - offset_ib)*gain_b;// amps
 59 |     current.c = (!_isset(pinC)) ? 0 : (_readADCVoltage(pinC) - offset_ic)*gain_c; // amps
 60 |     return current;
 61 | }
 62 | // Function synchronizing current sense with motor driver.
 63 | // for in-line sensing no such thing is necessary
 64 | int InlineCurrentSense::driverSync(BLDCDriver *driver){
 65 |     return 1;
 66 | }
 67 | 
 68 | // Function aligning the current sense with motor driver
 69 | // if all pins are connected well none of this is really necessary! - can be avoided
 70 | // returns flag
 71 | // 0 - fail
 72 | // 1 - success and nothing changed
 73 | // 2 - success but pins reconfigured
 74 | // 3 - success but gains inverted
 75 | // 4 - success but pins reconfigured and gains inverted
 76 | int InlineCurrentSense::driverAlign(BLDCDriver *driver, float voltage){
 77 |     int exit_flag = 1;
 78 |     if(skip_align) return exit_flag;
 79 |     PhaseCurrent_s c;
 80 |     float ab_ratio = 0;
 81 |     float ac_ratio = 0;
 82 |     // set phase A active and phases B and C down
 83 |     while (1) {
 84 | 		driver->setPwm(3, 0, 0);
 85 | 		_delay(200);
 86 | 		c = getPhaseCurrents();
 87 | 		_delay(200);
 88 | 
 89 | 		// read the current 100 times ( arbitrary number )
 90 | 		for (int i = 0; i < 100; i++) {
 91 | 			PhaseCurrent_s c1 = getPhaseCurrents();
 92 | 			c.a = c.a*0.6 + 0.4*c1.a;
 93 | 			c.b = c.b*0.6 + 0.4*c1.b;
 94 | 			c.c = c.c*0.6 + 0.4*c1.c;
 95 | 			_delay(3);
 96 | 		}
 97 | 		driver->setPwm(0, 0, 0);
 98 | 		// align phase A
 99 | //		float ab_ratio = fabs(c.a / c.b);
100 | //		float ac_ratio = c.c ? fabs(c.a / c.c) : 0;
101 | 		ab_ratio = fabs(c.a / c.b);
102 | 		ac_ratio = c.c ? fabs(c.a / c.c) : 0;
103 | 		if (ab_ratio > 1.5 || ab_ratio < 0.7) {
104 | 			break;
105 | 		}
106 |     }
107 | 
108 | 
109 |     if( ab_ratio > 1.5 ){ // should be ~2
110 |         gain_a *= _sign(c.a);
111 |     }else if( ab_ratio < 0.7 ){ // should be ~0.5
112 |         // switch phase A and B
113 |         int tmp_pinA = pinA;
114 |         pinA = pinB;
115 |         pinB = tmp_pinA;
116 |         gain_a *= _sign(c.b);
117 |         exit_flag = 2; // signal that pins have been switched
118 |     }else if(_isset(pinC) &&  ac_ratio < 0.7 ){ // should be ~0.5
119 |         // switch phase A and C
120 |         int tmp_pinA = pinA;
121 |         pinA = pinC;
122 |         pinC= tmp_pinA;
123 |         gain_a *= _sign(c.c);
124 |         exit_flag = 2;// signal that pins have been switched
125 |     }else{
126 |         // error in current sense - phase either not measured or bad connection
127 |         return 0;
128 |     }
129 | 
130 |     // set phase B active and phases A and C down
131 |     float ba_ratio = 0;
132 |     float bc_ratio = 0;
133 | 
134 |     while (1) {
135 | 		driver->setPwm(0,3,0);
136 | 		_delay(200);
137 | 		c = getPhaseCurrents();
138 | 		// read the current 100 times
139 | 		for (int i = 0; i < 100; i++) {
140 | 			PhaseCurrent_s c1 = getPhaseCurrents();
141 | 			c.a = c.a*0.6 + 0.4*c1.a;
142 | 			c.b = c.b*0.6 + 0.4*c1.b;
143 | 			c.c = c.c*0.6 + 0.4*c1.c;
144 | 			_delay(3);
145 | 		}
146 | 		driver->setPwm(0, 0, 0);
147 | 	//    float ba_ratio = fabs(c.b/c.a);
148 | 	//    float bc_ratio = c.c ? fabs(c.b / c.c) : 0;
149 | 		ba_ratio = fabs(c.b / c.a);
150 | 		bc_ratio = c.c ? fabs(c.b / c.c) : 0;
151 | 		if (ba_ratio > 1.5 || ba_ratio < 0.7) {
152 | 			break;
153 | 		}
154 |     }
155 | 
156 |      if( ba_ratio > 1.5 ){ // should be ~2
157 |         gain_b *= _sign(c.b);
158 |     }else if( ba_ratio < 0.7 ){ // it should be ~0.5
159 |         // switch phase A and B
160 |         int tmp_pinB = pinB;
161 |         pinB = pinA;
162 |         pinA = tmp_pinB;
163 |         gain_b *= _sign(c.a);
164 |         exit_flag = 2; // signal that pins have been switched
165 |     }else if(_isset(pinC) && bc_ratio < 0.7 ){ // should be ~0.5
166 |         // switch phase A and C
167 |         int tmp_pinB = pinB;
168 |         pinB = pinC;
169 |         pinC = tmp_pinB;
170 |         gain_b *= _sign(c.c);
171 |         exit_flag = 2; // signal that pins have been switched
172 |     }else{
173 |         // error in current sense - phase either not measured or bad connection
174 |         return 0;
175 |     }
176 | 
177 |     // if phase C measured
178 |     if(_isset(pinC)){
179 |         // set phase B active and phases A and C down
180 |     	driver->setPwm(0, 0, voltage);
181 |         _delay(200);
182 |         c = getPhaseCurrents();
183 |         // read the adc voltage 500 times ( arbitrary number )
184 |         for (int i = 0; i < 50; i++) {
185 |             PhaseCurrent_s c1 = getPhaseCurrents();
186 |             c.c = (c.c+c1.c)/50.0;
187 |         }
188 |         driver->setPwm(0, 0, 0);
189 |         gain_c *= _sign(c.c);
190 |     }
191 | 
192 |     if(gain_a < 0 || gain_b < 0 || gain_c < 0) exit_flag +=2;
193 | 
194 |     // exit flag is either
195 |     // 0 - fail
196 |     // 1 - success and nothing changed
197 |     // 2 - success but pins reconfigured
198 |     // 3 - success but gains inverted
199 |     // 4 - success but pins reconfigured and gains inverted
200 |     return exit_flag;
201 | }
202 | 


--------------------------------------------------------------------------------
/Core/Src/tim.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |   ******************************************************************************
  3 |   * @file    tim.c
  4 |   * @brief   This file provides code for the configuration
  5 |   *          of the TIM instances.
  6 |   ******************************************************************************
  7 |   * @attention
  8 |   *
  9 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
 10 |   * All rights reserved.</center></h2>
 11 |   *
 12 |   * This software component is licensed by ST under BSD 3-Clause license,
 13 |   * the "License"; You may not use this file except in compliance with the
 14 |   * License. You may obtain a copy of the License at:
 15 |   *                        opensource.org/licenses/BSD-3-Clause
 16 |   *
 17 |   ******************************************************************************
 18 |   */
 19 | 
 20 | /* Includes ------------------------------------------------------------------*/
 21 | #include "tim.h"
 22 | 
 23 | /* USER CODE BEGIN 0 */
 24 | 
 25 | /* USER CODE END 0 */
 26 | 
 27 | TIM_HandleTypeDef htim1;
 28 | TIM_HandleTypeDef htim2;
 29 | 
 30 | /* TIM1 init function */
 31 | void MX_TIM1_Init(void)
 32 | {
 33 |   TIM_MasterConfigTypeDef sMasterConfig = {0};
 34 |   TIM_OC_InitTypeDef sConfigOC = {0};
 35 |   TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
 36 | 
 37 |   htim1.Instance = TIM1;
 38 |   htim1.Init.Prescaler = 0;
 39 |   htim1.Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED3;
 40 |   htim1.Init.Period = 4800;
 41 |   htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
 42 |   htim1.Init.RepetitionCounter = 0;
 43 |   htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
 44 |   if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
 45 |   {
 46 |     Error_Handler();
 47 |   }
 48 |   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
 49 |   sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
 50 |   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
 51 |   if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
 52 |   {
 53 |     Error_Handler();
 54 |   }
 55 |   sConfigOC.OCMode = TIM_OCMODE_PWM2;
 56 |   sConfigOC.Pulse = 0;
 57 |   sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
 58 |   sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
 59 |   sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
 60 |   sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
 61 |   sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
 62 |   if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
 63 |   {
 64 |     Error_Handler();
 65 |   }
 66 |   if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
 67 |   {
 68 |     Error_Handler();
 69 |   }
 70 |   if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
 71 |   {
 72 |     Error_Handler();
 73 |   }
 74 |   sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
 75 |   sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
 76 |   sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
 77 |   sBreakDeadTimeConfig.DeadTime = 0;
 78 |   sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
 79 |   sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
 80 |   sBreakDeadTimeConfig.BreakFilter = 0;
 81 |   sBreakDeadTimeConfig.Break2State = TIM_BREAK2_DISABLE;
 82 |   sBreakDeadTimeConfig.Break2Polarity = TIM_BREAK2POLARITY_HIGH;
 83 |   sBreakDeadTimeConfig.Break2Filter = 0;
 84 |   sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
 85 |   if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
 86 |   {
 87 |     Error_Handler();
 88 |   }
 89 |   HAL_TIM_MspPostInit(&htim1);
 90 | 
 91 | }
 92 | /* TIM2 init function */
 93 | void MX_TIM2_Init(void)
 94 | {
 95 |   TIM_ClockConfigTypeDef sClockSourceConfig = {0};
 96 |   TIM_MasterConfigTypeDef sMasterConfig = {0};
 97 | 
 98 |   htim2.Instance = TIM2;
 99 |   htim2.Init.Prescaler = 120-1;
100 |   htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
101 |   htim2.Init.Period = 4294967295;
102 |   htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
103 |   htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
104 |   if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
105 |   {
106 |     Error_Handler();
107 |   }
108 |   sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
109 |   if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
110 |   {
111 |     Error_Handler();
112 |   }
113 |   sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
114 |   sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
115 |   if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
116 |   {
117 |     Error_Handler();
118 |   }
119 | 
120 | }
121 | 
122 | void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef* tim_pwmHandle)
123 | {
124 | 
125 |   if(tim_pwmHandle->Instance==TIM1)
126 |   {
127 |   /* USER CODE BEGIN TIM1_MspInit 0 */
128 | 
129 |   /* USER CODE END TIM1_MspInit 0 */
130 |     /* TIM1 clock enable */
131 |     __HAL_RCC_TIM1_CLK_ENABLE();
132 | 
133 |     /* TIM1 interrupt Init */
134 |     HAL_NVIC_SetPriority(TIM1_UP_IRQn, 0, 0);
135 |     HAL_NVIC_EnableIRQ(TIM1_UP_IRQn);
136 |   /* USER CODE BEGIN TIM1_MspInit 1 */
137 | 
138 |   /* USER CODE END TIM1_MspInit 1 */
139 |   }
140 | }
141 | 
142 | void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
143 | {
144 | 
145 |   if(tim_baseHandle->Instance==TIM2)
146 |   {
147 |   /* USER CODE BEGIN TIM2_MspInit 0 */
148 | 
149 |   /* USER CODE END TIM2_MspInit 0 */
150 |     /* TIM2 clock enable */
151 |     __HAL_RCC_TIM2_CLK_ENABLE();
152 | 
153 |     /* TIM2 interrupt Init */
154 |     HAL_NVIC_SetPriority(TIM2_IRQn, 0, 0);
155 |     HAL_NVIC_EnableIRQ(TIM2_IRQn);
156 |   /* USER CODE BEGIN TIM2_MspInit 1 */
157 | 
158 |   /* USER CODE END TIM2_MspInit 1 */
159 |   }
160 | }
161 | void HAL_TIM_MspPostInit(TIM_HandleTypeDef* timHandle)
162 | {
163 | 
164 |   GPIO_InitTypeDef GPIO_InitStruct = {0};
165 |   if(timHandle->Instance==TIM1)
166 |   {
167 |   /* USER CODE BEGIN TIM1_MspPostInit 0 */
168 | 
169 |   /* USER CODE END TIM1_MspPostInit 0 */
170 | 
171 |     __HAL_RCC_GPIOE_CLK_ENABLE();
172 |     /**TIM1 GPIO Configuration
173 |     PE9     ------> TIM1_CH1
174 |     PE11     ------> TIM1_CH2
175 |     PE14     ------> TIM1_CH4
176 |     */
177 |     GPIO_InitStruct.Pin = PWMC_Pin6_Pin|PWMB_Pin5_Pin|PWMA_Pin9_Pin;
178 |     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
179 |     GPIO_InitStruct.Pull = GPIO_NOPULL;
180 |     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
181 |     GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
182 |     HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
183 | 
184 |   /* USER CODE BEGIN TIM1_MspPostInit 1 */
185 | 
186 |   /* USER CODE END TIM1_MspPostInit 1 */
187 |   }
188 | 
189 | }
190 | 
191 | void HAL_TIM_PWM_MspDeInit(TIM_HandleTypeDef* tim_pwmHandle)
192 | {
193 | 
194 |   if(tim_pwmHandle->Instance==TIM1)
195 |   {
196 |   /* USER CODE BEGIN TIM1_MspDeInit 0 */
197 | 
198 |   /* USER CODE END TIM1_MspDeInit 0 */
199 |     /* Peripheral clock disable */
200 |     __HAL_RCC_TIM1_CLK_DISABLE();
201 | 
202 |     /* TIM1 interrupt Deinit */
203 |     HAL_NVIC_DisableIRQ(TIM1_UP_IRQn);
204 |   /* USER CODE BEGIN TIM1_MspDeInit 1 */
205 | 
206 |   /* USER CODE END TIM1_MspDeInit 1 */
207 |   }
208 | }
209 | 
210 | void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
211 | {
212 | 
213 |   if(tim_baseHandle->Instance==TIM2)
214 |   {
215 |   /* USER CODE BEGIN TIM2_MspDeInit 0 */
216 | 
217 |   /* USER CODE END TIM2_MspDeInit 0 */
218 |     /* Peripheral clock disable */
219 |     __HAL_RCC_TIM2_CLK_DISABLE();
220 | 
221 |     /* TIM2 interrupt Deinit */
222 |     HAL_NVIC_DisableIRQ(TIM2_IRQn);
223 |   /* USER CODE BEGIN TIM2_MspDeInit 1 */
224 | 
225 |   /* USER CODE END TIM2_MspDeInit 1 */
226 |   }
227 | }
228 | 
229 | /* USER CODE BEGIN 1 */
230 | 
231 | /* USER CODE END 1 */
232 | 
233 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
234 | 


--------------------------------------------------------------------------------
/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_spi_ex.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |   ******************************************************************************
  3 |   * @file    stm32h7xx_hal_spi_ex.c
  4 |   * @author  MCD Application Team
  5 |   * @brief   Extended SPI HAL module driver.
  6 |   *          This file provides firmware functions to manage the following
  7 |   *          SPI peripheral extended functionalities :
  8 |   *           + IO operation functions
  9 |   *           + Peripheral Control functions
 10 |   *
 11 |   ******************************************************************************
 12 |   * @attention
 13 |   *
 14 |   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
 15 |   * All rights reserved.</center></h2>
 16 |   *
 17 |   * This software component is licensed by ST under BSD 3-Clause license,
 18 |   * the "License"; You may not use this file except in compliance with the
 19 |   * License. You may obtain a copy of the License at:
 20 |   *                        opensource.org/licenses/BSD-3-Clause
 21 |   *
 22 |   ******************************************************************************
 23 |   */
 24 | 
 25 | /* Includes ------------------------------------------------------------------*/
 26 | #include "stm32h7xx_hal.h"
 27 | 
 28 | /** @addtogroup STM32H7xx_HAL_Driver
 29 |   * @{
 30 |   */
 31 | 
 32 | /** @defgroup SPIEx SPIEx
 33 |   * @brief SPI Extended HAL module driver
 34 |   * @{
 35 |   */
 36 | #ifdef HAL_SPI_MODULE_ENABLED
 37 | 
 38 | /* Private typedef -----------------------------------------------------------*/
 39 | /* Private defines -----------------------------------------------------------*/
 40 | /* Private macros ------------------------------------------------------------*/
 41 | /* Private variables ---------------------------------------------------------*/
 42 | /* Private function prototypes -----------------------------------------------*/
 43 | /* Exported functions --------------------------------------------------------*/
 44 | 
 45 | /** @defgroup SPIEx_Exported_Functions SPIEx Exported Functions
 46 |   * @{
 47 |   */
 48 | 
 49 | /** @defgroup SPIEx_Exported_Functions_Group1 IO operation functions
 50 |   *  @brief   Data transfers functions
 51 |   *
 52 | @verbatim
 53 |   ==============================================================================
 54 |                       ##### IO operation functions #####
 55 |  ===============================================================================
 56 |  [..]
 57 |     This subsection provides a set of extended functions to manage the SPI
 58 |     data transfers.
 59 | 
 60 |     (#) SPIEx function:
 61 |         (++) HAL_SPIEx_FlushRxFifo()
 62 |         (++) HAL_SPIEx_FlushRxFifo()
 63 |         (++) HAL_SPIEx_EnableLockConfiguration()
 64 |         (++) HAL_SPIEx_ConfigureUnderrun()
 65 | 
 66 | @endverbatim
 67 |   * @{
 68 |   */
 69 | 
 70 | /**
 71 |   * @brief Flush the RX fifo.
 72 |   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains
 73 |   *               the configuration information for the specified SPI module.
 74 |   * @retval HAL status
 75 |   */
 76 | HAL_StatusTypeDef HAL_SPIEx_FlushRxFifo(SPI_HandleTypeDef *hspi)
 77 | {
 78 |   uint8_t  count  = 0;
 79 |   uint32_t itflag = hspi->Instance->SR;
 80 |   __IO uint32_t tmpreg;
 81 | 
 82 |   while (((hspi->Instance->SR & SPI_FLAG_FRLVL) !=  SPI_RX_FIFO_0PACKET) || ((itflag & SPI_FLAG_RXWNE) !=  0UL))
 83 |   {
 84 |     count += (uint8_t)4UL;
 85 |     tmpreg = hspi->Instance->RXDR;
 86 |     UNUSED(tmpreg); /* To avoid GCC warning */
 87 | 
 88 |     if (IS_SPI_HIGHEND_INSTANCE(hspi->Instance))
 89 |     {
 90 |       if (count > SPI_HIGHEND_FIFO_SIZE)
 91 |       {
 92 |         return HAL_TIMEOUT;
 93 |       }
 94 |     }
 95 |     else
 96 |     {
 97 |       if (count > SPI_LOWEND_FIFO_SIZE)
 98 |       {
 99 |         return HAL_TIMEOUT;
100 |       }
101 |     }
102 |   }
103 |   return HAL_OK;
104 | }
105 | 
106 | 
107 | /**
108 |   * @brief  Enable the Lock for the AF configuration of associated IOs
109 |   *         and write protect the Content of Configuration register 2
110 |   *         when SPI is enabled
111 |   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains
112 |   *               the configuration information for SPI module.
113 |   * @retval None
114 |   */
115 | HAL_StatusTypeDef HAL_SPIEx_EnableLockConfiguration(SPI_HandleTypeDef *hspi)
116 | {
117 |   HAL_StatusTypeDef errorcode = HAL_OK;
118 | 
119 |   /* Process Locked */
120 |   __HAL_LOCK(hspi);
121 | 
122 |   if (hspi->State != HAL_SPI_STATE_READY)
123 |   {
124 |     errorcode = HAL_BUSY;
125 |     hspi->State = HAL_SPI_STATE_READY;
126 |     /* Process Unlocked */
127 |     __HAL_UNLOCK(hspi);
128 |     return errorcode;
129 |   }
130 | 
131 |   /* Check if the SPI is disabled to edit IOLOCK bit */
132 |   if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)
133 |   {
134 |     SET_BIT(hspi->Instance->CR1, SPI_CR1_IOLOCK);
135 |   }
136 |   else
137 |   {
138 |     /* Disable SPI peripheral */
139 |     __HAL_SPI_DISABLE(hspi);
140 | 
141 |     SET_BIT(hspi->Instance->CR1, SPI_CR1_IOLOCK);
142 | 
143 |     /* Enable SPI peripheral */
144 |     __HAL_SPI_ENABLE(hspi);
145 |   }
146 | 
147 |   hspi->State = HAL_SPI_STATE_READY;
148 |   /* Process Unlocked */
149 |   __HAL_UNLOCK(hspi);
150 |   return errorcode;
151 | }
152 | 
153 | /**
154 |   * @brief  Configure the UNDERRUN condition and behavior of slave transmitter.
155 |   * @param  hspi: pointer to a SPI_HandleTypeDef structure that contains
156 |   *               the configuration information for SPI module.
157 |   * @param  UnderrunDetection : Detection of underrun condition at slave transmitter
158 |   *                             This parameter can be a value of @ref SPI_Underrun_Detection.
159 |   * @param  UnderrunBehaviour : Behavior of slave transmitter at underrun condition
160 |   *                             This parameter can be a value of @ref SPI_Underrun_Behaviour.
161 |   * @retval None
162 |   */
163 | HAL_StatusTypeDef HAL_SPIEx_ConfigureUnderrun(SPI_HandleTypeDef *hspi, uint32_t UnderrunDetection, uint32_t UnderrunBehaviour)
164 | {
165 |   HAL_StatusTypeDef errorcode = HAL_OK;
166 | 
167 |   /* Process Locked */
168 |   __HAL_LOCK(hspi);
169 | 
170 |   /* Check State and Insure that Underrun configuration is managed only by Salve */
171 |   if ((hspi->State != HAL_SPI_STATE_READY) || (hspi->Init.Mode != SPI_MODE_SLAVE))
172 |   {
173 |     errorcode = HAL_BUSY;
174 |     hspi->State = HAL_SPI_STATE_READY;
175 |     /* Process Unlocked */
176 |     __HAL_UNLOCK(hspi);
177 |     return errorcode;
178 |   }
179 | 
180 |   /* Check the parameters */
181 |   assert_param(IS_SPI_UNDERRUN_DETECTION(UnderrunDetection));
182 |   assert_param(IS_SPI_UNDERRUN_BEHAVIOUR(UnderrunBehaviour));
183 | 
184 |   /* Check if the SPI is disabled to edit CFG1 register */
185 |   if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)
186 |   {
187 |     /* Configure Underrun fields */
188 |     MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRDET, UnderrunDetection);
189 |     MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRCFG, UnderrunBehaviour);
190 |   }
191 |   else
192 |   {
193 |     /* Disable SPI peripheral */
194 |     __HAL_SPI_DISABLE(hspi);
195 | 
196 |     /* Configure Underrun fields */
197 |     MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRDET, UnderrunDetection);
198 |     MODIFY_REG(hspi->Instance->CFG1, SPI_CFG1_UDRCFG, UnderrunBehaviour);
199 | 
200 |     /* Enable SPI peripheral */
201 |     __HAL_SPI_ENABLE(hspi);
202 |   }
203 | 
204 | 
205 |   hspi->State = HAL_SPI_STATE_READY;
206 |   /* Process Unlocked */
207 |   __HAL_UNLOCK(hspi);
208 |   return errorcode;
209 | }
210 | 
211 | /**
212 |   * @}
213 |   */
214 | 
215 | /**
216 |   * @}
217 |   */
218 | 
219 | #endif /* HAL_SPI_MODULE_ENABLED */
220 | 
221 | /**
222 |   * @}
223 |   */
224 | 
225 | /**
226 |   * @}
227 |   */
228 | 
229 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
230 | 


--------------------------------------------------------------------------------
/STM32_SimpleFOC_InlineCurrentSense.launch:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 2 | <launchConfiguration type="com.st.stm32cube.ide.mcu.debug.launch.launchConfigurationType">
 3 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.launch.access_port_id" value="0"/>
 4 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.launch.enable_live_expr" value="true"/>
 5 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.launch.enable_swv" value="false"/>
 6 |     <intAttribute key="com.st.stm32cube.ide.mcu.debug.launch.formatVersion" value="2"/>
 7 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.launch.ip_address_local" value="localhost"/>
 8 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.launch.loadList" value="{&quot;fItems&quot;:[{&quot;fIsFromMainTab&quot;:true,&quot;fPath&quot;:&quot;Debug\\STM32_SimpleFOC_InlineCurrentSense.elf&quot;,&quot;fProjectName&quot;:&quot;STM32_SimpleFOC_InlineCurrentSense&quot;,&quot;fPerformBuild&quot;:true,&quot;fDownload&quot;:true,&quot;fLoadSymbols&quot;:true}]}"/>
 9 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.launch.override_start_address_mode" value="default"/>
10 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.launch.remoteCommand" value="target remote"/>
11 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.launch.startServer" value="true"/>
12 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.launch.startuptab.exception.divby0" value="true"/>
13 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.launch.startuptab.exception.unaligned" value="false"/>
14 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.launch.startuptab.haltonexception" value="true"/>
15 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.launch.swd_mode" value="true"/>
16 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.launch.swv_port" value="61235"/>
17 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.launch.swv_trace_div" value="8"/>
18 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.launch.swv_trace_hclk" value="16000000"/>
19 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.launch.useRemoteTarget" value="true"/>
20 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.launch.vector_table" value=""/>
21 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.launch.verify_flash_download" value="true"/>
22 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.cti_allow_halt" value="false"/>
23 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.cti_signal_halt" value="false"/>
24 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.enable_external_loader" value="false"/>
25 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.enable_logging" value="false"/>
26 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.enable_max_halt_delay" value="false"/>
27 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.enable_shared_stlink" value="false"/>
28 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.external_loader" value=""/>
29 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.external_loader_init" value="false"/>
30 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.frequency" value="0"/>
31 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.halt_all_on_reset" value="false"/>
32 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.log_file" value="C:\Users\natal\Documents\simpleFOC\STM32_SimpleFOC_InlineCurrentSense\Debug\st-link_gdbserver_log.txt"/>
33 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.low_power_debug" value="enable"/>
34 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.max_halt_delay" value="2"/>
35 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.reset_strategy" value="connect_under_reset"/>
36 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.stlink_check_serial_number" value="true"/>
37 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.stlink_txt_serial_number" value="002E00173438511734313939"/>
38 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlink.watchdog_config" value="none"/>
39 |     <stringAttribute key="com.st.stm32cube.ide.mcu.debug.stlinkrestart_configurations" value="{&quot;fItems&quot;:[{&quot;fDisplayName&quot;:&quot;Reset&quot;,&quot;fIsSuppressible&quot;:false,&quot;fResetAttribute&quot;:&quot;Reset&quot;,&quot;fResetStrategies&quot;:[{&quot;fDisplayName&quot;:&quot;Reset&quot;,&quot;fLaunchAttribute&quot;:&quot;monitor reset&quot;,&quot;fGdbCommands&quot;:[&quot;monitor reset&quot;],&quot;fCmdOptions&quot;:[]},{&quot;fDisplayName&quot;:&quot;None&quot;,&quot;fLaunchAttribute&quot;:&quot;no_reset&quot;,&quot;fGdbCommands&quot;:[],&quot;fCmdOptions&quot;:[]}],&quot;fGdbCommandGroup&quot;:{&quot;name&quot;:&quot;Additional commands&quot;,&quot;commands&quot;:[]}}]}"/>
40 |     <booleanAttribute key="com.st.stm32cube.ide.mcu.debug.swv.swv_wait_for_sync" value="true"/>
41 |     <booleanAttribute key="org.eclipse.cdt.debug.gdbjtag.core.doHalt" value="false"/>
42 |     <booleanAttribute key="org.eclipse.cdt.debug.gdbjtag.core.doReset" value="false"/>
43 |     <stringAttribute key="org.eclipse.cdt.debug.gdbjtag.core.initCommands" value=""/>
44 |     <stringAttribute key="org.eclipse.cdt.debug.gdbjtag.core.ipAddress" value="localhost"/>
45 |     <stringAttribute key="org.eclipse.cdt.debug.gdbjtag.core.jtagDevice" value="ST-LINK (ST-LINK GDB server)"/>
46 |     <stringAttribute key="org.eclipse.cdt.debug.gdbjtag.core.pcRegister" value=""/>
47 |     <intAttribute key="org.eclipse.cdt.debug.gdbjtag.core.portNumber" value="61234"/>
48 |     <stringAttribute key="org.eclipse.cdt.debug.gdbjtag.core.runCommands" value=""/>
49 |     <booleanAttribute key="org.eclipse.cdt.debug.gdbjtag.core.setPcRegister" value="false"/>
50 |     <booleanAttribute key="org.eclipse.cdt.debug.gdbjtag.core.setResume" value="true"/>
51 |     <booleanAttribute key="org.eclipse.cdt.debug.gdbjtag.core.setStopAt" value="true"/>
52 |     <stringAttribute key="org.eclipse.cdt.debug.gdbjtag.core.stopAt" value="main"/>
53 |     <stringAttribute key="org.eclipse.cdt.dsf.gdb.DEBUG_NAME" value="arm-none-eabi-gdb"/>
54 |     <booleanAttribute key="org.eclipse.cdt.dsf.gdb.NON_STOP" value="true"/>
55 |     <booleanAttribute key="org.eclipse.cdt.dsf.gdb.UPDATE_THREADLIST_ON_SUSPEND" value="false"/>
56 |     <intAttribute key="org.eclipse.cdt.launch.ATTR_BUILD_BEFORE_LAUNCH_ATTR" value="2"/>
57 |     <stringAttribute key="org.eclipse.cdt.launch.COREFILE_PATH" value=""/>
58 |     <stringAttribute key="org.eclipse.cdt.launch.DEBUGGER_START_MODE" value="remote"/>
59 |     <booleanAttribute key="org.eclipse.cdt.launch.DEBUGGER_STOP_AT_MAIN" value="true"/>
60 |     <stringAttribute key="org.eclipse.cdt.launch.DEBUGGER_STOP_AT_MAIN_SYMBOL" value="main"/>
61 |     <stringAttribute key="org.eclipse.cdt.launch.PROGRAM_NAME" value="Debug\STM32_SimpleFOC_InlineCurrentSense.elf"/>
62 |     <stringAttribute key="org.eclipse.cdt.launch.PROJECT_ATTR" value="STM32_SimpleFOC_InlineCurrentSense"/>
63 |     <booleanAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_AUTO_ATTR" value="true"/>
64 |     <stringAttribute key="org.eclipse.cdt.launch.PROJECT_BUILD_CONFIG_ID_ATTR" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.config.exe.debug.1460927330"/>
65 |     <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
66 |         <listEntry value="/STM32_SimpleFOC_InlineCurrentSense"/>
67 |     </listAttribute>
68 |     <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
69 |         <listEntry value="4"/>
70 |     </listAttribute>
71 |     <stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&#13;&#10;&lt;memoryBlockExpressionList context=&quot;reserved-for-future-use&quot;/&gt;&#13;&#10;"/>
72 |     <stringAttribute key="process_factory_id" value="org.eclipse.cdt.dsf.gdb.GdbProcessFactory"/>
73 | </launchConfiguration>
74 | 


--------------------------------------------------------------------------------
/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_def.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |   ******************************************************************************
  3 |   * @file    stm32h7xx_hal_def.h
  4 |   * @author  MCD Application Team
  5 |   * @brief   This file contains HAL common defines, enumeration, macros and
  6 |   *          structures definitions.
  7 |   ******************************************************************************
  8 |   * @attention
  9 |   *
 10 |   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
 11 |   * All rights reserved.</center></h2>
 12 |   *
 13 |   * This software component is licensed by ST under BSD 3-Clause license,
 14 |   * the "License"; You may not use this file except in compliance with the
 15 |   * License. You may obtain a copy of the License at:
 16 |   *                        opensource.org/licenses/BSD-3-Clause
 17 |   *
 18 |   ******************************************************************************
 19 |   */
 20 | 
 21 | /* Define to prevent recursive inclusion -------------------------------------*/
 22 | #ifndef STM32H7xx_HAL_DEF
 23 | #define STM32H7xx_HAL_DEF
 24 | 
 25 | #ifdef __cplusplus
 26 |  extern "C" {
 27 | #endif
 28 | 
 29 | /* Includes ------------------------------------------------------------------*/
 30 | #include "stm32h7xx.h"
 31 | #include "Legacy/stm32_hal_legacy.h"
 32 | #include <stddef.h>
 33 | #include <math.h>
 34 | 
 35 | /* Exported types ------------------------------------------------------------*/
 36 | 
 37 | /**
 38 |   * @brief  HAL Status structures definition
 39 |   */
 40 | typedef enum
 41 | {
 42 |   HAL_OK       = 0x00,
 43 |   HAL_ERROR    = 0x01,
 44 |   HAL_BUSY     = 0x02,
 45 |   HAL_TIMEOUT  = 0x03
 46 | } HAL_StatusTypeDef;
 47 | 
 48 | /**
 49 |   * @brief  HAL Lock structures definition
 50 |   */
 51 | typedef enum
 52 | {
 53 |   HAL_UNLOCKED = 0x00,
 54 |   HAL_LOCKED   = 0x01
 55 | } HAL_LockTypeDef;
 56 | 
 57 | /* Exported macro ------------------------------------------------------------*/
 58 | 
 59 | #define HAL_MAX_DELAY      0xFFFFFFFFU
 60 | 
 61 | #define HAL_IS_BIT_SET(REG, BIT)         (((REG) & (BIT)) == (BIT))
 62 | #define HAL_IS_BIT_CLR(REG, BIT)         (((REG) & (BIT)) == 0U)
 63 | 
 64 | #define __HAL_LINKDMA(__HANDLE__, __PPP_DMA_FIELD__, __DMA_HANDLE__)               \
 65 |                         do{                                                      \
 66 |                               (__HANDLE__)->__PPP_DMA_FIELD__ = &(__DMA_HANDLE__); \
 67 |                               (__DMA_HANDLE__).Parent = (__HANDLE__);             \
 68 |                           } while(0)
 69 | 
 70 | #define UNUSED(x) ((void)(x))
 71 | 
 72 | /** @brief Reset the Handle's State field.
 73 |   * @param __HANDLE__: specifies the Peripheral Handle.
 74 |   * @note  This macro can be used for the following purpose: 
 75 |   *          - When the Handle is declared as local variable; before passing it as parameter
 76 |   *            to HAL_PPP_Init() for the first time, it is mandatory to use this macro 
 77 |   *            to set to 0 the Handle's "State" field.
 78 |   *            Otherwise, "State" field may have any random value and the first time the function 
 79 |   *            HAL_PPP_Init() is called, the low level hardware initialization will be missed
 80 |   *            (i.e. HAL_PPP_MspInit() will not be executed).
 81 |   *          - When there is a need to reconfigure the low level hardware: instead of calling
 82 |   *            HAL_PPP_DeInit() then HAL_PPP_Init(), user can make a call to this macro then HAL_PPP_Init().
 83 |   *            In this later function, when the Handle's "State" field is set to 0, it will execute the function
 84 |   *            HAL_PPP_MspInit() which will reconfigure the low level hardware.
 85 |   * @retval None
 86 |   */
 87 | #define __HAL_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = 0)
 88 | 
 89 | #if (USE_RTOS == 1)
 90 |   #error " USE_RTOS should be 0 in the current HAL release "
 91 | #else
 92 |   #define __HAL_LOCK(__HANDLE__)                                           \
 93 |                                 do{                                        \
 94 |                                     if((__HANDLE__)->Lock == HAL_LOCKED)   \
 95 |                                     {                                      \
 96 |                                        return HAL_BUSY;                    \
 97 |                                     }                                      \
 98 |                                     else                                   \
 99 |                                     {                                      \
100 |                                        (__HANDLE__)->Lock = HAL_LOCKED;    \
101 |                                     }                                      \
102 |                                   }while (0)
103 | 
104 |   #define __HAL_UNLOCK(__HANDLE__)                                          \
105 |                                   do{                                       \
106 |                                       (__HANDLE__)->Lock = HAL_UNLOCKED;    \
107 |                                     }while (0)
108 | #endif /* USE_RTOS */
109 | 
110 | #if  defined ( __GNUC__ )
111 |   #ifndef __weak
112 |     #define __weak   __attribute__((weak))
113 |   #endif /* __weak */
114 |   #ifndef __packed
115 |     #define __packed __attribute__((__packed__))
116 |   #endif /* __packed */
117 | #endif /* __GNUC__ */
118 | 
119 | 
120 | /* Macro to get variable aligned on 4-bytes, for __ICCARM__ the directive "#pragma data_alignment=4" must be used instead */
121 | #if defined   (__GNUC__)        /* GNU Compiler */
122 |   #ifndef __ALIGN_END
123 |     #define __ALIGN_END    __attribute__ ((aligned (4)))
124 |   #endif /* __ALIGN_END */
125 |   #ifndef __ALIGN_BEGIN
126 |     #define __ALIGN_BEGIN
127 |   #endif /* __ALIGN_BEGIN */
128 | #else
129 |   #ifndef __ALIGN_END
130 |     #define __ALIGN_END
131 |   #endif /* __ALIGN_END */
132 |   #ifndef __ALIGN_BEGIN
133 |     #if defined   (__CC_ARM)      /* ARM Compiler */
134 |       #define __ALIGN_BEGIN    __align(4)
135 |     #elif defined (__ICCARM__)    /* IAR Compiler */
136 |       #define __ALIGN_BEGIN
137 |     #endif /* __CC_ARM */
138 |   #endif /* __ALIGN_BEGIN */
139 | #endif /* __GNUC__ */
140 | 
141 | /* Macro to get variable aligned on 32-bytes,needed for cache maintenance purpose */
142 | #if defined   (__GNUC__)        /* GNU Compiler */
143 |   #define ALIGN_32BYTES(buf)  buf __attribute__ ((aligned (32)))                                    
144 | #elif defined (__ICCARM__)    /* IAR Compiler */
145 |   #define ALIGN_32BYTES(buf) _Pragma("data_alignment=32") buf  
146 | #elif defined   (__CC_ARM)      /* ARM Compiler */
147 |   #define ALIGN_32BYTES(buf) __align(32) buf  
148 | #endif
149 | 
150 | /**
151 |   * @brief  __RAM_FUNC definition
152 |   */
153 | #if defined ( __CC_ARM   )
154 | /* ARM Compiler
155 |    ------------
156 |    RAM functions are defined using the toolchain options.
157 |    Functions that are executed in RAM should reside in a separate source module.
158 |    Using the 'Options for File' dialog you can simply change the 'Code / Const'
159 |    area of a module to a memory space in physical RAM.
160 |    Available memory areas are declared in the 'Target' tab of the 'Options for Target'
161 |    dialog.
162 | */
163 | #define __RAM_FUNC
164 | 
165 | #elif defined ( __ICCARM__ )
166 | /* ICCARM Compiler
167 |    ---------------
168 |    RAM functions are defined using a specific toolchain keyword "__ramfunc".
169 | */
170 | #define __RAM_FUNC __ramfunc
171 | 
172 | #elif defined   (  __GNUC__  )
173 | /* GNU Compiler
174 |    ------------
175 |   RAM functions are defined using a specific toolchain attribute
176 |    "__attribute__((section(".RamFunc")))".
177 | */
178 | #define __RAM_FUNC __attribute__((section(".RamFunc")))
179 | 
180 | #endif
181 | 
182 | #ifdef __cplusplus
183 | }
184 | #endif
185 | 
186 | #endif /* STM32H7xx_HAL_DEF */
187 | 
188 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
189 | 


--------------------------------------------------------------------------------
/Drivers/STM32H7xx_HAL_Driver/Inc/stm32h7xx_hal_hsem.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |   ******************************************************************************
  3 |   * @file    stm32h7xx_hal_hsem.h
  4 |   * @author  MCD Application Team
  5 |   * @brief   Header file of HSEM HAL module.
  6 |   ******************************************************************************
  7 |   * @attention
  8 |   *
  9 |   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
 10 |   * All rights reserved.</center></h2>
 11 |   *
 12 |   * This software component is licensed by ST under BSD 3-Clause license,
 13 |   * the "License"; You may not use this file except in compliance with the
 14 |   * License. You may obtain a copy of the License at:
 15 |   *                        opensource.org/licenses/BSD-3-Clause
 16 |   *
 17 |   ******************************************************************************
 18 |   */
 19 | 
 20 | /* Define to prevent recursive inclusion -------------------------------------*/
 21 | #ifndef STM32H7xx_HAL_HSEM_H
 22 | #define STM32H7xx_HAL_HSEM_H
 23 | 
 24 | #ifdef __cplusplus
 25 | extern "C" {
 26 | #endif
 27 | 
 28 | /* Includes ------------------------------------------------------------------*/
 29 | #include "stm32h7xx_hal_def.h"
 30 | 
 31 | /** @addtogroup STM32H7xx_HAL_Driver
 32 |    * @{
 33 |    */
 34 | 
 35 | /** @addtogroup HSEM
 36 |    * @{
 37 |    */
 38 | 
 39 | /* Exported macro ------------------------------------------------------------*/
 40 | /** @defgroup HSEM_Exported_Macros HSEM Exported Macros
 41 |   * @{
 42 |   */
 43 | 
 44 | /**
 45 |   * @brief  SemID to mask helper Macro.
 46 |   * @param  __SEMID__: semaphore ID from 0 to 31
 47 |   * @retval Semaphore Mask.
 48 |   */
 49 | #define __HAL_HSEM_SEMID_TO_MASK(__SEMID__) (1 << (__SEMID__))
 50 | 
 51 | /**
 52 |   * @brief  Enables the specified HSEM interrupts.
 53 |   * @param  __SEM_MASK__: semaphores Mask
 54 |   * @retval None.
 55 |   */
 56 | #if defined(DUAL_CORE)
 57 | #define __HAL_HSEM_ENABLE_IT(__SEM_MASK__) ((((SCB->CPUID & 0x000000F0) >> 4 )== 0x7) ? \
 58 |                                             (HSEM->C1IER |= (__SEM_MASK__)) : \
 59 |                                             (HSEM->C2IER |= (__SEM_MASK__)))
 60 | #else
 61 | #define __HAL_HSEM_ENABLE_IT(__SEM_MASK__) (HSEM->IER |= (__SEM_MASK__))
 62 | #endif /* DUAL_CORE */
 63 | /**
 64 |   * @brief  Disables the specified HSEM interrupts.
 65 |   * @param  __SEM_MASK__: semaphores Mask
 66 |   * @retval None.
 67 |   */
 68 | #if defined(DUAL_CORE)
 69 | #define __HAL_HSEM_DISABLE_IT(__SEM_MASK__) ((((SCB->CPUID & 0x000000F0) >> 4 )== 0x7) ? \
 70 |                                              (HSEM->C1IER &= ~(__SEM_MASK__)) :       \
 71 |                                              (HSEM->C2IER &= ~(__SEM_MASK__)))
 72 | #else
 73 | #define __HAL_HSEM_DISABLE_IT(__SEM_MASK__) (HSEM->IER &= ~(__SEM_MASK__))
 74 | #endif /* DUAL_CORE */
 75 | 
 76 | /**
 77 |   * @brief  Checks whether interrupt has occurred or not for semaphores specified by a mask.
 78 |   * @param  __SEM_MASK__: semaphores Mask
 79 |   * @retval semaphores Mask : Semaphores where an interrupt occurred.
 80 |   */
 81 | #if defined(DUAL_CORE)
 82 | #define __HAL_HSEM_GET_IT(__SEM_MASK__) ((((SCB->CPUID & 0x000000F0) >> 4 )== 0x7) ? \
 83 |                                          ((__SEM_MASK__) & HSEM->C1MISR) :        \
 84 |                                          ((__SEM_MASK__) & HSEM->C2MISR1))
 85 | #else
 86 | #define __HAL_HSEM_GET_IT(__SEM_MASK__) ((__SEM_MASK__) & HSEM->MISR)
 87 | #endif /* DUAL_CORE */
 88 | 
 89 | /**
 90 |   * @brief  Get the semaphores release status flags.
 91 |   * @param  __SEM_MASK__: semaphores Mask
 92 |   * @retval semaphores Mask : Semaphores where Release flags rise.
 93 |   */
 94 | #if defined(DUAL_CORE)
 95 | #define __HAL_HSEM_GET_FLAG(__SEM_MASK__) ((((SCB->CPUID & 0x000000F0) >> 4 )== 0x7) ? \
 96 |                                            (__SEM_MASK__) & HSEM->C1ISR :           \
 97 |                                            (__SEM_MASK__) & HSEM->C2ISR)
 98 | #else
 99 | #define __HAL_HSEM_GET_FLAG(__SEM_MASK__) ((__SEM_MASK__) & HSEM->ISR)
100 | #endif /* DUAL_CORE */
101 | 
102 | /**
103 |   * @brief  Clears the HSEM Interrupt flags.
104 |   * @param  __SEM_MASK__: semaphores Mask
105 |   * @retval None.
106 |   */
107 | #if defined(DUAL_CORE)
108 | #define __HAL_HSEM_CLEAR_FLAG(__SEM_MASK__) ((((SCB->CPUID & 0x000000F0) >> 4 )== 0x7) ? \
109 |                                              (HSEM->C1ICR |= (__SEM_MASK__)) :        \
110 |                                              (HSEM->C2ICR |= (__SEM_MASK__)))
111 | #else
112 | #define __HAL_HSEM_CLEAR_FLAG(__SEM_MASK__) (HSEM->ICR |= (__SEM_MASK__))
113 | #endif /* DUAL_CORE */
114 | 
115 | /**
116 |   * @}
117 |   */
118 | 
119 | /* Exported functions --------------------------------------------------------*/
120 | /** @defgroup HSEM_Exported_Functions HSEM Exported Functions
121 |   * @{
122 |   */
123 | 
124 | /** @addtogroup HSEM_Exported_Functions_Group1 Take and Release functions
125 |   * @brief    HSEM Take and Release functions
126 |   * @{
127 |   */
128 | 
129 | /* HSEM semaphore take (lock) using 2-Step  method ****************************/
130 | HAL_StatusTypeDef  HAL_HSEM_Take(uint32_t SemID, uint32_t ProcessID);
131 | /* HSEM semaphore fast take (lock) using 1-Step  method ***********************/
132 | HAL_StatusTypeDef  HAL_HSEM_FastTake(uint32_t SemID);
133 | /* HSEM Check semaphore state Taken or not   **********************************/
134 | uint32_t HAL_HSEM_IsSemTaken(uint32_t SemID);
135 | /* HSEM Release  **************************************************************/
136 | void  HAL_HSEM_Release(uint32_t SemID, uint32_t ProcessID);
137 | /* HSEM Release All************************************************************/
138 | void HAL_HSEM_ReleaseAll(uint32_t Key, uint32_t CoreID);
139 | 
140 | /**
141 |   * @}
142 |   */
143 | 
144 | /** @addtogroup HSEM_Exported_Functions_Group2 HSEM Set and Get Key functions
145 |   * @brief    HSEM Set and Get Key functions.
146 |   * @{
147 |   */
148 | /* HSEM Set Clear Key *********************************************************/
149 | void  HAL_HSEM_SetClearKey(uint32_t Key);
150 | /* HSEM Get Clear Key *********************************************************/
151 | uint32_t HAL_HSEM_GetClearKey(void);
152 | /**
153 |   * @}
154 |   */
155 | 
156 | /** @addtogroup HSEM_Exported_Functions_Group3
157 |   * @brief   HSEM Notification functions
158 |   * @{
159 |   */
160 | /* HSEM Activate HSEM Notification (When a semaphore is released) ) *****************/
161 | void HAL_HSEM_ActivateNotification(uint32_t SemMask);
162 | /* HSEM Deactivate HSEM Notification (When a semaphore is released)  ****************/
163 | void HAL_HSEM_DeactivateNotification(uint32_t SemMask);
164 | /* HSEM Free Callback (When a semaphore is released)  *******************************/
165 | void HAL_HSEM_FreeCallback(uint32_t SemMask);
166 | /* HSEM IRQ Handler  **********************************************************/
167 | void HAL_HSEM_IRQHandler(void);
168 | 
169 | /**
170 |   * @}
171 |   */
172 | 
173 | /**
174 |   * @}
175 |   */
176 | 
177 | /* Private macros ------------------------------------------------------------*/
178 | /** @defgroup HSEM_Private_Macros HSEM Private Macros
179 |   * @{
180 |   */
181 | 
182 | #define IS_HSEM_SEMID(__SEMID__) ((__SEMID__) <= HSEM_SEMID_MAX )
183 | 
184 | #define IS_HSEM_PROCESSID(__PROCESSID__) ((__PROCESSID__) <= HSEM_PROCESSID_MAX )
185 | 
186 | #define IS_HSEM_KEY(__KEY__) ((__KEY__) <= HSEM_CLEAR_KEY_MAX )
187 | 
188 | #if defined(DUAL_CORE)
189 | #define IS_HSEM_COREID(__COREID__) (((__COREID__) == HSEM_CPU1_COREID) || \
190 |                                     ((__COREID__) == HSEM_CPU2_COREID))
191 | #else
192 | #define IS_HSEM_COREID(__COREID__) ((__COREID__) == HSEM_CPU1_COREID)
193 | #endif
194 | 
195 | 
196 | /**
197 |   * @}
198 |   */
199 | 
200 | /**
201 |   * @}
202 |   */
203 | 
204 | /**
205 |   * @}
206 |   */
207 | 
208 | #ifdef __cplusplus
209 | }
210 | #endif
211 | 
212 | #endif /* STM32H7xx_HAL_HSEM_H */
213 | 
214 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
215 | 


--------------------------------------------------------------------------------
/Core/Src/stm32h7xx_it.c:
--------------------------------------------------------------------------------
  1 | /* USER CODE BEGIN Header */
  2 | /**
  3 |   ******************************************************************************
  4 |   * @file    stm32h7xx_it.c
  5 |   * @brief   Interrupt Service Routines.
  6 |   ******************************************************************************
  7 |   * @attention
  8 |   *
  9 |   * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
 10 |   * All rights reserved.</center></h2>
 11 |   *
 12 |   * This software component is licensed by ST under BSD 3-Clause license,
 13 |   * the "License"; You may not use this file except in compliance with the
 14 |   * License. You may obtain a copy of the License at:
 15 |   *                        opensource.org/licenses/BSD-3-Clause
 16 |   *
 17 |   ******************************************************************************
 18 |   */
 19 | /* USER CODE END Header */
 20 | 
 21 | /* Includes ------------------------------------------------------------------*/
 22 | #include "main.h"
 23 | #include "stm32h7xx_it.h"
 24 | /* Private includes ----------------------------------------------------------*/
 25 | /* USER CODE BEGIN Includes */
 26 | /* USER CODE END Includes */
 27 | 
 28 | /* Private typedef -----------------------------------------------------------*/
 29 | /* USER CODE BEGIN TD */
 30 | 
 31 | /* USER CODE END TD */
 32 | 
 33 | /* Private define ------------------------------------------------------------*/
 34 | /* USER CODE BEGIN PD */
 35 | 
 36 | /* USER CODE END PD */
 37 | 
 38 | /* Private macro -------------------------------------------------------------*/
 39 | /* USER CODE BEGIN PM */
 40 | 
 41 | /* USER CODE END PM */
 42 | 
 43 | /* Private variables ---------------------------------------------------------*/
 44 | /* USER CODE BEGIN PV */
 45 | 
 46 | /* USER CODE END PV */
 47 | 
 48 | /* Private function prototypes -----------------------------------------------*/
 49 | /* USER CODE BEGIN PFP */
 50 | 
 51 | /* USER CODE END PFP */
 52 | 
 53 | /* Private user code ---------------------------------------------------------*/
 54 | /* USER CODE BEGIN 0 */
 55 | 
 56 | /* USER CODE END 0 */
 57 | 
 58 | /* External variables --------------------------------------------------------*/
 59 | extern SPI_HandleTypeDef hspi1;
 60 | extern TIM_HandleTypeDef htim1;
 61 | extern TIM_HandleTypeDef htim2;
 62 | /* USER CODE BEGIN EV */
 63 | 
 64 | /* USER CODE END EV */
 65 | 
 66 | /******************************************************************************/
 67 | /*           Cortex Processor Interruption and Exception Handlers          */
 68 | /******************************************************************************/
 69 | /**
 70 |   * @brief This function handles Non maskable interrupt.
 71 |   */
 72 | void NMI_Handler(void)
 73 | {
 74 |   /* USER CODE BEGIN NonMaskableInt_IRQn 0 */
 75 | 
 76 |   /* USER CODE END NonMaskableInt_IRQn 0 */
 77 |   /* USER CODE BEGIN NonMaskableInt_IRQn 1 */
 78 |   while (1)
 79 |   {
 80 |   }
 81 |   /* USER CODE END NonMaskableInt_IRQn 1 */
 82 | }
 83 | 
 84 | /**
 85 |   * @brief This function handles Hard fault interrupt.
 86 |   */
 87 | void HardFault_Handler(void)
 88 | {
 89 |   /* USER CODE BEGIN HardFault_IRQn 0 */
 90 | 
 91 |   /* USER CODE END HardFault_IRQn 0 */
 92 |   while (1)
 93 |   {
 94 |     /* USER CODE BEGIN W1_HardFault_IRQn 0 */
 95 |     /* USER CODE END W1_HardFault_IRQn 0 */
 96 |   }
 97 | }
 98 | 
 99 | /**
100 |   * @brief This function handles Memory management fault.
101 |   */
102 | void MemManage_Handler(void)
103 | {
104 |   /* USER CODE BEGIN MemoryManagement_IRQn 0 */
105 | 
106 |   /* USER CODE END MemoryManagement_IRQn 0 */
107 |   while (1)
108 |   {
109 |     /* USER CODE BEGIN W1_MemoryManagement_IRQn 0 */
110 |     /* USER CODE END W1_MemoryManagement_IRQn 0 */
111 |   }
112 | }
113 | 
114 | /**
115 |   * @brief This function handles Pre-fetch fault, memory access fault.
116 |   */
117 | void BusFault_Handler(void)
118 | {
119 |   /* USER CODE BEGIN BusFault_IRQn 0 */
120 | 
121 |   /* USER CODE END BusFault_IRQn 0 */
122 |   while (1)
123 |   {
124 |     /* USER CODE BEGIN W1_BusFault_IRQn 0 */
125 |     /* USER CODE END W1_BusFault_IRQn 0 */
126 |   }
127 | }
128 | 
129 | /**
130 |   * @brief This function handles Undefined instruction or illegal state.
131 |   */
132 | void UsageFault_Handler(void)
133 | {
134 |   /* USER CODE BEGIN UsageFault_IRQn 0 */
135 | 
136 |   /* USER CODE END UsageFault_IRQn 0 */
137 |   while (1)
138 |   {
139 |     /* USER CODE BEGIN W1_UsageFault_IRQn 0 */
140 |     /* USER CODE END W1_UsageFault_IRQn 0 */
141 |   }
142 | }
143 | 
144 | /**
145 |   * @brief This function handles System service call via SWI instruction.
146 |   */
147 | void SVC_Handler(void)
148 | {
149 |   /* USER CODE BEGIN SVCall_IRQn 0 */
150 | 
151 |   /* USER CODE END SVCall_IRQn 0 */
152 |   /* USER CODE BEGIN SVCall_IRQn 1 */
153 | 
154 |   /* USER CODE END SVCall_IRQn 1 */
155 | }
156 | 
157 | /**
158 |   * @brief This function handles Debug monitor.
159 |   */
160 | void DebugMon_Handler(void)
161 | {
162 |   /* USER CODE BEGIN DebugMonitor_IRQn 0 */
163 | 
164 |   /* USER CODE END DebugMonitor_IRQn 0 */
165 |   /* USER CODE BEGIN DebugMonitor_IRQn 1 */
166 | 
167 |   /* USER CODE END DebugMonitor_IRQn 1 */
168 | }
169 | 
170 | /**
171 |   * @brief This function handles Pendable request for system service.
172 |   */
173 | void PendSV_Handler(void)
174 | {
175 |   /* USER CODE BEGIN PendSV_IRQn 0 */
176 | 
177 |   /* USER CODE END PendSV_IRQn 0 */
178 |   /* USER CODE BEGIN PendSV_IRQn 1 */
179 | 
180 |   /* USER CODE END PendSV_IRQn 1 */
181 | }
182 | 
183 | /**
184 |   * @brief This function handles System tick timer.
185 |   */
186 | void SysTick_Handler(void)
187 | {
188 |   /* USER CODE BEGIN SysTick_IRQn 0 */
189 | 
190 |   /* USER CODE END SysTick_IRQn 0 */
191 |   HAL_IncTick();
192 |   /* USER CODE BEGIN SysTick_IRQn 1 */
193 | 
194 |   /* USER CODE END SysTick_IRQn 1 */
195 | }
196 | 
197 | /******************************************************************************/
198 | /* STM32H7xx Peripheral Interrupt Handlers                                    */
199 | /* Add here the Interrupt Handlers for the used peripherals.                  */
200 | /* For the available peripheral interrupt handler names,                      */
201 | /* please refer to the startup file (startup_stm32h7xx.s).                    */
202 | /******************************************************************************/
203 | 
204 | /**
205 |   * @brief This function handles EXTI line[9:5] interrupts.
206 |   */
207 | void EXTI9_5_IRQHandler(void)
208 | {
209 |   /* USER CODE BEGIN EXTI9_5_IRQn 0 */
210 | 
211 |   /* USER CODE END EXTI9_5_IRQn 0 */
212 |   HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_5);
213 |   /* USER CODE BEGIN EXTI9_5_IRQn 1 */
214 | 
215 |   /* USER CODE END EXTI9_5_IRQn 1 */
216 | }
217 | 
218 | /**
219 |   * @brief This function handles TIM1 update interrupt.
220 |   */
221 | void TIM1_UP_IRQHandler(void)
222 | {
223 |   /* USER CODE BEGIN TIM1_UP_IRQn 0 */
224 | 
225 |   /* USER CODE END TIM1_UP_IRQn 0 */
226 |   HAL_TIM_IRQHandler(&htim1);
227 |   /* USER CODE BEGIN TIM1_UP_IRQn 1 */
228 | 
229 |   /* USER CODE END TIM1_UP_IRQn 1 */
230 | }
231 | 
232 | /**
233 |   * @brief This function handles TIM2 global interrupt.
234 |   */
235 | void TIM2_IRQHandler(void)
236 | {
237 |   /* USER CODE BEGIN TIM2_IRQn 0 */
238 | 
239 |   /* USER CODE END TIM2_IRQn 0 */
240 |   HAL_TIM_IRQHandler(&htim2);
241 |   /* USER CODE BEGIN TIM2_IRQn 1 */
242 | 
243 |   /* USER CODE END TIM2_IRQn 1 */
244 | }
245 | 
246 | /**
247 |   * @brief This function handles SPI1 global interrupt.
248 |   */
249 | void SPI1_IRQHandler(void)
250 | {
251 |   /* USER CODE BEGIN SPI1_IRQn 0 */
252 | 
253 |   /* USER CODE END SPI1_IRQn 0 */
254 |   HAL_SPI_IRQHandler(&hspi1);
255 |   /* USER CODE BEGIN SPI1_IRQn 1 */
256 | 
257 |   /* USER CODE END SPI1_IRQn 1 */
258 | }
259 | 
260 | /**
261 |   * @brief This function handles EXTI line[15:10] interrupts.
262 |   */
263 | void EXTI15_10_IRQHandler(void)
264 | {
265 |   /* USER CODE BEGIN EXTI15_10_IRQn 0 */
266 | 
267 |   /* USER CODE END EXTI15_10_IRQn 0 */
268 |   HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
269 |   HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
270 |   /* USER CODE BEGIN EXTI15_10_IRQn 1 */
271 | 
272 |   /* USER CODE END EXTI15_10_IRQn 1 */
273 | }
274 | 
275 | /* USER CODE BEGIN 1 */
276 | 
277 | /* USER CODE END 1 */
278 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
279 | 


--------------------------------------------------------------------------------
/STM32CubeIDE/.project:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <projectDescription>
  3 | 	<name>STM32_SimpleFOC_InlineCurrentSense</name>
  4 | 	<comment></comment>
  5 | 	<projects>
  6 | 	</projects>
  7 | 	<buildSpec>
  8 | 		<buildCommand>
  9 | 			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
 10 | 			<triggers>clean,full,incremental,</triggers>
 11 | 			<arguments>
 12 | 			</arguments>
 13 | 		</buildCommand>
 14 | 		<buildCommand>
 15 | 			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
 16 | 			<triggers>full,incremental,</triggers>
 17 | 			<arguments>
 18 | 			</arguments>
 19 | 		</buildCommand>
 20 | 	</buildSpec>
 21 | 	<natures>
 22 | 		<nature>com.st.stm32cube.ide.mcu.MCUProjectNature</nature>
 23 | 		<nature>org.eclipse.cdt.core.cnature</nature>
 24 | 		<nature>com.st.stm32cube.ide.mcu.MCUCubeIdeServicesRevAev2ProjectNature</nature>
 25 | 		<nature>com.st.stm32cube.ide.mcu.MCUNonUnderRootProjectNature</nature>
 26 | 		<nature>com.st.stm32cube.ide.mcu.MCUCubeProjectNature</nature>
 27 | 		<nature>com.st.stm32cube.ide.mcu.MCUAdvancedStructureProjectNature</nature>
 28 | 		<nature>com.st.stm32cube.ide.mcu.MCUEndUserDisabledTrustZoneProjectNature</nature>
 29 | 		<nature>com.st.stm32cube.ide.mcu.MCUSingleCpuProjectNature</nature>
 30 | 		<nature>com.st.stm32cube.ide.mcu.MCURootProjectNature</nature>
 31 | 		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
 32 | 		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
 33 | 	</natures>
 34 | 	<linkedResources>
 35 | 		<link>
 36 | 			<name>STM32_SimpleFOC_InlineCurrentSense.ioc</name>
 37 | 			<type>1</type>
 38 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/STM32_SimpleFOC_InlineCurrentSense.ioc</locationURI>
 39 | 		</link>
 40 | 		<link>
 41 | 			<name>Drivers/CMSIS/system_stm32h7xx.c</name>
 42 | 			<type>1</type>
 43 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Core/Src/system_stm32h7xx.c</locationURI>
 44 | 		</link>
 45 | 		<link>
 46 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal.c</name>
 47 | 			<type>1</type>
 48 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal.c</locationURI>
 49 | 		</link>
 50 | 		<link>
 51 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_adc.c</name>
 52 | 			<type>1</type>
 53 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_adc.c</locationURI>
 54 | 		</link>
 55 | 		<link>
 56 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_adc_ex.c</name>
 57 | 			<type>1</type>
 58 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_adc_ex.c</locationURI>
 59 | 		</link>
 60 | 		<link>
 61 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_cortex.c</name>
 62 | 			<type>1</type>
 63 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_cortex.c</locationURI>
 64 | 		</link>
 65 | 		<link>
 66 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_dma.c</name>
 67 | 			<type>1</type>
 68 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma.c</locationURI>
 69 | 		</link>
 70 | 		<link>
 71 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_dma_ex.c</name>
 72 | 			<type>1</type>
 73 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_dma_ex.c</locationURI>
 74 | 		</link>
 75 | 		<link>
 76 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_exti.c</name>
 77 | 			<type>1</type>
 78 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_exti.c</locationURI>
 79 | 		</link>
 80 | 		<link>
 81 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_flash.c</name>
 82 | 			<type>1</type>
 83 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash.c</locationURI>
 84 | 		</link>
 85 | 		<link>
 86 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_flash_ex.c</name>
 87 | 			<type>1</type>
 88 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_flash_ex.c</locationURI>
 89 | 		</link>
 90 | 		<link>
 91 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_gpio.c</name>
 92 | 			<type>1</type>
 93 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_gpio.c</locationURI>
 94 | 		</link>
 95 | 		<link>
 96 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_hsem.c</name>
 97 | 			<type>1</type>
 98 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c</locationURI>
 99 | 		</link>
100 | 		<link>
101 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_i2c.c</name>
102 | 			<type>1</type>
103 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c.c</locationURI>
104 | 		</link>
105 | 		<link>
106 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_i2c_ex.c</name>
107 | 			<type>1</type>
108 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_i2c_ex.c</locationURI>
109 | 		</link>
110 | 		<link>
111 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_mdma.c</name>
112 | 			<type>1</type>
113 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_mdma.c</locationURI>
114 | 		</link>
115 | 		<link>
116 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_pwr.c</name>
117 | 			<type>1</type>
118 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr.c</locationURI>
119 | 		</link>
120 | 		<link>
121 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_pwr_ex.c</name>
122 | 			<type>1</type>
123 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_pwr_ex.c</locationURI>
124 | 		</link>
125 | 		<link>
126 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_rcc.c</name>
127 | 			<type>1</type>
128 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc.c</locationURI>
129 | 		</link>
130 | 		<link>
131 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_rcc_ex.c</name>
132 | 			<type>1</type>
133 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_rcc_ex.c</locationURI>
134 | 		</link>
135 | 		<link>
136 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_spi.c</name>
137 | 			<type>1</type>
138 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_spi.c</locationURI>
139 | 		</link>
140 | 		<link>
141 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_spi_ex.c</name>
142 | 			<type>1</type>
143 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_spi_ex.c</locationURI>
144 | 		</link>
145 | 		<link>
146 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_tim.c</name>
147 | 			<type>1</type>
148 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_tim.c</locationURI>
149 | 		</link>
150 | 		<link>
151 | 			<name>Drivers/STM32H7xx_HAL_Driver/stm32h7xx_hal_tim_ex.c</name>
152 | 			<type>1</type>
153 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_tim_ex.c</locationURI>
154 | 		</link>
155 | 		<link>
156 | 			<name>Application/User/Core/adc.c</name>
157 | 			<type>1</type>
158 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Core/Src/adc.c</locationURI>
159 | 		</link>
160 | 		<link>
161 | 			<name>Application/User/Core/gpio.c</name>
162 | 			<type>1</type>
163 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Core/Src/gpio.c</locationURI>
164 | 		</link>
165 | 		<link>
166 | 			<name>Application/User/Core/main.c</name>
167 | 			<type>1</type>
168 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Core/Src/main.c</locationURI>
169 | 		</link>
170 | 		<link>
171 | 			<name>Application/User/Core/spi.c</name>
172 | 			<type>1</type>
173 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Core/Src/spi.c</locationURI>
174 | 		</link>
175 | 		<link>
176 | 			<name>Application/User/Core/stm32h7xx_hal_msp.c</name>
177 | 			<type>1</type>
178 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Core/Src/stm32h7xx_hal_msp.c</locationURI>
179 | 		</link>
180 | 		<link>
181 | 			<name>Application/User/Core/stm32h7xx_it.c</name>
182 | 			<type>1</type>
183 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Core/Src/stm32h7xx_it.c</locationURI>
184 | 		</link>
185 | 		<link>
186 | 			<name>Application/User/Core/tim.c</name>
187 | 			<type>1</type>
188 | 			<locationURI>$%7BPARENT-1-PROJECT_LOC%7D/Core/Src/tim.c</locationURI>
189 | 		</link>
190 | 	</linkedResources>
191 | </projectDescription>
192 | 


--------------------------------------------------------------------------------