10 |
BLDC Driver connect
11 |
12 |
13 |
14 | PWM U
27 | 0
28 | PWM V
29 | 0
30 | PWM W
31 | 0
32 |
33 |
34 |
35 |
36 |
45 | 0
49 | 0
50 |
51 |
52 |
53 |
One point mode
54 |
Switch mode
55 |
56 |
57 |
58 |
59 |
60 |
61 | expected position:
70 | 0
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 | expected power:
89 | 0
90 |
91 |
92 |
93 |
94 |
95 |
215 |
216 |
217 |
--------------------------------------------------------------------------------
/Connect/web/js/app.js:
--------------------------------------------------------------------------------
1 | function timedRefresh() {
2 | var timer = setInterval(function() {
3 | eel.get_python_variable()(call_Back);
4 | }, 100);
5 | };
6 | timedRefresh();
7 |
8 | const svgMotorPos = document.getElementById("bldcSetPosition");
9 | const svgMotorPower = document.getElementById("bldcSetPower");
10 |
11 | function call_Back(output){
12 | var partsArray = output.split(',');
13 |
14 | if(partsArray[0] == 0){
15 | document.getElementById("buttonMode1").style.backgroundColor="#52754a";
16 | document.getElementById("buttonMode2").style.backgroundColor="#803b3b";
17 | } else if (partsArray[0] == 1){
18 | document.getElementById("buttonMode1").style.backgroundColor="#803b3b";
19 | document.getElementById("buttonMode2").style.backgroundColor="#52754a";
20 | }
21 |
22 | var bldcAngle = Math.round(partsArray[1] / 11.406);
23 | document.getElementById("bldcPosition").innerHTML = bldcAngle + "°";
24 | var msg = 'rotate(' + bldcAngle + 'deg)'
25 | document.getElementById("motorPosition").style.transformOrigin = "50% 50%";
26 | document.getElementById("motorPosition").style.transform = msg;
27 | document.getElementById("bldcPwmU").innerHTML = partsArray[2];
28 | pwmU = Math.round(partsArray[2]) / 10;
29 | document.getElementById("pwmU").style.transform = "scale(" + pwmU + "%, 100%)";
30 | document.getElementById("bldcPwmV").innerHTML = partsArray[3];
31 | pwmV = Math.round(partsArray[3]) / 10;
32 | document.getElementById("pwmV").style.transform = "scale(" + pwmV + "%, 100%)";
33 | document.getElementById("bldcPwmW").innerHTML = partsArray[4];
34 | pwmW = Math.round(partsArray[4]) / 10;
35 | document.getElementById("pwmW").style.transform = "scale(" + pwmW + "%, 100%)";
36 |
37 | var bldcExpectedAngle = Math.round(partsArray[5] / 11.406);
38 | var msg = 'rotate(' + bldcExpectedAngle + 'deg)'
39 | document.getElementById("motorExpectedPosition").style.transformOrigin = "50% 50%";
40 | document.getElementById("motorExpectedPosition").style.transform = msg;
41 |
42 | var rect = svgMotorPos.getBoundingClientRect();
43 | var pointerPos = Math.round((rect.width / 4095) * partsArray[5]);
44 | document.getElementById("posPointer").style.transform = "translate(" + pointerPos + "px, 0px)";
45 | document.getElementById("bldcExpectedPositionLabel").innerHTML = bldcExpectedAngle + "°";
46 |
47 | var rect2 = svgMotorPower.getBoundingClientRect();
48 | var pointerPower = Math.round((rect2.width / 100) * partsArray[6]);
49 | document.getElementById("powerPointer").style.transform = "translate(" + pointerPower + "px, 0px)";
50 | document.getElementById("bldcExpectedPowerLabel").innerHTML = partsArray[6] + "%";
51 |
52 | actualPower = Math.round(partsArray[7]);
53 | document.getElementById("actualPower").style.transform = "scale(" + actualPower + "%, 100%)";
54 |
55 | console.log(partsArray);
56 | document.getElementById("temperature").innerHTML = partsArray[8] + "°C";
57 | if(partsArray[8] > 30){
58 | document.getElementById("temperature").style.fill = "#992626";
59 | } else {
60 | document.getElementById("temperature").style.fill = "#162818";
61 | }
62 | }
63 |
64 |
65 | const positionSvgHandler = (svgMotorPos, x, y) => { //position
66 | let p = new DOMPoint(x, y);
67 | return p.matrixTransform(svgMotorPos.getScreenCTM().inverse());
68 | };
69 | svgMotorPos.addEventListener('click', e => {
70 | let p = positionSvgHandler(e.target, e.clientX, e.clientY);
71 | var rect = svgMotorPos.getBoundingClientRect();
72 | var newMotorPos = Math.round((359 / rect.width) * p.x);
73 | eel.set_motor_position(newMotorPos)();
74 | });
75 |
76 |
77 | const powerSvgHandler = (svgMotorPower, x, y) => { //power
78 | let p = new DOMPoint(x, y);
79 | return p.matrixTransform(svgMotorPower.getScreenCTM().inverse());
80 | };
81 | svgMotorPower.addEventListener('click', e => {
82 | let p = powerSvgHandler(e.target, e.clientX, e.clientY);
83 | var rect = svgMotorPower.getBoundingClientRect();
84 | var newMotorPower = Math.round((100 / rect.width) * p.x);
85 | eel.set_motor_power(newMotorPower)();
86 | });
87 |
88 | function set_mode(mode){
89 | eel.set_mode(mode)();
90 | }
91 |
--------------------------------------------------------------------------------
/Core/Inc/as5600.h:
--------------------------------------------------------------------------------
1 | /*
2 | * as5600.h
3 | *
4 | * Created on: Mar 5, 2022
5 | * Author: KoSik
6 | */
7 |
8 | #ifndef INC_AS5600_H_
9 | #define INC_AS5600_H_
10 |
11 | #define AS5600_I2C_ADDRESS 0x36 << 1
12 |
13 |
14 | HAL_StatusTypeDef as5600_WriteCommand(I2C_HandleTypeDef *hi2c, uint8_t conf_register_addr, uint8_t setting);
15 | HAL_StatusTypeDef as5600_Init(I2C_HandleTypeDef *hi2c);
16 | HAL_StatusTypeDef as5600_ReadPosition(I2C_HandleTypeDef *hi2c, uint16_t *angle);
17 | HAL_StatusTypeDef as5600_ReadRawPosition(I2C_HandleTypeDef *hi2c, uint16_t *angle);
18 | HAL_StatusTypeDef as5600_ReadConfig(I2C_HandleTypeDef *hi2c, uint16_t *config);
19 | uint8_t as5600_StatusMagnet(I2C_HandleTypeDef *hi2c);
20 |
21 | #endif /* INC_AS5600_H_ */
22 |
--------------------------------------------------------------------------------
/Core/Inc/bldc.h:
--------------------------------------------------------------------------------
1 | /*
2 | * bldc.h
3 | *
4 | * Created on: Apr 9, 2022
5 | * Author: KoSik
6 | * e-mail: kosik84@gmail.com
7 | *
8 | * version: 1.0
9 | */
10 |
11 | #ifndef INC_BLDC_H_
12 | #define INC_BLDC_H_
13 |
14 | struct BLDCMotorSt {
15 | uint32_t pwmU;
16 | uint32_t pwmV;
17 | uint32_t pwmW;
18 | uint16_t expectedPosition; // expected motor position
19 | double speed;
20 | //double accelerate;
21 | double expectedPower;
22 | double actualPower;
23 | //double expectedAcceleration;
24 | double actualAcceleration;
25 | double actualSpeed;
26 | double expectedSpeed;
27 | double actualSpeedARRReg; //timer 2
28 | //uint16_t expectedDeadZone; // dead zone
29 | double distance; // distance from the expected point to the current point
30 | uint8_t direction; // direction 0-L 1-R
31 | int16_t fieldPosition; //magnetic field position for complete rotation - 4095 pozycji
32 | int16_t fieldLastPosition;
33 | };
34 |
35 | struct BLDCencoderSt {
36 | uint8_t status;
37 | uint16_t angle; //encoder position RAW
38 | uint16_t calculatedAngle; // calculated encoder position
39 | uint8_t magnetStatus;
40 | uint16_t offset; // position offset
41 | };
42 |
43 | #define REST_DELAY 9
44 | #define PWM_MAX 1023
45 | #define MOTOR_RESOLUTION 819.0 // 5 x 819 = 4095
46 |
47 | #define ARR_MIN 400
48 | #define ACCELERATION_MAX 25 // the number of magnetic field steps that can be jumped in one step
49 |
50 | void bldc_Calculate(TIM_HandleTypeDef *tim);
51 | HAL_StatusTypeDef bldc_Init(TIM_HandleTypeDef *tim, uint32_t channel1,
52 | uint32_t channel2, uint32_t channel3);
53 | HAL_StatusTypeDef bldc_SyncWithEncoder(uint8_t divide);
54 | void bldc_Set_NewPosition(uint16_t deadZone, uint16_t stepsToChange);
55 | uint8_t bldcCheckReachedPosition(uint16_t zeroPoint);
56 | void bldcHapticSwitch(uint16_t point1, uint16_t point2);
57 | void bldc_Set_MotorPosition(uint16_t position, float power);
58 | uint16_t bldc_Create_FocPoint(uint16_t punktX);
59 | void bldc_Create_FocArray(uint16_t *tab);
60 | void set_field(int16_t pozycja_silnika, float moc_silnika);
61 | void delay_Us(uint32_t delay_Us);
62 |
63 | #endif /* INC_BLDC_H_ */
64 |
--------------------------------------------------------------------------------
/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 | * Copyright (c) 2022 STMicroelectronics.
11 | * All rights reserved.
12 | *
13 | * This software is licensed under terms that can be found in the LICENSE file
14 | * in the root directory of this software component.
15 | * If no LICENSE file comes with this software, it is provided AS-IS.
16 | *
17 | ******************************************************************************
18 | */
19 | /* USER CODE END Header */
20 |
21 | /* Define to prevent recursive inclusion -------------------------------------*/
22 | #ifndef __MAIN_H
23 | #define __MAIN_H
24 |
25 | #ifdef __cplusplus
26 | extern "C" {
27 | #endif
28 |
29 | /* Includes ------------------------------------------------------------------*/
30 | #include "stm32f1xx_hal.h"
31 |
32 | /* Private includes ----------------------------------------------------------*/
33 | /* USER CODE BEGIN Includes */
34 |
35 | /* USER CODE END Includes */
36 |
37 | /* Exported types ------------------------------------------------------------*/
38 | /* USER CODE BEGIN ET */
39 |
40 | /* USER CODE END ET */
41 |
42 | /* Exported constants --------------------------------------------------------*/
43 | /* USER CODE BEGIN EC */
44 |
45 | /* USER CODE END EC */
46 |
47 | /* Exported macro ------------------------------------------------------------*/
48 | /* USER CODE BEGIN EM */
49 |
50 | /* USER CODE END EM */
51 |
52 | void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);
53 |
54 | /* Exported functions prototypes ---------------------------------------------*/
55 | void Error_Handler(void);
56 |
57 | /* USER CODE BEGIN EFP */
58 |
59 | /* USER CODE END EFP */
60 |
61 | /* Private defines -----------------------------------------------------------*/
62 | #define LEDR_Pin GPIO_PIN_13
63 | #define LEDR_GPIO_Port GPIOC
64 | #define LEDG_Pin GPIO_PIN_14
65 | #define LEDG_GPIO_Port GPIOC
66 | #define HALL1_Pin GPIO_PIN_0
67 | #define HALL1_GPIO_Port GPIOA
68 | #define HALL2_Pin GPIO_PIN_1
69 | #define HALL2_GPIO_Port GPIOA
70 | #define HALL3_Pin GPIO_PIN_2
71 | #define HALL3_GPIO_Port GPIOA
72 | #define HALL4_Pin GPIO_PIN_3
73 | #define HALL4_GPIO_Port GPIOA
74 | #define TEMP_Pin GPIO_PIN_4
75 | #define TEMP_GPIO_Port GPIOA
76 | /* USER CODE BEGIN Private defines */
77 |
78 | /* USER CODE END Private defines */
79 |
80 | #ifdef __cplusplus
81 | }
82 | #endif
83 |
84 | #endif /* __MAIN_H */
85 |
--------------------------------------------------------------------------------
/Core/Inc/pid.h:
--------------------------------------------------------------------------------
1 | /*
2 | ------------------------------------------------------------------------------
3 | ~ File : pid.h
4 | ~ Author : Majid Derhambakhsh
5 | ~ Version: V1.0.0
6 | ~ Created: 02/11/2021 03:43:00 AM
7 | ~ Brief :
8 | ~ Support:
9 | E-Mail : Majid.do16@gmail.com (subject : Embedded Library Support)
10 |
11 | Github : https://github.com/Majid-Derhambakhsh
12 | ------------------------------------------------------------------------------
13 | ~ Description:
14 |
15 | ~ Attention :
16 |
17 | ~ Changes :
18 | ------------------------------------------------------------------------------
19 | */
20 |
21 | #ifndef __PID_H_
22 | #define __PID_H_
23 |
24 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Include ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
25 | #include
26 | #include
27 |
28 | /* ------------------------------------------------------------------ */
29 |
30 | #ifdef __CODEVISIONAVR__ /* Check compiler */
31 |
32 | #pragma warn_unref_func- /* Disable 'unused function' warning */
33 |
34 | /* ------------------------------------------------------------------ */
35 |
36 | #elif defined(__GNUC__) && !defined(USE_HAL_DRIVER) /* Check compiler */
37 |
38 | #pragma GCC diagnostic ignored "-Wunused-function" /* Disable 'unused function' warning */
39 |
40 | /* ------------------------------------------------------------------ */
41 |
42 | #elif defined(USE_HAL_DRIVER) /* Check driver */
43 |
44 | #include "main.h"
45 |
46 | /* --------------- Check Mainstream series --------------- */
47 |
48 | #ifdef STM32F0
49 | #include "stm32f0xx_hal.h" /* Import HAL library */
50 | #elif defined(STM32F1)
51 | #include "stm32f1xx_hal.h" /* Import HAL library */
52 | #elif defined(STM32F2)
53 | #include "stm32f2xx_hal.h" /* Import HAL library */
54 | #elif defined(STM32F3)
55 | #include "stm32f3xx_hal.h" /* Import HAL library */
56 | #elif defined(STM32F4)
57 | #include "stm32f4xx_hal.h" /* Import HAL library */
58 | #elif defined(STM32F7)
59 | #include "stm32f7xx_hal.h" /* Import HAL library */
60 | #elif defined(STM32G0)
61 | #include "stm32g0xx_hal.h" /* Import HAL library */
62 | #elif defined(STM32G4)
63 | #include "stm32g4xx_hal.h" /* Import HAL library */
64 |
65 | /* ------------ Check High Performance series ------------ */
66 |
67 | #elif defined(STM32H7)
68 | #include "stm32h7xx_hal.h" /* Import HAL library */
69 |
70 | /* ------------ Check Ultra low power series ------------- */
71 |
72 | #elif defined(STM32L0)
73 | #include "stm32l0xx_hal.h" /* Import HAL library */
74 | #elif defined(STM32L1)
75 | #include "stm32l1xx_hal.h" /* Import HAL library */
76 | #elif defined(STM32L5)
77 | #include "stm32l5xx_hal.h" /* Import HAL library */
78 | #elif defined(STM32L4)
79 | #include "stm32l4xx_hal.h" /* Import HAL library */
80 | #elif defined(STM32H7)
81 | #include "stm32h7xx_hal.h" /* Import HAL library */
82 | #else
83 | #endif /* STM32F1 */
84 |
85 | /* ------------------------------------------------------- */
86 |
87 | #if defined ( __ICCARM__ ) /* ICCARM Compiler */
88 |
89 | #pragma diag_suppress=Pe177 /* Disable 'unused function' warning */
90 |
91 | #elif defined ( __GNUC__ ) /* GNU Compiler */
92 |
93 | //#pragma diag_suppress 177 /* Disable 'unused function' warning */
94 |
95 | #endif /* __ICCARM__ */
96 |
97 | /* ------------------------------------------------------------------ */
98 |
99 | #else /* Compiler not found */
100 |
101 | #error Chip or Library not supported /* Send error */
102 |
103 | #endif /* __CODEVISIONAVR__ */
104 |
105 | /* ------------------------------------------------------------------ */
106 |
107 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Defines ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
108 | /* ------------------------ Library ------------------------ */
109 | #define _PID_LIBRARY_VERSION 1.0.0
110 |
111 | /* ------------------------ Public ------------------------- */
112 | #define _PID_8BIT_PWM_MAX UINT8_MAX
113 | #define _PID_SAMPLE_TIME_MS_DEF 100
114 |
115 | #ifndef _FALSE
116 |
117 | #define _FALSE 0
118 |
119 | #endif
120 |
121 | #ifndef _TRUE
122 |
123 | #define _TRUE 1
124 |
125 | #endif
126 |
127 | /* ---------------------- By compiler ---------------------- */
128 | #ifndef GetTime
129 |
130 | /* ---------------------- By compiler ---------------------- */
131 |
132 | #ifdef __CODEVISIONAVR__ /* Check compiler */
133 |
134 | #define GetTime() 0
135 |
136 | /* ------------------------------------------------------------------ */
137 |
138 | #elif defined(__GNUC__) && !defined(USE_HAL_DRIVER) /* Check compiler */
139 |
140 | #define GetTime() 0
141 |
142 | /* ------------------------------------------------------------------ */
143 |
144 | #elif defined(USE_HAL_DRIVER) /* Check driver */
145 |
146 | #define GetTime() HAL_GetTick()
147 |
148 | /* ------------------------------------------------------------------ */
149 |
150 | #else
151 | #endif /* __CODEVISIONAVR__ */
152 | /* ------------------------------------------------------------------ */
153 |
154 | #endif
155 |
156 | /* --------------------------------------------------------- */
157 |
158 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Types ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
159 | /* PID Mode */
160 | typedef enum
161 | {
162 |
163 | _PID_MODE_MANUAL = 0,
164 | _PID_MODE_AUTOMATIC = 1
165 |
166 | }PIDMode_TypeDef;
167 |
168 | /* PID P On x */
169 | typedef enum
170 | {
171 |
172 | _PID_P_ON_M = 0, /* Proportional on Measurement */
173 | _PID_P_ON_E = 1
174 |
175 | }PIDPON_TypeDef;
176 |
177 | /* PID Control direction */
178 | typedef enum
179 | {
180 |
181 | _PID_CD_DIRECT = 0,
182 | _PID_CD_REVERSE = 1
183 |
184 | }PIDCD_TypeDef;
185 |
186 | /* PID Structure */
187 | typedef struct
188 | {
189 |
190 | PIDPON_TypeDef POnE;
191 | PIDMode_TypeDef InAuto;
192 |
193 | PIDPON_TypeDef POn;
194 | PIDCD_TypeDef ControllerDirection;
195 |
196 | uint32_t LastTime;
197 | uint32_t SampleTime;
198 |
199 | double DispKp;
200 | double DispKi;
201 | double DispKd;
202 |
203 | double Kp;
204 | double Ki;
205 | double Kd;
206 |
207 | double *MyInput;
208 | double *MyOutput;
209 | double *MySetpoint;
210 |
211 | double OutputSum;
212 | double LastInput;
213 |
214 | double OutMin;
215 | double OutMax;
216 |
217 | }PID_TypeDef;
218 |
219 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Variables ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
220 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Enum ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
221 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Struct ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
222 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Class ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
223 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Prototype ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
224 | /* :::::::::::::: Init ::::::::::::: */
225 | void PID_Init(PID_TypeDef *uPID);
226 |
227 | void PID(PID_TypeDef *uPID, double *Input, double *Output, double *Setpoint, double Kp, double Ki, double Kd, PIDPON_TypeDef POn, PIDCD_TypeDef ControllerDirection);
228 | void PID2(PID_TypeDef *uPID, double *Input, double *Output, double *Setpoint, double Kp, double Ki, double Kd, PIDCD_TypeDef ControllerDirection);
229 |
230 | /* ::::::::::: Computing ::::::::::: */
231 | uint8_t PID_Compute(PID_TypeDef *uPID);
232 |
233 | /* ::::::::::: PID Mode :::::::::::: */
234 | void PID_SetMode(PID_TypeDef *uPID, PIDMode_TypeDef Mode);
235 | PIDMode_TypeDef PID_GetMode(PID_TypeDef *uPID);
236 |
237 | /* :::::::::: PID Limits ::::::::::: */
238 | void PID_SetOutputLimits(PID_TypeDef *uPID, double Min, double Max);
239 |
240 | /* :::::::::: PID Tunings :::::::::: */
241 | void PID_SetTunings(PID_TypeDef *uPID, double Kp, double Ki, double Kd);
242 | void PID_SetTunings2(PID_TypeDef *uPID, double Kp, double Ki, double Kd, PIDPON_TypeDef POn);
243 |
244 | /* ::::::::: PID Direction ::::::::: */
245 | void PID_SetControllerDirection(PID_TypeDef *uPID, PIDCD_TypeDef Direction);
246 | PIDCD_TypeDef PID_GetDirection(PID_TypeDef *uPID);
247 |
248 | /* ::::::::: PID Sampling :::::::::: */
249 | void PID_SetSampleTime(PID_TypeDef *uPID, int32_t NewSampleTime);
250 |
251 | /* ::::::: Get Tunings Param ::::::: */
252 | double PID_GetKp(PID_TypeDef *uPID);
253 | double PID_GetKi(PID_TypeDef *uPID);
254 | double PID_GetKd(PID_TypeDef *uPID);
255 |
256 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ End of the program ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
257 |
258 | #endif /* __PID_H_ */
259 |
--------------------------------------------------------------------------------
/Core/Inc/stm32f1xx_it.h:
--------------------------------------------------------------------------------
1 | /* USER CODE BEGIN Header */
2 | /**
3 | ******************************************************************************
4 | * @file stm32f1xx_it.h
5 | * @brief This file contains the headers of the interrupt handlers.
6 | ******************************************************************************
7 | * @attention
8 | *
9 | * Copyright (c) 2022 STMicroelectronics.
10 | * All rights reserved.
11 | *
12 | * This software is licensed under terms that can be found in the LICENSE file
13 | * in the root directory of this software component.
14 | * If no LICENSE file comes with this software, it is provided AS-IS.
15 | *
16 | ******************************************************************************
17 | */
18 | /* USER CODE END Header */
19 |
20 | /* Define to prevent recursive inclusion -------------------------------------*/
21 | #ifndef __STM32F1xx_IT_H
22 | #define __STM32F1xx_IT_H
23 |
24 | #ifdef __cplusplus
25 | extern "C" {
26 | #endif
27 |
28 | /* Private includes ----------------------------------------------------------*/
29 | /* USER CODE BEGIN Includes */
30 |
31 | /* USER CODE END Includes */
32 |
33 | /* Exported types ------------------------------------------------------------*/
34 | /* USER CODE BEGIN ET */
35 |
36 | /* USER CODE END ET */
37 |
38 | /* Exported constants --------------------------------------------------------*/
39 | /* USER CODE BEGIN EC */
40 |
41 | /* USER CODE END EC */
42 |
43 | /* Exported macro ------------------------------------------------------------*/
44 | /* USER CODE BEGIN EM */
45 |
46 | /* USER CODE END EM */
47 |
48 | /* Exported functions prototypes ---------------------------------------------*/
49 | void NMI_Handler(void);
50 | void HardFault_Handler(void);
51 | void MemManage_Handler(void);
52 | void BusFault_Handler(void);
53 | void UsageFault_Handler(void);
54 | void SVC_Handler(void);
55 | void DebugMon_Handler(void);
56 | void PendSV_Handler(void);
57 | void SysTick_Handler(void);
58 | void PVD_IRQHandler(void);
59 | void FLASH_IRQHandler(void);
60 | void RCC_IRQHandler(void);
61 | void DMA1_Channel1_IRQHandler(void);
62 | void DMA1_Channel2_IRQHandler(void);
63 | void DMA1_Channel3_IRQHandler(void);
64 | void DMA1_Channel6_IRQHandler(void);
65 | void USB_HP_CAN1_TX_IRQHandler(void);
66 | void USB_LP_CAN1_RX0_IRQHandler(void);
67 | void TIM2_IRQHandler(void);
68 | void TIM3_IRQHandler(void);
69 | void TIM4_IRQHandler(void);
70 | void I2C2_EV_IRQHandler(void);
71 | /* USER CODE BEGIN EFP */
72 |
73 | /* USER CODE END EFP */
74 |
75 | #ifdef __cplusplus
76 | }
77 | #endif
78 |
79 | #endif /* __STM32F1xx_IT_H */
80 |
--------------------------------------------------------------------------------
/Core/Inc/usb_comm.h:
--------------------------------------------------------------------------------
1 | /*
2 | * usb_comm.h
3 | *
4 | * Created on: 18 paź 2022
5 | * Author: KoSik
6 | * e-mail: kosik84@gmail.com
7 | *
8 | * version: 1.0
9 | */
10 |
11 | #ifndef INC_USB_COMM_H_
12 | #define INC_USB_COMM_H_
13 |
14 | uint8_t read_variable(uint8_t *Data, char sparam[3], uint16_t *param, uint8_t array_size);
15 | void decode_message(uint8_t *Data, uint8_t array_size);
16 |
17 | #endif /* INC_USB_COMM_H_ */
18 |
--------------------------------------------------------------------------------
/Core/Src/as5600.c:
--------------------------------------------------------------------------------
1 | /*
2 | * as5600.c
3 | *
4 | * Created on: Mar 5, 2022
5 | * Author: KoSik
6 | */
7 |
8 | #include "main.h"
9 | #include "as5600.h"
10 |
11 | HAL_StatusTypeDef as5600_WriteCommand(I2C_HandleTypeDef *hi2c,
12 | uint8_t conf_register_addr, uint8_t setting) {
13 | return HAL_I2C_Mem_Write(hi2c, AS5600_I2C_ADDRESS, conf_register_addr, 1,
14 | &setting, 1, 100);
15 | }
16 |
17 | HAL_StatusTypeDef as5600_Init(I2C_HandleTypeDef *hi2c) {
18 | uint8_t status;
19 | HAL_I2C_Init(hi2c);
20 | status = as5600_WriteCommand(hi2c, 0x08, 0x01); //wlacz enkoder
21 | if (!status) {
22 | HAL_Delay(50);
23 | status = as5600_WriteCommand(hi2c, 0x08, 0x01); //wlacz enkoder
24 | }
25 | status = as5600_WriteCommand(hi2c, 0x07, 0x00); //slow filter x16
26 | HAL_Delay(10);
27 | return status;
28 | }
29 |
30 | HAL_StatusTypeDef as5600_ReadPosition(I2C_HandleTypeDef *hi2c, uint16_t *angle) {
31 | uint8_t status = 0;
32 | uint8_t temp[2];
33 |
34 | status = HAL_I2C_Mem_Read(hi2c, AS5600_I2C_ADDRESS, 0x0E, 1, temp, 2, 100);
35 | *angle = (temp[0] << 8) + temp[1];
36 |
37 | return status;
38 | }
39 |
40 | HAL_StatusTypeDef as5600_ReadRawPosition(I2C_HandleTypeDef *hi2c,
41 | uint16_t *angle) {
42 | uint8_t status = 0;
43 | uint8_t temp[2];
44 |
45 | status = HAL_I2C_Mem_Read(hi2c, AS5600_I2C_ADDRESS, 0x0C, 1, temp, 2, 100);
46 | *angle = (temp[0] << 8) + temp[1];
47 |
48 | return status;
49 | }
50 |
51 | HAL_StatusTypeDef as5600_ReadConfig(I2C_HandleTypeDef *hi2c, uint16_t *config) {
52 | uint8_t temp_posision = 0;
53 | uint8_t status = 0;
54 |
55 | status = HAL_I2C_Mem_Read(hi2c, AS5600_I2C_ADDRESS, 0x07, 1, &temp_posision, 1,
56 | 100);
57 | *config = temp_posision << 8;
58 | if (status == 0) {
59 | HAL_I2C_Mem_Read(hi2c, AS5600_I2C_ADDRESS, 0x08, 1, &temp_posision, 1,
60 | 100);
61 | *config += temp_posision;
62 | }
63 |
64 | return status;
65 | }
66 |
67 | /* Magnet Status
68 | * Bits |MD|ML|MH|
69 | *
70 | * MD - magnet was detected
71 | * ML - magnet too weak
72 | * MH - magnet too strong
73 | * */
74 | uint8_t as5600_StatusMagnet(I2C_HandleTypeDef *hi2c) {
75 | uint8_t status = 0;
76 |
77 | HAL_I2C_Mem_Read(hi2c, AS5600_I2C_ADDRESS, 0x0B, 1, &status, 1, 100);
78 | return status >> 3;
79 | }
80 |
81 |
--------------------------------------------------------------------------------
/Core/Src/bldc.c:
--------------------------------------------------------------------------------
1 | /*
2 | * bldc.h
3 | *
4 | * Created on: Apr 9, 2022
5 | * Author: KoSik
6 | * e-mail: kosik84@gmail.com
7 | *
8 | * version: 1.0
9 | */
10 |
11 | #include "main.h"
12 | #include "bldc.h"
13 | #include "stdlib.h"
14 |
15 | struct BLDCMotorSt bldcMotor;
16 | struct BLDCencoderSt bldcEncoder;
17 |
18 | uint16_t focArray[(int)MOTOR_RESOLUTION];
19 | uint8_t initPhase = 0;
20 | //uint16_t centerPoint, centerPoint2, bufPoint;
21 |
22 |
23 |
24 | HAL_StatusTypeDef bldc_Init(TIM_HandleTypeDef *tim, uint32_t channel1, uint32_t channel2, uint32_t channel3){
25 | HAL_StatusTypeDef status;
26 |
27 | status = HAL_TIM_PWM_Start_DMA(tim, channel1, (uint32_t*)&bldcMotor.pwmU, 1);
28 | HAL_TIMEx_PWMN_Start(tim, channel1);
29 | HAL_TIM_PWM_Start_DMA(tim, channel2, (uint32_t*)&bldcMotor.pwmV, 1);
30 | HAL_TIMEx_PWMN_Start(tim, channel2);
31 | HAL_TIM_PWM_Start_DMA(tim, channel3, (uint32_t*)&bldcMotor.pwmW, 1);
32 | HAL_TIMEx_PWMN_Start(tim, channel3);
33 |
34 |
35 | initPhase = 1;
36 |
37 | for (bldcMotor.fieldPosition = 4095; bldcMotor.fieldPosition > 0; bldcMotor.fieldPosition--) {
38 | bldc_Set_MotorPosition(bldcMotor.fieldPosition, 20);
39 | delay_Us(30);
40 | if(bldcEncoder.angle < 819){
41 | break;
42 | }
43 | }
44 | for (bldcMotor.fieldPosition = 819; bldcMotor.fieldPosition > 0; bldcMotor.fieldPosition--) {
45 | bldc_Set_MotorPosition(bldcMotor.fieldPosition, 20);
46 | delay_Us(300);
47 | }
48 | HAL_Delay(100);
49 | bldcEncoder.offset = bldcEncoder.angle;
50 | initPhase = 0;
51 |
52 |
53 | return status;
54 | }
55 |
56 |
57 | /*
58 | * Update field position with encoder position
59 | * tested with 1kHz update
60 | * */
61 | HAL_StatusTypeDef bldc_SyncWithEncoder(uint8_t divide){
62 | if(abs(bldcMotor.fieldPosition - bldcEncoder.calculatedAngle) > 50){ //korekta pozycji silnika wzgledem enkodera
63 | if(abs(bldcMotor.fieldPosition - bldcEncoder.calculatedAngle) > 3000){ //jesli przeskok przez 0
64 | if(bldcMotor.fieldPosition > bldcEncoder.calculatedAngle){
65 | bldcMotor.fieldPosition = bldcEncoder.calculatedAngle - ((bldcMotor.fieldPosition - (4095 + bldcEncoder.calculatedAngle)) / divide);
66 | } else {
67 | bldcMotor.fieldPosition = bldcEncoder.calculatedAngle + (((bldcMotor.fieldPosition + 4095) - bldcEncoder.calculatedAngle) / divide);
68 | }
69 | } else {
70 | bldcMotor.fieldPosition = bldcEncoder.calculatedAngle + ((bldcMotor.fieldPosition - bldcEncoder.calculatedAngle) / divide);
71 | }
72 | }
73 | return HAL_OK;
74 | }
75 |
76 | void bldc_Set_NewPosition(uint16_t deadZone, uint16_t stepsToChange) {
77 | if (bldcMotor.distance >= stepsToChange) {
78 | if (bldcMotor.direction == 0) {
79 | bldcMotor.fieldPosition = bldcMotor.fieldPosition + stepsToChange;
80 | if (bldcMotor.fieldPosition > 4095) {
81 | bldcMotor.fieldPosition = bldcMotor.fieldPosition - 4095;
82 | }
83 | } else {
84 | bldcMotor.fieldPosition = bldcMotor.fieldPosition - stepsToChange;
85 | if(bldcMotor.fieldPosition < 0) {
86 | bldcMotor.fieldPosition = 4095 - bldcMotor.fieldPosition;
87 | }
88 | }
89 | }
90 | bldc_Set_MotorPosition(bldcMotor.fieldPosition, bldcMotor.actualPower);
91 | }
92 |
93 | /*
94 | * on/off switch simulation
95 | * call in timer
96 | *
97 | *
98 | * center point calculation error !!!!!!!!!!!!!!!!!!!!!!!!!!!
99 | * error when point2 < point1
100 | * */
101 | void bldcHapticSwitch(uint16_t point1, uint16_t point2){
102 | uint16_t centerPoint, centerPoint2, bufPoint;
103 |
104 | if(point1 > point2){ //odworcenie punktow
105 | bufPoint = point2;
106 | point2 = point1;
107 | point1 = bufPoint;
108 | }
109 | centerPoint = ((point2 - point1)/2) + point1;
110 |
111 | centerPoint2 = centerPoint + 2047;
112 | if(centerPoint2 > 4095){
113 | centerPoint2 = centerPoint2 - 4095;
114 | }
115 |
116 | if (bldcEncoder.calculatedAngle >= centerPoint && bldcEncoder.calculatedAngle < centerPoint2) {
117 | bldcMotor.expectedPosition = point2;
118 | } else {
119 | bldcMotor.expectedPosition = point1;
120 | }
121 | }
122 |
123 |
124 | /*
125 | * calculation of power and next position
126 | * interrupt 100Hz
127 | * */
128 | void bldc_Calculate(TIM_HandleTypeDef *tim){
129 | uint16_t calcR, calcL;
130 |
131 | // ANGLE
132 | if((uint16_t)bldcEncoder.angle > bldcEncoder.offset){
133 | bldcEncoder.calculatedAngle = (uint16_t)bldcEncoder.angle - bldcEncoder.offset;
134 | } else {
135 | bldcEncoder.calculatedAngle = (4095 + (uint16_t)bldcEncoder.angle) - bldcEncoder.offset;
136 | }
137 | // DISTANCE + DIRECTION
138 | if(bldcMotor.expectedPosition >= bldcMotor.fieldPosition){
139 | calcL = bldcMotor.expectedPosition - bldcMotor.fieldPosition;
140 | calcR = (4095 - bldcMotor.expectedPosition) + bldcMotor.fieldPosition;
141 | } else {
142 | calcL = (4095 - bldcMotor.fieldPosition) + bldcMotor.expectedPosition;
143 | calcR = bldcMotor.fieldPosition - bldcMotor.expectedPosition;
144 | }
145 |
146 | if(calcR > calcL){
147 | bldcMotor.distance = calcL;
148 | bldcMotor.direction = 0;
149 | } else {
150 | bldcMotor.distance = calcR;
151 | bldcMotor.direction = 1;
152 | }
153 | // SPEED
154 | if(bldcMotor.fieldPosition >= bldcMotor.fieldLastPosition){
155 | calcL = bldcMotor.fieldPosition - bldcMotor.fieldLastPosition;
156 | calcR = (4095 - bldcMotor.fieldPosition) + bldcMotor.fieldLastPosition;
157 | } else {
158 | calcL = (4095 - bldcMotor.fieldLastPosition) + bldcMotor.fieldPosition;
159 | calcR = bldcMotor.fieldLastPosition - bldcMotor.fieldPosition;
160 | }
161 |
162 | if(calcR > calcL){
163 | bldcMotor.speed = calcL;
164 | } else {
165 | bldcMotor.speed = calcR;
166 | }
167 | bldcMotor.fieldLastPosition = bldcMotor.fieldPosition;
168 |
169 | // ACCELERATION
170 | if(bldcMotor.speed < bldcMotor.expectedSpeed && bldcMotor.distance > 100){
171 | if(__HAL_TIM_GET_AUTORELOAD(tim) > ARR_MIN){
172 | bldcMotor.actualSpeedARRReg = bldcMotor.actualSpeedARRReg - 1;
173 | __HAL_TIM_SET_AUTORELOAD(tim, bldcMotor.actualSpeedARRReg);
174 | } else if(__HAL_TIM_GET_AUTORELOAD(tim) == ARR_MIN && bldcMotor.actualAcceleration < ACCELERATION_MAX){
175 | bldcMotor.actualAcceleration+=0.008;
176 | }
177 | }
178 | // BRAKING
179 | if(bldcMotor.distance < 100){
180 | bldcMotor.actualSpeedARRReg = 400 + (bldcMotor.distance * 6);
181 | __HAL_TIM_SET_AUTORELOAD(tim, bldcMotor.actualSpeedARRReg);
182 | }
183 |
184 | }
185 |
186 |
187 |
188 | /*
189 | * interrupt 1kHz
190 | * */
191 | void bldc_Set_MotorPosition(uint16_t position, float power){
192 | uint16_t pos = position;
193 |
194 | for(uint8_t i=0; i<20; i++){
195 | if(pos>=819){
196 | pos=pos-819;
197 | } else {
198 | break;
199 | }
200 | }
201 | set_field(pos, power);
202 | }
203 |
204 | uint16_t bldc_Create_FocPoint(uint16_t pointX){
205 | float a, b;
206 |
207 | if(pointX > (MOTOR_RESOLUTION-1)){
208 | pointX -= (MOTOR_RESOLUTION-1);
209 | }
210 |
211 | if(pointX >= 0 && pointX < REST_DELAY){
212 | return PWM_MAX;
213 | } else if(pointX >= REST_DELAY && pointX < (MOTOR_RESOLUTION/2)){
214 | a = -PWM_MAX / ((MOTOR_RESOLUTION/2) - REST_DELAY);
215 | b = PWM_MAX - (a * REST_DELAY);
216 | return (int)((a * pointX) + b);
217 | } else if (pointX >= (MOTOR_RESOLUTION/2) && pointX < ((MOTOR_RESOLUTION/2) + REST_DELAY)){
218 | return 0;
219 | } else if (pointX >= (MOTOR_RESOLUTION/2) + REST_DELAY && pointX < MOTOR_RESOLUTION){
220 | a = ((PWM_MAX * 1.0) / (MOTOR_RESOLUTION - ((MOTOR_RESOLUTION/2) + REST_DELAY)));
221 | b = -(a * ((MOTOR_RESOLUTION/2) + REST_DELAY));
222 | return (int)((a * pointX) + b);
223 | } else {
224 | return 0;
225 | }
226 | }
227 |
228 | void bldc_Create_FocArray(uint16_t *tab){
229 | for(uint16_t q=0; q MOTOR_RESOLUTION - shift1){
245 | actualPosition = motorPosition - MOTOR_RESOLUTION + shift1;
246 | } else {
247 | actualPosition = motorPosition + shift1;
248 | }
249 | bldcMotor.pwmV = (uint16_t)(focArray[actualPosition] * moc_silnika / 100);
250 |
251 | if(motorPosition > MOTOR_RESOLUTION - shift2){
252 | actualPosition = motorPosition - MOTOR_RESOLUTION + shift2;
253 | } else {
254 | actualPosition = motorPosition + shift2;
255 | }
256 | bldcMotor.pwmW = (uint16_t)(focArray[actualPosition] * moc_silnika / 100);
257 |
258 | }
259 |
260 | void delay_Us(uint32_t delay_Us){
261 | volatile unsigned int num;
262 | volatile unsigned int t;
263 |
264 |
265 | for (num = 0; num < delay_Us; num++)
266 | {
267 | t = 11;
268 | while (t != 0)
269 | {
270 | t--;
271 | }
272 | }
273 | }
274 |
--------------------------------------------------------------------------------
/Core/Src/pid.c:
--------------------------------------------------------------------------------
1 | /*
2 | ------------------------------------------------------------------------------
3 | ~ File : pid.c
4 | ~ Author : Majid Derhambakhsh
5 | ~ Version: V1.0.0
6 | ~ Created: 02/11/2021 03:43:00 AM
7 | ~ Brief :
8 | ~ Support:
9 | E-Mail : Majid.do16@gmail.com (subject : Embedded Library Support)
10 |
11 | Github : https://github.com/Majid-Derhambakhsh
12 | ------------------------------------------------------------------------------
13 | ~ Description:
14 |
15 | ~ Attention :
16 |
17 | ~ Changes :
18 | ------------------------------------------------------------------------------
19 | */
20 |
21 | #include "pid.h"
22 |
23 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
24 | /* ~~~~~~~~~~~~~~~~~ Initialize ~~~~~~~~~~~~~~~~ */
25 | void PID_Init(PID_TypeDef *uPID)
26 | {
27 | /* ~~~~~~~~~~ Set parameter ~~~~~~~~~~ */
28 | uPID->OutputSum = *uPID->MyOutput;
29 | uPID->LastInput = *uPID->MyInput;
30 |
31 | if (uPID->OutputSum > uPID->OutMax)
32 | {
33 | uPID->OutputSum = uPID->OutMax;
34 | }
35 | else if (uPID->OutputSum < uPID->OutMin)
36 | {
37 | uPID->OutputSum = uPID->OutMin;
38 | }
39 | else { }
40 |
41 | }
42 |
43 | void PID(PID_TypeDef *uPID, double *Input, double *Output, double *Setpoint, double Kp, double Ki, double Kd, PIDPON_TypeDef POn, PIDCD_TypeDef ControllerDirection)
44 | {
45 | /* ~~~~~~~~~~ Set parameter ~~~~~~~~~~ */
46 | uPID->MyOutput = Output;
47 | uPID->MyInput = Input;
48 | uPID->MySetpoint = Setpoint;
49 | uPID->InAuto = (PIDMode_TypeDef)_FALSE;
50 |
51 | PID_SetOutputLimits(uPID, 0, _PID_8BIT_PWM_MAX);
52 |
53 | uPID->SampleTime = _PID_SAMPLE_TIME_MS_DEF; /* default Controller Sample Time is 0.1 seconds */
54 |
55 | PID_SetControllerDirection(uPID, ControllerDirection);
56 | PID_SetTunings2(uPID, Kp, Ki, Kd, POn);
57 |
58 | uPID->LastTime = GetTime() - uPID->SampleTime;
59 |
60 | }
61 |
62 | void PID2(PID_TypeDef *uPID, double *Input, double *Output, double *Setpoint, double Kp, double Ki, double Kd, PIDCD_TypeDef ControllerDirection)
63 | {
64 | PID(uPID, Input, Output, Setpoint, Kp, Ki, Kd, _PID_P_ON_E, ControllerDirection);
65 | }
66 |
67 | /* ~~~~~~~~~~~~~~~~~ Computing ~~~~~~~~~~~~~~~~~ */
68 | uint8_t PID_Compute(PID_TypeDef *uPID)
69 | {
70 |
71 | uint32_t now;
72 | uint32_t timeChange;
73 |
74 | double input;
75 | double error;
76 | double dInput;
77 | double output;
78 |
79 | /* ~~~~~~~~~~ Check PID mode ~~~~~~~~~~ */
80 | if (!uPID->InAuto)
81 | {
82 | return _FALSE;
83 | }
84 |
85 | /* ~~~~~~~~~~ Calculate time ~~~~~~~~~~ */
86 | now = GetTime();
87 | timeChange = (now - uPID->LastTime);
88 |
89 | if (timeChange >= uPID->SampleTime)
90 | {
91 | /* ..... Compute all the working error variables ..... */
92 | input = *uPID->MyInput;
93 | error = *uPID->MySetpoint - input;
94 | dInput = (input - uPID->LastInput);
95 |
96 | uPID->OutputSum += (uPID->Ki * error);
97 |
98 | /* ..... Add Proportional on Measurement, if P_ON_M is specified ..... */
99 | if (!uPID->POnE)
100 | {
101 | uPID->OutputSum -= uPID->Kp * dInput;
102 | }
103 |
104 | if (uPID->OutputSum > uPID->OutMax)
105 | {
106 | uPID->OutputSum = uPID->OutMax;
107 | }
108 | else if (uPID->OutputSum < uPID->OutMin)
109 | {
110 | uPID->OutputSum = uPID->OutMin;
111 | }
112 | else { }
113 |
114 | /* ..... Add Proportional on Error, if P_ON_E is specified ..... */
115 | if (uPID->POnE)
116 | {
117 | output = uPID->Kp * error;
118 | }
119 | else
120 | {
121 | output = 0;
122 | }
123 |
124 | /* ..... Compute Rest of PID Output ..... */
125 | output += uPID->OutputSum - uPID->Kd * dInput;
126 |
127 | if (output > uPID->OutMax)
128 | {
129 | output = uPID->OutMax;
130 | }
131 | else if (output < uPID->OutMin)
132 | {
133 | output = uPID->OutMin;
134 | }
135 | else { }
136 |
137 | *uPID->MyOutput = output;
138 |
139 | /* ..... Remember some variables for next time ..... */
140 | uPID->LastInput = input;
141 | uPID->LastTime = now;
142 |
143 | return _TRUE;
144 |
145 | }
146 | else
147 | {
148 | return _FALSE;
149 | }
150 |
151 | }
152 |
153 | /* ~~~~~~~~~~~~~~~~~ PID Mode ~~~~~~~~~~~~~~~~~~ */
154 | void PID_SetMode(PID_TypeDef *uPID, PIDMode_TypeDef Mode)
155 | {
156 |
157 | uint8_t newAuto = (Mode == _PID_MODE_AUTOMATIC);
158 |
159 | /* ~~~~~~~~~~ Initialize the PID ~~~~~~~~~~ */
160 | if (newAuto && !uPID->InAuto)
161 | {
162 | PID_Init(uPID);
163 | }
164 |
165 | uPID->InAuto = (PIDMode_TypeDef)newAuto;
166 |
167 | }
168 | PIDMode_TypeDef PID_GetMode(PID_TypeDef *uPID)
169 | {
170 | return uPID->InAuto ? _PID_MODE_AUTOMATIC : _PID_MODE_MANUAL;
171 | }
172 |
173 | /* ~~~~~~~~~~~~~~~~ PID Limits ~~~~~~~~~~~~~~~~~ */
174 | void PID_SetOutputLimits(PID_TypeDef *uPID, double Min, double Max)
175 | {
176 | /* ~~~~~~~~~~ Check value ~~~~~~~~~~ */
177 | if (Min >= Max)
178 | {
179 | return;
180 | }
181 |
182 | uPID->OutMin = Min;
183 | uPID->OutMax = Max;
184 |
185 | /* ~~~~~~~~~~ Check PID Mode ~~~~~~~~~~ */
186 | if (uPID->InAuto)
187 | {
188 |
189 | /* ..... Check out value ..... */
190 | if (*uPID->MyOutput > uPID->OutMax)
191 | {
192 | *uPID->MyOutput = uPID->OutMax;
193 | }
194 | else if (*uPID->MyOutput < uPID->OutMin)
195 | {
196 | *uPID->MyOutput = uPID->OutMin;
197 | }
198 | else { }
199 |
200 | /* ..... Check out value ..... */
201 | if (uPID->OutputSum > uPID->OutMax)
202 | {
203 | uPID->OutputSum = uPID->OutMax;
204 | }
205 | else if (uPID->OutputSum < uPID->OutMin)
206 | {
207 | uPID->OutputSum = uPID->OutMin;
208 | }
209 | else { }
210 |
211 | }
212 |
213 | }
214 |
215 | /* ~~~~~~~~~~~~~~~~ PID Tunings ~~~~~~~~~~~~~~~~ */
216 | void PID_SetTunings(PID_TypeDef *uPID, double Kp, double Ki, double Kd)
217 | {
218 | PID_SetTunings2(uPID, Kp, Ki, Kd, uPID->POn);
219 | }
220 | void PID_SetTunings2(PID_TypeDef *uPID, double Kp, double Ki, double Kd, PIDPON_TypeDef POn)
221 | {
222 |
223 | double SampleTimeInSec;
224 |
225 | /* ~~~~~~~~~~ Check value ~~~~~~~~~~ */
226 | if (Kp < 0 || Ki < 0 || Kd < 0)
227 | {
228 | return;
229 | }
230 |
231 | /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
232 | uPID->POn = POn;
233 | uPID->POnE = (PIDPON_TypeDef)(POn == _PID_P_ON_E);
234 |
235 | uPID->DispKp = Kp;
236 | uPID->DispKi = Ki;
237 | uPID->DispKd = Kd;
238 |
239 | /* ~~~~~~~~~ Calculate time ~~~~~~~~ */
240 | SampleTimeInSec = ((double)uPID->SampleTime) / 1000;
241 |
242 | uPID->Kp = Kp;
243 | uPID->Ki = Ki * SampleTimeInSec;
244 | uPID->Kd = Kd / SampleTimeInSec;
245 |
246 | /* ~~~~~~~~ Check direction ~~~~~~~~ */
247 | if (uPID->ControllerDirection == _PID_CD_REVERSE)
248 | {
249 |
250 | uPID->Kp = (0 - uPID->Kp);
251 | uPID->Ki = (0 - uPID->Ki);
252 | uPID->Kd = (0 - uPID->Kd);
253 |
254 | }
255 |
256 | }
257 |
258 | /* ~~~~~~~~~~~~~~~ PID Direction ~~~~~~~~~~~~~~~ */
259 | void PID_SetControllerDirection(PID_TypeDef *uPID, PIDCD_TypeDef Direction)
260 | {
261 | /* ~~~~~~~~~~ Check parameters ~~~~~~~~~~ */
262 | if ((uPID->InAuto) && (Direction !=uPID->ControllerDirection))
263 | {
264 |
265 | uPID->Kp = (0 - uPID->Kp);
266 | uPID->Ki = (0 - uPID->Ki);
267 | uPID->Kd = (0 - uPID->Kd);
268 |
269 | }
270 |
271 | uPID->ControllerDirection = Direction;
272 |
273 | }
274 | PIDCD_TypeDef PID_GetDirection(PID_TypeDef *uPID)
275 | {
276 | return uPID->ControllerDirection;
277 | }
278 |
279 | /* ~~~~~~~~~~~~~~~ PID Sampling ~~~~~~~~~~~~~~~~ */
280 | void PID_SetSampleTime(PID_TypeDef *uPID, int32_t NewSampleTime)
281 | {
282 |
283 | double ratio;
284 |
285 | /* ~~~~~~~~~~ Check value ~~~~~~~~~~ */
286 | if (NewSampleTime > 0)
287 | {
288 |
289 | ratio = (double)NewSampleTime / (double)uPID->SampleTime;
290 |
291 | uPID->Ki *= ratio;
292 | uPID->Kd /= ratio;
293 | uPID->SampleTime = (uint32_t)NewSampleTime;
294 |
295 | }
296 |
297 | }
298 |
299 | /* ~~~~~~~~~~~~~ Get Tunings Param ~~~~~~~~~~~~~ */
300 | double PID_GetKp(PID_TypeDef *uPID)
301 | {
302 | return uPID->DispKp;
303 | }
304 | double PID_GetKi(PID_TypeDef *uPID)
305 | {
306 | return uPID->DispKi;
307 | }
308 | double PID_GetKd(PID_TypeDef *uPID)
309 | {
310 | return uPID->DispKd;
311 | }
312 |
--------------------------------------------------------------------------------
/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 | * Copyright (c) 2022 STMicroelectronics.
14 | * All rights reserved.
15 | *
16 | * This software is licensed under terms that can be found in the LICENSE file
17 | * in the root directory of this software component.
18 | * If no LICENSE file comes with this software, it is provided AS-IS.
19 | *
20 | ******************************************************************************
21 | */
22 |
23 | /* Includes */
24 | #include
25 | #include
26 | #include
27 | #include
28 | #include
29 | #include
30 | #include
31 | #include
32 |
33 |
34 | /* Variables */
35 | extern int __io_putchar(int ch) __attribute__((weak));
36 | extern int __io_getchar(void) __attribute__((weak));
37 |
38 |
39 | char *__env[1] = { 0 };
40 | char **environ = __env;
41 |
42 |
43 | /* Functions */
44 | void initialise_monitor_handles()
45 | {
46 | }
47 |
48 | int _getpid(void)
49 | {
50 | return 1;
51 | }
52 |
53 | int _kill(int pid, int sig)
54 | {
55 | errno = EINVAL;
56 | return -1;
57 | }
58 |
59 | void _exit (int status)
60 | {
61 | _kill(status, -1);
62 | while (1) {} /* Make sure we hang here */
63 | }
64 |
65 | __attribute__((weak)) int _read(int file, char *ptr, int len)
66 | {
67 | int DataIdx;
68 |
69 | for (DataIdx = 0; DataIdx < len; DataIdx++)
70 | {
71 | *ptr++ = __io_getchar();
72 | }
73 |
74 | return len;
75 | }
76 |
77 | __attribute__((weak)) int _write(int file, char *ptr, int len)
78 | {
79 | int DataIdx;
80 |
81 | for (DataIdx = 0; DataIdx < len; DataIdx++)
82 | {
83 | __io_putchar(*ptr++);
84 | }
85 | return len;
86 | }
87 |
88 | int _close(int file)
89 | {
90 | return -1;
91 | }
92 |
93 |
94 | int _fstat(int file, struct stat *st)
95 | {
96 | st->st_mode = S_IFCHR;
97 | return 0;
98 | }
99 |
100 | int _isatty(int file)
101 | {
102 | return 1;
103 | }
104 |
105 | int _lseek(int file, int ptr, int dir)
106 | {
107 | return 0;
108 | }
109 |
110 | int _open(char *path, int flags, ...)
111 | {
112 | /* Pretend like we always fail */
113 | return -1;
114 | }
115 |
116 | int _wait(int *status)
117 | {
118 | errno = ECHILD;
119 | return -1;
120 | }
121 |
122 | int _unlink(char *name)
123 | {
124 | errno = ENOENT;
125 | return -1;
126 | }
127 |
128 | int _times(struct tms *buf)
129 | {
130 | return -1;
131 | }
132 |
133 | int _stat(char *file, struct stat *st)
134 | {
135 | st->st_mode = S_IFCHR;
136 | return 0;
137 | }
138 |
139 | int _link(char *old, char *new)
140 | {
141 | errno = EMLINK;
142 | return -1;
143 | }
144 |
145 | int _fork(void)
146 | {
147 | errno = EAGAIN;
148 | return -1;
149 | }
150 |
151 | int _execve(char *name, char **argv, char **env)
152 | {
153 | errno = ENOMEM;
154 | return -1;
155 | }
156 |
--------------------------------------------------------------------------------
/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 | * Copyright (c) 2022 STMicroelectronics.
14 | * All rights reserved.
15 | *
16 | * This software is licensed under terms that can be found in the LICENSE file
17 | * in the root directory of this software component.
18 | * If no LICENSE file comes with this software, it is provided AS-IS.
19 | *
20 | ******************************************************************************
21 | */
22 |
23 | /* Includes */
24 | #include
25 | #include
26 |
27 | /**
28 | * Pointer to the current high watermark of the heap usage
29 | */
30 | static uint8_t *__sbrk_heap_end = NULL;
31 |
32 | /**
33 | * @brief _sbrk() allocates memory to the newlib heap and is used by malloc
34 | * and others from the C library
35 | *
36 | * @verbatim
37 | * ############################################################################
38 | * # .data # .bss # newlib heap # MSP stack #
39 | * # # # # Reserved by _Min_Stack_Size #
40 | * ############################################################################
41 | * ^-- RAM start ^-- _end _estack, RAM end --^
42 | * @endverbatim
43 | *
44 | * This implementation starts allocating at the '_end' linker symbol
45 | * The '_Min_Stack_Size' linker symbol reserves a memory for the MSP stack
46 | * The implementation considers '_estack' linker symbol to be RAM end
47 | * NOTE: If the MSP stack, at any point during execution, grows larger than the
48 | * reserved size, please increase the '_Min_Stack_Size'.
49 | *
50 | * @param incr Memory size
51 | * @return Pointer to allocated memory
52 | */
53 | void *_sbrk(ptrdiff_t incr)
54 | {
55 | extern uint8_t _end; /* Symbol defined in the linker script */
56 | extern uint8_t _estack; /* Symbol defined in the linker script */
57 | extern uint32_t _Min_Stack_Size; /* Symbol defined in the linker script */
58 | const uint32_t stack_limit = (uint32_t)&_estack - (uint32_t)&_Min_Stack_Size;
59 | const uint8_t *max_heap = (uint8_t *)stack_limit;
60 | uint8_t *prev_heap_end;
61 |
62 | /* Initialize heap end at first call */
63 | if (NULL == __sbrk_heap_end)
64 | {
65 | __sbrk_heap_end = &_end;
66 | }
67 |
68 | /* Protect heap from growing into the reserved MSP stack */
69 | if (__sbrk_heap_end + incr > max_heap)
70 | {
71 | errno = ENOMEM;
72 | return (void *)-1;
73 | }
74 |
75 | prev_heap_end = __sbrk_heap_end;
76 | __sbrk_heap_end += incr;
77 |
78 | return (void *)prev_heap_end;
79 | }
80 |
--------------------------------------------------------------------------------
/Core/Src/usb_comm.c:
--------------------------------------------------------------------------------
1 | /*
2 | * usb_comm.c
3 | *
4 | * Created on: 18 paź 2022
5 | * Author: KoSik
6 | * e-mail: kosik84@gmail.com
7 | *
8 | * version: 1.0
9 | */
10 | #include
11 | #include
12 | #include
13 |
14 | uint16_t expectedDegree = 0;
15 | uint16_t expectedPosition = 0;
16 | uint16_t expectedPower = 30;
17 | uint8_t mode = 0;
18 |
19 |
20 | uint8_t read_variable(uint8_t *Data, char sparam[3], uint16_t *param, uint8_t array_size){
21 | uint8_t buf[10];
22 | uint8_t q;
23 |
24 | for (q = 0; q < sizeof(buf); q++) { // clean buffer
25 | buf[q] = 0;
26 | }
27 | if (Data[1] == sparam[0] && Data[2] == sparam[1] && Data[3] == sparam[2]) {
28 | for (q = 0; q < sizeof(Data); q++) {
29 | if (Data[4 + q] == '/') {
30 | break;
31 | } else {
32 | buf[q] = Data[4 + q];
33 | }
34 | }
35 | *param = atoi((char*) buf); //variable save
36 | for (uint16_t i = 0; i < (array_size - (4 + q)); i++) {
37 | Data[i] = Data[4 + q + i];
38 | }
39 | return 1;
40 | } else {
41 | return 0;
42 | }
43 | }
44 |
45 | void decode_message(uint8_t *Data, uint8_t array_size) {
46 | for (uint8_t j = 0; j < 3; j++) {
47 | if (Data[0] == '#') {
48 | if (!read_variable(Data, "mod", &mode, array_size)) {
49 | if (!read_variable(Data, "pwr", &expectedPower, array_size)) {
50 | if (!read_variable(Data, "pos", &expectedPosition, array_size)) {
51 | read_variable(Data, "deg", &expectedDegree, array_size);
52 | }
53 | }
54 | }
55 | //------------------------------------------------------------------------
56 |
57 | else {
58 | break;
59 | }
60 | }
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/Drivers/CMSIS/Device/ST/STM32F1xx/Include/stm32f103xb.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KoSik-prog/STM32F103_BLDC_Driver/3d108960543fd65714011477147a4a047ca86acc/Drivers/CMSIS/Device/ST/STM32F1xx/Include/stm32f103xb.h
--------------------------------------------------------------------------------
/Drivers/CMSIS/Device/ST/STM32F1xx/Include/stm32f1xx.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KoSik-prog/STM32F103_BLDC_Driver/3d108960543fd65714011477147a4a047ca86acc/Drivers/CMSIS/Device/ST/STM32F1xx/Include/stm32f1xx.h
--------------------------------------------------------------------------------
/Drivers/CMSIS/Device/ST/STM32F1xx/Include/system_stm32f1xx.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file system_stm32f10x.h
4 | * @author MCD Application Team
5 | * @brief CMSIS Cortex-M3 Device Peripheral Access Layer System Header File.
6 | ******************************************************************************
7 | * @attention
8 | *
9 | * © Copyright (c) 2017 STMicroelectronics.
10 | * All rights reserved.
29 |
30 | /*
31 | * Arm Compiler 4/5
32 | */
33 | #if defined ( __CC_ARM )
34 | #include "cmsis_armcc.h"
35 |
36 |
37 | /*
38 | * Arm Compiler 6 (armclang)
39 | */
40 | #elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
41 | #include "cmsis_armclang.h"
42 |
43 |
44 | /*
45 | * GNU Compiler
46 | */
47 | #elif defined ( __GNUC__ )
48 | #include "cmsis_gcc.h"
49 |
50 |
51 | /*
52 | * IAR Compiler
53 | */
54 | #elif defined ( __ICCARM__ )
55 | #include
56 |
57 |
58 | /*
59 | * TI Arm Compiler
60 | */
61 | #elif defined ( __TI_ARM__ )
62 | #include
63 |
64 | #ifndef __ASM
65 | #define __ASM __asm
66 | #endif
67 | #ifndef __INLINE
68 | #define __INLINE inline
69 | #endif
70 | #ifndef __STATIC_INLINE
71 | #define __STATIC_INLINE static inline
72 | #endif
73 | #ifndef __STATIC_FORCEINLINE
74 | #define __STATIC_FORCEINLINE __STATIC_INLINE
75 | #endif
76 | #ifndef __NO_RETURN
77 | #define __NO_RETURN __attribute__((noreturn))
78 | #endif
79 | #ifndef __USED
80 | #define __USED __attribute__((used))
81 | #endif
82 | #ifndef __WEAK
83 | #define __WEAK __attribute__((weak))
84 | #endif
85 | #ifndef __PACKED
86 | #define __PACKED __attribute__((packed))
87 | #endif
88 | #ifndef __PACKED_STRUCT
89 | #define __PACKED_STRUCT struct __attribute__((packed))
90 | #endif
91 | #ifndef __PACKED_UNION
92 | #define __PACKED_UNION union __attribute__((packed))
93 | #endif
94 | #ifndef __UNALIGNED_UINT32 /* deprecated */
95 | struct __attribute__((packed)) T_UINT32 { uint32_t v; };
96 | #define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v)
97 | #endif
98 | #ifndef __UNALIGNED_UINT16_WRITE
99 | __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
100 | #define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void*)(addr))->v) = (val))
101 | #endif
102 | #ifndef __UNALIGNED_UINT16_READ
103 | __PACKED_STRUCT T_UINT16_READ { uint16_t v; };
104 | #define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v)
105 | #endif
106 | #ifndef __UNALIGNED_UINT32_WRITE
107 | __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
108 | #define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
109 | #endif
110 | #ifndef __UNALIGNED_UINT32_READ
111 | __PACKED_STRUCT T_UINT32_READ { uint32_t v; };
112 | #define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v)
113 | #endif
114 | #ifndef __ALIGNED
115 | #define __ALIGNED(x) __attribute__((aligned(x)))
116 | #endif
117 | #ifndef __RESTRICT
118 | #warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
119 | #define __RESTRICT
120 | #endif
121 |
122 |
123 | /*
124 | * TASKING Compiler
125 | */
126 | #elif defined ( __TASKING__ )
127 | /*
128 | * The CMSIS functions have been implemented as intrinsics in the compiler.
129 | * Please use "carm -?i" to get an up to date list of all intrinsics,
130 | * Including the CMSIS ones.
131 | */
132 |
133 | #ifndef __ASM
134 | #define __ASM __asm
135 | #endif
136 | #ifndef __INLINE
137 | #define __INLINE inline
138 | #endif
139 | #ifndef __STATIC_INLINE
140 | #define __STATIC_INLINE static inline
141 | #endif
142 | #ifndef __STATIC_FORCEINLINE
143 | #define __STATIC_FORCEINLINE __STATIC_INLINE
144 | #endif
145 | #ifndef __NO_RETURN
146 | #define __NO_RETURN __attribute__((noreturn))
147 | #endif
148 | #ifndef __USED
149 | #define __USED __attribute__((used))
150 | #endif
151 | #ifndef __WEAK
152 | #define __WEAK __attribute__((weak))
153 | #endif
154 | #ifndef __PACKED
155 | #define __PACKED __packed__
156 | #endif
157 | #ifndef __PACKED_STRUCT
158 | #define __PACKED_STRUCT struct __packed__
159 | #endif
160 | #ifndef __PACKED_UNION
161 | #define __PACKED_UNION union __packed__
162 | #endif
163 | #ifndef __UNALIGNED_UINT32 /* deprecated */
164 | struct __packed__ T_UINT32 { uint32_t v; };
165 | #define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v)
166 | #endif
167 | #ifndef __UNALIGNED_UINT16_WRITE
168 | __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
169 | #define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
170 | #endif
171 | #ifndef __UNALIGNED_UINT16_READ
172 | __PACKED_STRUCT T_UINT16_READ { uint16_t v; };
173 | #define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v)
174 | #endif
175 | #ifndef __UNALIGNED_UINT32_WRITE
176 | __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
177 | #define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
178 | #endif
179 | #ifndef __UNALIGNED_UINT32_READ
180 | __PACKED_STRUCT T_UINT32_READ { uint32_t v; };
181 | #define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v)
182 | #endif
183 | #ifndef __ALIGNED
184 | #define __ALIGNED(x) __align(x)
185 | #endif
186 | #ifndef __RESTRICT
187 | #warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
188 | #define __RESTRICT
189 | #endif
190 |
191 |
192 | /*
193 | * COSMIC Compiler
194 | */
195 | #elif defined ( __CSMC__ )
196 | #include
197 |
198 | #ifndef __ASM
199 | #define __ASM _asm
200 | #endif
201 | #ifndef __INLINE
202 | #define __INLINE inline
203 | #endif
204 | #ifndef __STATIC_INLINE
205 | #define __STATIC_INLINE static inline
206 | #endif
207 | #ifndef __STATIC_FORCEINLINE
208 | #define __STATIC_FORCEINLINE __STATIC_INLINE
209 | #endif
210 | #ifndef __NO_RETURN
211 | // NO RETURN is automatically detected hence no warning here
212 | #define __NO_RETURN
213 | #endif
214 | #ifndef __USED
215 | #warning No compiler specific solution for __USED. __USED is ignored.
216 | #define __USED
217 | #endif
218 | #ifndef __WEAK
219 | #define __WEAK __weak
220 | #endif
221 | #ifndef __PACKED
222 | #define __PACKED @packed
223 | #endif
224 | #ifndef __PACKED_STRUCT
225 | #define __PACKED_STRUCT @packed struct
226 | #endif
227 | #ifndef __PACKED_UNION
228 | #define __PACKED_UNION @packed union
229 | #endif
230 | #ifndef __UNALIGNED_UINT32 /* deprecated */
231 | @packed struct T_UINT32 { uint32_t v; };
232 | #define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v)
233 | #endif
234 | #ifndef __UNALIGNED_UINT16_WRITE
235 | __PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
236 | #define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
237 | #endif
238 | #ifndef __UNALIGNED_UINT16_READ
239 | __PACKED_STRUCT T_UINT16_READ { uint16_t v; };
240 | #define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v)
241 | #endif
242 | #ifndef __UNALIGNED_UINT32_WRITE
243 | __PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
244 | #define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
245 | #endif
246 | #ifndef __UNALIGNED_UINT32_READ
247 | __PACKED_STRUCT T_UINT32_READ { uint32_t v; };
248 | #define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v)
249 | #endif
250 | #ifndef __ALIGNED
251 | #warning No compiler specific solution for __ALIGNED. __ALIGNED is ignored.
252 | #define __ALIGNED(x)
253 | #endif
254 | #ifndef __RESTRICT
255 | #warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
256 | #define __RESTRICT
257 | #endif
258 |
259 |
260 | #else
261 | #error Unknown compiler.
262 | #endif
263 |
264 |
265 | #endif /* __CMSIS_COMPILER_H */
266 |
267 |
--------------------------------------------------------------------------------
/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 |
--------------------------------------------------------------------------------
/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
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/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_def.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm32f1xx_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 | * © Copyright (c) 2017 STMicroelectronics.
11 | * All rights reserved.
33 |
34 | /* Exported types ------------------------------------------------------------*/
35 |
36 | /**
37 | * @brief HAL Status structures definition
38 | */
39 | typedef enum
40 | {
41 | HAL_OK = 0x00U,
42 | HAL_ERROR = 0x01U,
43 | HAL_BUSY = 0x02U,
44 | HAL_TIMEOUT = 0x03U
45 | } HAL_StatusTypeDef;
46 |
47 | /**
48 | * @brief HAL Lock structures definition
49 | */
50 | typedef enum
51 | {
52 | HAL_UNLOCKED = 0x00U,
53 | HAL_LOCKED = 0x01U
54 | } HAL_LockTypeDef;
55 |
56 | /* Exported macro ------------------------------------------------------------*/
57 | #define HAL_MAX_DELAY 0xFFFFFFFFU
58 |
59 | #define HAL_IS_BIT_SET(REG, BIT) (((REG) & (BIT)) != 0U)
60 | #define HAL_IS_BIT_CLR(REG, BIT) (((REG) & (BIT)) == 0U)
61 |
62 | #define __HAL_LINKDMA(__HANDLE__, __PPP_DMA_FIELD__, __DMA_HANDLE__) \
63 | do{ \
64 | (__HANDLE__)->__PPP_DMA_FIELD__ = &(__DMA_HANDLE__); \
65 | (__DMA_HANDLE__).Parent = (__HANDLE__); \
66 | } while(0U)
67 |
68 | #define UNUSED(X) (void)X /* To avoid gcc/g++ warnings */
69 |
70 | /** @brief Reset the Handle's State field.
71 | * @param __HANDLE__ specifies the Peripheral Handle.
72 | * @note This macro can be used for the following purpose:
73 | * - When the Handle is declared as local variable; before passing it as parameter
74 | * to HAL_PPP_Init() for the first time, it is mandatory to use this macro
75 | * to set to 0 the Handle's "State" field.
76 | * Otherwise, "State" field may have any random value and the first time the function
77 | * HAL_PPP_Init() is called, the low level hardware initialization will be missed
78 | * (i.e. HAL_PPP_MspInit() will not be executed).
79 | * - When there is a need to reconfigure the low level hardware: instead of calling
80 | * HAL_PPP_DeInit() then HAL_PPP_Init(), user can make a call to this macro then HAL_PPP_Init().
81 | * In this later function, when the Handle's "State" field is set to 0, it will execute the function
82 | * HAL_PPP_MspInit() which will reconfigure the low level hardware.
83 | * @retval None
84 | */
85 | #define __HAL_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = 0U)
86 |
87 | #if (USE_RTOS == 1U)
88 | /* Reserved for future use */
89 | #error "USE_RTOS should be 0 in the current HAL release"
90 | #else
91 | #define __HAL_LOCK(__HANDLE__) \
92 | do{ \
93 | if((__HANDLE__)->Lock == HAL_LOCKED) \
94 | { \
95 | return HAL_BUSY; \
96 | } \
97 | else \
98 | { \
99 | (__HANDLE__)->Lock = HAL_LOCKED; \
100 | } \
101 | }while (0U)
102 |
103 | #define __HAL_UNLOCK(__HANDLE__) \
104 | do{ \
105 | (__HANDLE__)->Lock = HAL_UNLOCKED; \
106 | }while (0U)
107 | #endif /* USE_RTOS */
108 |
109 | #if defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) /* ARM Compiler V6 */
110 | #ifndef __weak
111 | #define __weak __attribute__((weak))
112 | #endif
113 | #ifndef __packed
114 | #define __packed __attribute__((packed))
115 | #endif
116 | #elif defined ( __GNUC__ ) && !defined (__CC_ARM) /* GNU Compiler */
117 | #ifndef __weak
118 | #define __weak __attribute__((weak))
119 | #endif /* __weak */
120 | #ifndef __packed
121 | #define __packed __attribute__((__packed__))
122 | #endif /* __packed */
123 | #endif /* __GNUC__ */
124 |
125 |
126 | /* Macro to get variable aligned on 4-bytes, for __ICCARM__ the directive "#pragma data_alignment=4" must be used instead */
127 | #if defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) /* ARM Compiler V6 */
128 | #ifndef __ALIGN_BEGIN
129 | #define __ALIGN_BEGIN
130 | #endif
131 | #ifndef __ALIGN_END
132 | #define __ALIGN_END __attribute__ ((aligned (4)))
133 | #endif
134 | #elif defined ( __GNUC__ ) && !defined (__CC_ARM) /* GNU Compiler */
135 | #ifndef __ALIGN_END
136 | #define __ALIGN_END __attribute__ ((aligned (4)))
137 | #endif /* __ALIGN_END */
138 | #ifndef __ALIGN_BEGIN
139 | #define __ALIGN_BEGIN
140 | #endif /* __ALIGN_BEGIN */
141 | #else
142 | #ifndef __ALIGN_END
143 | #define __ALIGN_END
144 | #endif /* __ALIGN_END */
145 | #ifndef __ALIGN_BEGIN
146 | #if defined (__CC_ARM) /* ARM Compiler V5*/
147 | #define __ALIGN_BEGIN __align(4)
148 | #elif defined (__ICCARM__) /* IAR Compiler */
149 | #define __ALIGN_BEGIN
150 | #endif /* __CC_ARM */
151 | #endif /* __ALIGN_BEGIN */
152 | #endif /* __GNUC__ */
153 |
154 |
155 | /**
156 | * @brief __RAM_FUNC definition
157 | */
158 | #if defined ( __CC_ARM ) || (defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050))
159 | /* ARM Compiler V4/V5 and V6
160 | --------------------------
161 | RAM functions are defined using the toolchain options.
162 | Functions that are executed in RAM should reside in a separate source module.
163 | Using the 'Options for File' dialog you can simply change the 'Code / Const'
164 | area of a module to a memory space in physical RAM.
165 | Available memory areas are declared in the 'Target' tab of the 'Options for Target'
166 | dialog.
167 | */
168 | #define __RAM_FUNC
169 |
170 | #elif defined ( __ICCARM__ )
171 | /* ICCARM Compiler
172 | ---------------
173 | RAM functions are defined using a specific toolchain keyword "__ramfunc".
174 | */
175 | #define __RAM_FUNC __ramfunc
176 |
177 | #elif defined ( __GNUC__ )
178 | /* GNU Compiler
179 | ------------
180 | RAM functions are defined using a specific toolchain attribute
181 | "__attribute__((section(".RamFunc")))".
182 | */
183 | #define __RAM_FUNC __attribute__((section(".RamFunc")))
184 |
185 | #endif
186 |
187 | /**
188 | * @brief __NOINLINE definition
189 | */
190 | #if defined ( __CC_ARM ) || (defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)) || defined ( __GNUC__ )
191 | /* ARM V4/V5 and V6 & GNU Compiler
192 | -------------------------------
193 | */
194 | #define __NOINLINE __attribute__ ( (noinline) )
195 |
196 | #elif defined ( __ICCARM__ )
197 | /* ICCARM Compiler
198 | ---------------
199 | */
200 | #define __NOINLINE _Pragma("optimize = no_inline")
201 |
202 | #endif
203 |
204 | #ifdef __cplusplus
205 | }
206 | #endif
207 |
208 | #endif /* ___STM32F1xx_HAL_DEF */
209 |
210 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
211 |
--------------------------------------------------------------------------------
/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_flash.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm32f1xx_hal_flash.h
4 | * @author MCD Application Team
5 | * @brief Header file of Flash HAL module.
6 | ******************************************************************************
7 | * @attention
8 | *
9 | * © Copyright (c) 2016 STMicroelectronics.
10 | * All rights reserved. ACR |= FLASH_ACR_HLFCYA)
183 |
184 | /**
185 | * @brief Disable the FLASH half cycle access.
186 | * @note half cycle access can only be used with a low-frequency clock of less than
187 | 8 MHz that can be obtained with the use of HSI or HSE but not of PLL.
188 | * @retval None
189 | */
190 | #define __HAL_FLASH_HALF_CYCLE_ACCESS_DISABLE() (FLASH->ACR &= (~FLASH_ACR_HLFCYA))
191 |
192 | /**
193 | * @}
194 | */
195 |
196 | #if defined(FLASH_ACR_LATENCY)
197 | /** @defgroup FLASH_EM_Latency FLASH Latency
198 | * @brief macros to handle FLASH Latency
199 | * @{
200 | */
201 |
202 | /**
203 | * @brief Set the FLASH Latency.
204 | * @param __LATENCY__ FLASH Latency
205 | * The value of this parameter depend on device used within the same series
206 | * @retval None
207 | */
208 | #define __HAL_FLASH_SET_LATENCY(__LATENCY__) (FLASH->ACR = (FLASH->ACR&(~FLASH_ACR_LATENCY)) | (__LATENCY__))
209 |
210 |
211 | /**
212 | * @brief Get the FLASH Latency.
213 | * @retval FLASH Latency
214 | * The value of this parameter depend on device used within the same series
215 | */
216 | #define __HAL_FLASH_GET_LATENCY() (READ_BIT((FLASH->ACR), FLASH_ACR_LATENCY))
217 |
218 | /**
219 | * @}
220 | */
221 |
222 | #endif /* FLASH_ACR_LATENCY */
223 | /** @defgroup FLASH_Prefetch FLASH Prefetch
224 | * @brief macros to handle FLASH Prefetch buffer
225 | * @{
226 | */
227 | /**
228 | * @brief Enable the FLASH prefetch buffer.
229 | * @retval None
230 | */
231 | #define __HAL_FLASH_PREFETCH_BUFFER_ENABLE() (FLASH->ACR |= FLASH_ACR_PRFTBE)
232 |
233 | /**
234 | * @brief Disable the FLASH prefetch buffer.
235 | * @retval None
236 | */
237 | #define __HAL_FLASH_PREFETCH_BUFFER_DISABLE() (FLASH->ACR &= (~FLASH_ACR_PRFTBE))
238 |
239 | /**
240 | * @}
241 | */
242 |
243 | /**
244 | * @}
245 | */
246 |
247 | /* Include FLASH HAL Extended module */
248 | #include "stm32f1xx_hal_flash_ex.h"
249 |
250 | /* Exported functions --------------------------------------------------------*/
251 | /** @addtogroup FLASH_Exported_Functions
252 | * @{
253 | */
254 |
255 | /** @addtogroup FLASH_Exported_Functions_Group1
256 | * @{
257 | */
258 | /* IO operation functions *****************************************************/
259 | HAL_StatusTypeDef HAL_FLASH_Program(uint32_t TypeProgram, uint32_t Address, uint64_t Data);
260 | HAL_StatusTypeDef HAL_FLASH_Program_IT(uint32_t TypeProgram, uint32_t Address, uint64_t Data);
261 |
262 | /* FLASH IRQ handler function */
263 | void HAL_FLASH_IRQHandler(void);
264 | /* Callbacks in non blocking modes */
265 | void HAL_FLASH_EndOfOperationCallback(uint32_t ReturnValue);
266 | void HAL_FLASH_OperationErrorCallback(uint32_t ReturnValue);
267 |
268 | /**
269 | * @}
270 | */
271 |
272 | /** @addtogroup FLASH_Exported_Functions_Group2
273 | * @{
274 | */
275 | /* Peripheral Control functions ***********************************************/
276 | HAL_StatusTypeDef HAL_FLASH_Unlock(void);
277 | HAL_StatusTypeDef HAL_FLASH_Lock(void);
278 | HAL_StatusTypeDef HAL_FLASH_OB_Unlock(void);
279 | HAL_StatusTypeDef HAL_FLASH_OB_Lock(void);
280 | void HAL_FLASH_OB_Launch(void);
281 |
282 | /**
283 | * @}
284 | */
285 |
286 | /** @addtogroup FLASH_Exported_Functions_Group3
287 | * @{
288 | */
289 | /* Peripheral State and Error functions ***************************************/
290 | uint32_t HAL_FLASH_GetError(void);
291 |
292 | /**
293 | * @}
294 | */
295 |
296 | /**
297 | * @}
298 | */
299 |
300 | /* Private function -------------------------------------------------*/
301 | /** @addtogroup FLASH_Private_Functions
302 | * @{
303 | */
304 | HAL_StatusTypeDef FLASH_WaitForLastOperation(uint32_t Timeout);
305 | #if defined(FLASH_BANK2_END)
306 | HAL_StatusTypeDef FLASH_WaitForLastOperationBank2(uint32_t Timeout);
307 | #endif /* FLASH_BANK2_END */
308 |
309 | /**
310 | * @}
311 | */
312 |
313 | /**
314 | * @}
315 | */
316 |
317 | /**
318 | * @}
319 | */
320 |
321 | #ifdef __cplusplus
322 | }
323 | #endif
324 |
325 | #endif /* __STM32F1xx_HAL_FLASH_H */
326 |
327 | /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
328 |
329 |
--------------------------------------------------------------------------------
/Drivers/STM32F1xx_HAL_Driver/Inc/stm32f1xx_hal_pcd_ex.h:
--------------------------------------------------------------------------------
1 | /**
2 | ******************************************************************************
3 | * @file stm32f1xx_hal_pcd_ex.h
4 | * @author MCD Application Team
5 | * @brief Header file of PCD HAL Extension module.
6 | ******************************************************************************
7 | * @attention
8 | *
9 | * © Copyright (c) 2016 STMicroelectronics.
10 | * All rights reserved. © Copyright (c) 2016 STMicroelectronics.
10 | * All rights reserved. © Copyright (c) 2016 STMicroelectronics.
22 | * All rights reserved. © Copyright (c) 2016 STMicroelectronics.
29 | * All rights reserved. © Copyright (c) 2016 STMicroelectronics.
14 | * All rights reserved. © Copyright (c) 2015 STMicroelectronics.
10 | * All rights reserved. © Copyright (c) 2015 STMicroelectronics.
10 | * All rights reserved. © Copyright (c) 2015 STMicroelectronics.
10 | * All rights reserved. © Copyright (c) 2015 STMicroelectronics.
10 | * All rights reserved. © Copyright (c) 2015 STMicroelectronics.
10 | * All rights reserved.
3 |
73 |
75 |
76 |
78 |
81 |
--------------------------------------------------------------------------------
/STM32F103_BLDC_Driver.launch:
--------------------------------------------------------------------------------
1 |
2 |
3 |
73 |
75 |
76 |
78 |
81 |
--------------------------------------------------------------------------------
/USB_DEVICE/App/usb_device.c:
--------------------------------------------------------------------------------
1 | /* USER CODE BEGIN Header */
2 | /**
3 | ******************************************************************************
4 | * @file : usb_device.c
5 | * @version : v2.0_Cube
6 | * @brief : This file implements the USB Device
7 | ******************************************************************************
8 | * @attention
9 | *
10 | * Copyright (c) 2022 STMicroelectronics.
11 | * All rights reserved.
12 | *
13 | * This software is licensed under terms that can be found in the LICENSE file
14 | * in the root directory of this software component.
15 | * If no LICENSE file comes with this software, it is provided AS-IS.
16 | *
17 | ******************************************************************************
18 | */
19 | /* USER CODE END Header */
20 |
21 | /* Includes ------------------------------------------------------------------*/
22 |
23 | #include "usb_device.h"
24 | #include "usbd_core.h"
25 | #include "usbd_desc.h"
26 | #include "usbd_cdc.h"
27 | #include "usbd_cdc_if.h"
28 |
29 | /* USER CODE BEGIN Includes */
30 |
31 | /* USER CODE END Includes */
32 |
33 | /* USER CODE BEGIN PV */
34 | /* Private variables ---------------------------------------------------------*/
35 |
36 | /* USER CODE END PV */
37 |
38 | /* USER CODE BEGIN PFP */
39 | /* Private function prototypes -----------------------------------------------*/
40 |
41 | /* USER CODE END PFP */
42 |
43 | /* USB Device Core handle declaration. */
44 | USBD_HandleTypeDef hUsbDeviceFS;
45 |
46 | /*
47 | * -- Insert your variables declaration here --
48 | */
49 | /* USER CODE BEGIN 0 */
50 |
51 | /* USER CODE END 0 */
52 |
53 | /*
54 | * -- Insert your external function declaration here --
55 | */
56 | /* USER CODE BEGIN 1 */
57 |
58 | /* USER CODE END 1 */
59 |
60 | /**
61 | * Init USB device Library, add supported class and start the library
62 | * @retval None
63 | */
64 | void MX_USB_DEVICE_Init(void)
65 | {
66 | /* USER CODE BEGIN USB_DEVICE_Init_PreTreatment */
67 |
68 | /* USER CODE END USB_DEVICE_Init_PreTreatment */
69 |
70 | /* Init Device Library, add supported class and start the library. */
71 | if (USBD_Init(&hUsbDeviceFS, &FS_Desc, DEVICE_FS) != USBD_OK)
72 | {
73 | Error_Handler();
74 | }
75 | if (USBD_RegisterClass(&hUsbDeviceFS, &USBD_CDC) != USBD_OK)
76 | {
77 | Error_Handler();
78 | }
79 | if (USBD_CDC_RegisterInterface(&hUsbDeviceFS, &USBD_Interface_fops_FS) != USBD_OK)
80 | {
81 | Error_Handler();
82 | }
83 | if (USBD_Start(&hUsbDeviceFS) != USBD_OK)
84 | {
85 | Error_Handler();
86 | }
87 |
88 | /* USER CODE BEGIN USB_DEVICE_Init_PostTreatment */
89 |
90 | /* USER CODE END USB_DEVICE_Init_PostTreatment */
91 | }
92 |
93 | /**
94 | * @}
95 | */
96 |
97 | /**
98 | * @}
99 | */
100 |
101 |
--------------------------------------------------------------------------------
/USB_DEVICE/App/usb_device.h:
--------------------------------------------------------------------------------
1 | /* USER CODE BEGIN Header */
2 | /**
3 | ******************************************************************************
4 | * @file : usb_device.h
5 | * @version : v2.0_Cube
6 | * @brief : Header for usb_device.c file.
7 | ******************************************************************************
8 | * @attention
9 | *
10 | * Copyright (c) 2022 STMicroelectronics.
11 | * All rights reserved.
12 | *
13 | * This software is licensed under terms that can be found in the LICENSE file
14 | * in the root directory of this software component.
15 | * If no LICENSE file comes with this software, it is provided AS-IS.
16 | *
17 | ******************************************************************************
18 | */
19 | /* USER CODE END Header */
20 |
21 | /* Define to prevent recursive inclusion -------------------------------------*/
22 | #ifndef __USB_DEVICE__H__
23 | #define __USB_DEVICE__H__
24 |
25 | #ifdef __cplusplus
26 | extern "C" {
27 | #endif
28 |
29 | /* Includes ------------------------------------------------------------------*/
30 | #include "stm32f1xx.h"
31 | #include "stm32f1xx_hal.h"
32 | #include "usbd_def.h"
33 |
34 | /* USER CODE BEGIN INCLUDE */
35 |
36 | /* USER CODE END INCLUDE */
37 |
38 | /** @addtogroup USBD_OTG_DRIVER
39 | * @{
40 | */
41 |
42 | /** @defgroup USBD_DEVICE USBD_DEVICE
43 | * @brief Device file for Usb otg low level driver.
44 | * @{
45 | */
46 |
47 | /** @defgroup USBD_DEVICE_Exported_Variables USBD_DEVICE_Exported_Variables
48 | * @brief Public variables.
49 | * @{
50 | */
51 |
52 | /* Private variables ---------------------------------------------------------*/
53 | /* USER CODE BEGIN PV */
54 |
55 | /* USER CODE END PV */
56 |
57 | /* Private function prototypes -----------------------------------------------*/
58 | /* USER CODE BEGIN PFP */
59 |
60 | /* USER CODE END PFP */
61 |
62 | /*
63 | * -- Insert your variables declaration here --
64 | */
65 | /* USER CODE BEGIN VARIABLES */
66 |
67 | /* USER CODE END VARIABLES */
68 | /**
69 | * @}
70 | */
71 |
72 | /** @defgroup USBD_DEVICE_Exported_FunctionsPrototype USBD_DEVICE_Exported_FunctionsPrototype
73 | * @brief Declaration of public functions for Usb device.
74 | * @{
75 | */
76 |
77 | /** USB Device initialization function. */
78 | void MX_USB_DEVICE_Init(void);
79 |
80 | /*
81 | * -- Insert functions declaration here --
82 | */
83 | /* USER CODE BEGIN FD */
84 |
85 | /* USER CODE END FD */
86 | /**
87 | * @}
88 | */
89 |
90 | /**
91 | * @}
92 | */
93 |
94 | /**
95 | * @}
96 | */
97 |
98 | #ifdef __cplusplus
99 | }
100 | #endif
101 |
102 | #endif /* __USB_DEVICE__H__ */
103 |
--------------------------------------------------------------------------------
/USB_DEVICE/App/usbd_cdc_if.c:
--------------------------------------------------------------------------------
1 | /* USER CODE BEGIN Header */
2 | /**
3 | ******************************************************************************
4 | * @file : usbd_cdc_if.c
5 | * @version : v2.0_Cube
6 | * @brief : Usb device for Virtual Com Port.
7 | ******************************************************************************
8 | * @attention
9 | *
10 | * Copyright (c) 2022 STMicroelectronics.
11 | * All rights reserved.
12 | *
13 | * This software is licensed under terms that can be found in the LICENSE file
14 | * in the root directory of this software component.
15 | * If no LICENSE file comes with this software, it is provided AS-IS.
16 | *
17 | ******************************************************************************
18 | */
19 | /* USER CODE END Header */
20 |
21 | /* Includes ------------------------------------------------------------------*/
22 | #include "usbd_cdc_if.h"
23 |
24 | /* USER CODE BEGIN INCLUDE */
25 | #include "usb_comm.h"
26 | /* USER CODE END INCLUDE */
27 |
28 | /* Private typedef -----------------------------------------------------------*/
29 | /* Private define ------------------------------------------------------------*/
30 | /* Private macro -------------------------------------------------------------*/
31 |
32 | /* USER CODE BEGIN PV */
33 | /* Private variables ---------------------------------------------------------*/
34 |
35 | /* USER CODE END PV */
36 |
37 | /** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
38 | * @brief Usb device library.
39 | * @{
40 | */
41 |
42 | /** @addtogroup USBD_CDC_IF
43 | * @{
44 | */
45 |
46 | /** @defgroup USBD_CDC_IF_Private_TypesDefinitions USBD_CDC_IF_Private_TypesDefinitions
47 | * @brief Private types.
48 | * @{
49 | */
50 |
51 | /* USER CODE BEGIN PRIVATE_TYPES */
52 |
53 | /* USER CODE END PRIVATE_TYPES */
54 |
55 | /**
56 | * @}
57 | */
58 |
59 | /** @defgroup USBD_CDC_IF_Private_Defines USBD_CDC_IF_Private_Defines
60 | * @brief Private defines.
61 | * @{
62 | */
63 |
64 | /* USER CODE BEGIN PRIVATE_DEFINES */
65 | /* USER CODE END PRIVATE_DEFINES */
66 |
67 | /**
68 | * @}
69 | */
70 |
71 | /** @defgroup USBD_CDC_IF_Private_Macros USBD_CDC_IF_Private_Macros
72 | * @brief Private macros.
73 | * @{
74 | */
75 |
76 | /* USER CODE BEGIN PRIVATE_MACRO */
77 |
78 | /* USER CODE END PRIVATE_MACRO */
79 |
80 | /**
81 | * @}
82 | */
83 |
84 | /** @defgroup USBD_CDC_IF_Private_Variables USBD_CDC_IF_Private_Variables
85 | * @brief Private variables.
86 | * @{
87 | */
88 | /* Create buffer for reception and transmission */
89 | /* It's up to user to redefine and/or remove those define */
90 | /** Received data over USB are stored in this buffer */
91 | uint8_t UserRxBufferFS[APP_RX_DATA_SIZE];
92 |
93 | /** Data to send over USB CDC are stored in this buffer */
94 | uint8_t UserTxBufferFS[APP_TX_DATA_SIZE];
95 |
96 | /* USER CODE BEGIN PRIVATE_VARIABLES */
97 |
98 | /* USER CODE END PRIVATE_VARIABLES */
99 |
100 | /**
101 | * @}
102 | */
103 |
104 | /** @defgroup USBD_CDC_IF_Exported_Variables USBD_CDC_IF_Exported_Variables
105 | * @brief Public variables.
106 | * @{
107 | */
108 |
109 | extern USBD_HandleTypeDef hUsbDeviceFS;
110 |
111 | /* USER CODE BEGIN EXPORTED_VARIABLES */
112 |
113 | /* USER CODE END EXPORTED_VARIABLES */
114 |
115 | /**
116 | * @}
117 | */
118 |
119 | /** @defgroup USBD_CDC_IF_Private_FunctionPrototypes USBD_CDC_IF_Private_FunctionPrototypes
120 | * @brief Private functions declaration.
121 | * @{
122 | */
123 |
124 | static int8_t CDC_Init_FS(void);
125 | static int8_t CDC_DeInit_FS(void);
126 | static int8_t CDC_Control_FS(uint8_t cmd, uint8_t* pbuf, uint16_t length);
127 | static int8_t CDC_Receive_FS(uint8_t* pbuf, uint32_t *Len);
128 |
129 | /* USER CODE BEGIN PRIVATE_FUNCTIONS_DECLARATION */
130 |
131 | /* USER CODE END PRIVATE_FUNCTIONS_DECLARATION */
132 |
133 | /**
134 | * @}
135 | */
136 |
137 | USBD_CDC_ItfTypeDef USBD_Interface_fops_FS =
138 | {
139 | CDC_Init_FS,
140 | CDC_DeInit_FS,
141 | CDC_Control_FS,
142 | CDC_Receive_FS
143 | };
144 |
145 | /* Private functions ---------------------------------------------------------*/
146 | /**
147 | * @brief Initializes the CDC media low layer over the FS USB IP
148 | * @retval USBD_OK if all operations are OK else USBD_FAIL
149 | */
150 | static int8_t CDC_Init_FS(void)
151 | {
152 | /* USER CODE BEGIN 3 */
153 | /* Set Application Buffers */
154 | USBD_CDC_SetTxBuffer(&hUsbDeviceFS, UserTxBufferFS, 0);
155 | USBD_CDC_SetRxBuffer(&hUsbDeviceFS, UserRxBufferFS);
156 | return (USBD_OK);
157 | /* USER CODE END 3 */
158 | }
159 |
160 | /**
161 | * @brief DeInitializes the CDC media low layer
162 | * @retval USBD_OK if all operations are OK else USBD_FAIL
163 | */
164 | static int8_t CDC_DeInit_FS(void)
165 | {
166 | /* USER CODE BEGIN 4 */
167 | return (USBD_OK);
168 | /* USER CODE END 4 */
169 | }
170 |
171 | /**
172 | * @brief Manage the CDC class requests
173 | * @param cmd: Command code
174 | * @param pbuf: Buffer containing command data (request parameters)
175 | * @param length: Number of data to be sent (in bytes)
176 | * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
177 | */
178 | static int8_t CDC_Control_FS(uint8_t cmd, uint8_t* pbuf, uint16_t length)
179 | {
180 | /* USER CODE BEGIN 5 */
181 | switch(cmd)
182 | {
183 | case CDC_SEND_ENCAPSULATED_COMMAND:
184 |
185 | break;
186 |
187 | case CDC_GET_ENCAPSULATED_RESPONSE:
188 |
189 | break;
190 |
191 | case CDC_SET_COMM_FEATURE:
192 |
193 | break;
194 |
195 | case CDC_GET_COMM_FEATURE:
196 |
197 | break;
198 |
199 | case CDC_CLEAR_COMM_FEATURE:
200 |
201 | break;
202 |
203 | /*******************************************************************************/
204 | /* Line Coding Structure */
205 | /*-----------------------------------------------------------------------------*/
206 | /* Offset | Field | Size | Value | Description */
207 | /* 0 | dwDTERate | 4 | Number |Data terminal rate, in bits per second*/
208 | /* 4 | bCharFormat | 1 | Number | Stop bits */
209 | /* 0 - 1 Stop bit */
210 | /* 1 - 1.5 Stop bits */
211 | /* 2 - 2 Stop bits */
212 | /* 5 | bParityType | 1 | Number | Parity */
213 | /* 0 - None */
214 | /* 1 - Odd */
215 | /* 2 - Even */
216 | /* 3 - Mark */
217 | /* 4 - Space */
218 | /* 6 | bDataBits | 1 | Number Data bits (5, 6, 7, 8 or 16). */
219 | /*******************************************************************************/
220 | case CDC_SET_LINE_CODING:
221 |
222 | break;
223 |
224 | case CDC_GET_LINE_CODING:
225 |
226 | break;
227 |
228 | case CDC_SET_CONTROL_LINE_STATE:
229 |
230 | break;
231 |
232 | case CDC_SEND_BREAK:
233 |
234 | break;
235 |
236 | default:
237 | break;
238 | }
239 |
240 | return (USBD_OK);
241 | /* USER CODE END 5 */
242 | }
243 |
244 | /**
245 | * @brief Data received over USB OUT endpoint are sent over CDC interface
246 | * through this function.
247 | *
248 | * @note
249 | * This function will issue a NAK packet on any OUT packet received on
250 | * USB endpoint until exiting this function. If you exit this function
251 | * before transfer is complete on CDC interface (ie. using DMA controller)
252 | * it will result in receiving more data while previous ones are still
253 | * not sent.
254 | *
255 | * @param Buf: Buffer of data to be received
256 | * @param Len: Number of data received (in bytes)
257 | * @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
258 | */
259 | static int8_t CDC_Receive_FS(uint8_t* Buf, uint32_t *Len)
260 | {
261 | /* USER CODE BEGIN 6 */
262 | USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &Buf[0]);
263 | USBD_CDC_ReceivePacket(&hUsbDeviceFS);
264 |
265 | extern uint8_t ReceivedData[40];
266 |
267 | for (uint8_t iter = 0; iter < 40; ++iter) {
268 | ReceivedData[iter] = 0;
269 | }
270 |
271 | strlcpy((char*)ReceivedData, (char*)Buf, (*Len) + 1);
272 |
273 | uint8_t DataToSend[80];
274 | uint8_t MessageLength = 0;
275 |
276 | if (ReceivedData[0] == '?') {
277 | MessageLength = sprintf((char*)DataToSend, "$%s/\n\r", "BLDCController");
278 | CDC_Transmit_FS(DataToSend, MessageLength);
279 | } else {
280 | decode_message(ReceivedData, 40);
281 | }
282 |
283 | return (USBD_OK);
284 | /* USER CODE END 6 */
285 | }
286 |
287 | /**
288 | * @brief CDC_Transmit_FS
289 | * Data to send over USB IN endpoint are sent over CDC interface
290 | * through this function.
291 | * @note
292 | *
293 | *
294 | * @param Buf: Buffer of data to be sent
295 | * @param Len: Number of data to be sent (in bytes)
296 | * @retval USBD_OK if all operations are OK else USBD_FAIL or USBD_BUSY
297 | */
298 | uint8_t CDC_Transmit_FS(uint8_t* Buf, uint16_t Len)
299 | {
300 | uint8_t result = USBD_OK;
301 | /* USER CODE BEGIN 7 */
302 | USBD_CDC_HandleTypeDef *hcdc = (USBD_CDC_HandleTypeDef*)hUsbDeviceFS.pClassData;
303 | if (hcdc->TxState != 0){
304 | return USBD_BUSY;
305 | }
306 | USBD_CDC_SetTxBuffer(&hUsbDeviceFS, Buf, Len);
307 | result = USBD_CDC_TransmitPacket(&hUsbDeviceFS);
308 | /* USER CODE END 7 */
309 | return result;
310 | }
311 |
312 | /* USER CODE BEGIN PRIVATE_FUNCTIONS_IMPLEMENTATION */
313 |
314 | /* USER CODE END PRIVATE_FUNCTIONS_IMPLEMENTATION */
315 |
316 | /**
317 | * @}
318 | */
319 |
320 | /**
321 | * @}
322 | */
323 |
--------------------------------------------------------------------------------
/USB_DEVICE/App/usbd_cdc_if.h:
--------------------------------------------------------------------------------
1 | /* USER CODE BEGIN Header */
2 | /**
3 | ******************************************************************************
4 | * @file : usbd_cdc_if.h
5 | * @version : v2.0_Cube
6 | * @brief : Header for usbd_cdc_if.c file.
7 | ******************************************************************************
8 | * @attention
9 | *
10 | * Copyright (c) 2022 STMicroelectronics.
11 | * All rights reserved.
12 | *
13 | * This software is licensed under terms that can be found in the LICENSE file
14 | * in the root directory of this software component.
15 | * If no LICENSE file comes with this software, it is provided AS-IS.
16 | *
17 | ******************************************************************************
18 | */
19 | /* USER CODE END Header */
20 |
21 | /* Define to prevent recursive inclusion -------------------------------------*/
22 | #ifndef __USBD_CDC_IF_H__
23 | #define __USBD_CDC_IF_H__
24 |
25 | #ifdef __cplusplus
26 | extern "C" {
27 | #endif
28 |
29 | /* Includes ------------------------------------------------------------------*/
30 | #include "usbd_cdc.h"
31 |
32 | /* USER CODE BEGIN INCLUDE */
33 |
34 | /* USER CODE END INCLUDE */
35 |
36 | /** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
37 | * @brief For Usb device.
38 | * @{
39 | */
40 |
41 | /** @defgroup USBD_CDC_IF USBD_CDC_IF
42 | * @brief Usb VCP device module
43 | * @{
44 | */
45 |
46 | /** @defgroup USBD_CDC_IF_Exported_Defines USBD_CDC_IF_Exported_Defines
47 | * @brief Defines.
48 | * @{
49 | */
50 | /* Define size for the receive and transmit buffer over CDC */
51 | #define APP_RX_DATA_SIZE 1000
52 | #define APP_TX_DATA_SIZE 1000
53 | /* USER CODE BEGIN EXPORTED_DEFINES */
54 |
55 | /* USER CODE END EXPORTED_DEFINES */
56 |
57 | /**
58 | * @}
59 | */
60 |
61 | /** @defgroup USBD_CDC_IF_Exported_Types USBD_CDC_IF_Exported_Types
62 | * @brief Types.
63 | * @{
64 | */
65 |
66 | /* USER CODE BEGIN EXPORTED_TYPES */
67 |
68 | /* USER CODE END EXPORTED_TYPES */
69 |
70 | /**
71 | * @}
72 | */
73 |
74 | /** @defgroup USBD_CDC_IF_Exported_Macros USBD_CDC_IF_Exported_Macros
75 | * @brief Aliases.
76 | * @{
77 | */
78 |
79 | /* USER CODE BEGIN EXPORTED_MACRO */
80 |
81 | /* USER CODE END EXPORTED_MACRO */
82 |
83 | /**
84 | * @}
85 | */
86 |
87 | /** @defgroup USBD_CDC_IF_Exported_Variables USBD_CDC_IF_Exported_Variables
88 | * @brief Public variables.
89 | * @{
90 | */
91 |
92 | /** CDC Interface callback. */
93 | extern USBD_CDC_ItfTypeDef USBD_Interface_fops_FS;
94 |
95 | /* USER CODE BEGIN EXPORTED_VARIABLES */
96 |
97 | /* USER CODE END EXPORTED_VARIABLES */
98 |
99 | /**
100 | * @}
101 | */
102 |
103 | /** @defgroup USBD_CDC_IF_Exported_FunctionsPrototype USBD_CDC_IF_Exported_FunctionsPrototype
104 | * @brief Public functions declaration.
105 | * @{
106 | */
107 |
108 | uint8_t CDC_Transmit_FS(uint8_t* Buf, uint16_t Len);
109 |
110 | /* USER CODE BEGIN EXPORTED_FUNCTIONS */
111 |
112 | /* USER CODE END EXPORTED_FUNCTIONS */
113 |
114 | /**
115 | * @}
116 | */
117 |
118 | /**
119 | * @}
120 | */
121 |
122 | /**
123 | * @}
124 | */
125 |
126 | #ifdef __cplusplus
127 | }
128 | #endif
129 |
130 | #endif /* __USBD_CDC_IF_H__ */
131 |
132 |
--------------------------------------------------------------------------------
/USB_DEVICE/App/usbd_desc.h:
--------------------------------------------------------------------------------
1 | /* USER CODE BEGIN Header */
2 | /**
3 | ******************************************************************************
4 | * @file : usbd_desc.c
5 | * @version : v2.0_Cube
6 | * @brief : Header for usbd_conf.c file.
7 | ******************************************************************************
8 | * @attention
9 | *
10 | * Copyright (c) 2022 STMicroelectronics.
11 | * All rights reserved.
12 | *
13 | * This software is licensed under terms that can be found in the LICENSE file
14 | * in the root directory of this software component.
15 | * If no LICENSE file comes with this software, it is provided AS-IS.
16 | *
17 | ******************************************************************************
18 | */
19 | /* USER CODE END Header */
20 | /* Define to prevent recursive inclusion -------------------------------------*/
21 | #ifndef __USBD_DESC__C__
22 | #define __USBD_DESC__C__
23 |
24 | #ifdef __cplusplus
25 | extern "C" {
26 | #endif
27 |
28 | /* Includes ------------------------------------------------------------------*/
29 | #include "usbd_def.h"
30 |
31 | /* USER CODE BEGIN INCLUDE */
32 |
33 | /* USER CODE END INCLUDE */
34 |
35 | /** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
36 | * @{
37 | */
38 |
39 | /** @defgroup USBD_DESC USBD_DESC
40 | * @brief Usb device descriptors module.
41 | * @{
42 | */
43 |
44 | /** @defgroup USBD_DESC_Exported_Constants USBD_DESC_Exported_Constants
45 | * @brief Constants.
46 | * @{
47 | */
48 | #define DEVICE_ID1 (UID_BASE)
49 | #define DEVICE_ID2 (UID_BASE + 0x4)
50 | #define DEVICE_ID3 (UID_BASE + 0x8)
51 |
52 | #define USB_SIZ_STRING_SERIAL 0x1A
53 |
54 | /* USER CODE BEGIN EXPORTED_CONSTANTS */
55 |
56 | /* USER CODE END EXPORTED_CONSTANTS */
57 |
58 | /**
59 | * @}
60 | */
61 |
62 | /** @defgroup USBD_DESC_Exported_Defines USBD_DESC_Exported_Defines
63 | * @brief Defines.
64 | * @{
65 | */
66 |
67 | /* USER CODE BEGIN EXPORTED_DEFINES */
68 |
69 | /* USER CODE END EXPORTED_DEFINES */
70 |
71 | /**
72 | * @}
73 | */
74 |
75 | /** @defgroup USBD_DESC_Exported_TypesDefinitions USBD_DESC_Exported_TypesDefinitions
76 | * @brief Types.
77 | * @{
78 | */
79 |
80 | /* USER CODE BEGIN EXPORTED_TYPES */
81 |
82 | /* USER CODE END EXPORTED_TYPES */
83 |
84 | /**
85 | * @}
86 | */
87 |
88 | /** @defgroup USBD_DESC_Exported_Macros USBD_DESC_Exported_Macros
89 | * @brief Aliases.
90 | * @{
91 | */
92 |
93 | /* USER CODE BEGIN EXPORTED_MACRO */
94 |
95 | /* USER CODE END EXPORTED_MACRO */
96 |
97 | /**
98 | * @}
99 | */
100 |
101 | /** @defgroup USBD_DESC_Exported_Variables USBD_DESC_Exported_Variables
102 | * @brief Public variables.
103 | * @{
104 | */
105 |
106 | /** Descriptor for the Usb device. */
107 | extern USBD_DescriptorsTypeDef FS_Desc;
108 |
109 | /* USER CODE BEGIN EXPORTED_VARIABLES */
110 |
111 | /* USER CODE END EXPORTED_VARIABLES */
112 |
113 | /**
114 | * @}
115 | */
116 |
117 | /** @defgroup USBD_DESC_Exported_FunctionsPrototype USBD_DESC_Exported_FunctionsPrototype
118 | * @brief Public functions declaration.
119 | * @{
120 | */
121 |
122 | /* USER CODE BEGIN EXPORTED_FUNCTIONS */
123 |
124 | /* USER CODE END EXPORTED_FUNCTIONS */
125 |
126 | /**
127 | * @}
128 | */
129 |
130 | /**
131 | * @}
132 | */
133 |
134 | /**
135 | * @}
136 | */
137 |
138 | #ifdef __cplusplus
139 | }
140 | #endif
141 |
142 | #endif /* __USBD_DESC__C__ */
143 |
144 |
--------------------------------------------------------------------------------
/USB_DEVICE/Target/usbd_conf.h:
--------------------------------------------------------------------------------
1 | /* USER CODE BEGIN Header */
2 | /**
3 | ******************************************************************************
4 | * @file : usbd_conf.h
5 | * @version : v2.0_Cube
6 | * @brief : Header for usbd_conf.c file.
7 | ******************************************************************************
8 | * @attention
9 | *
10 | * Copyright (c) 2022 STMicroelectronics.
11 | * All rights reserved.
12 | *
13 | * This software is licensed under terms that can be found in the LICENSE file
14 | * in the root directory of this software component.
15 | * If no LICENSE file comes with this software, it is provided AS-IS.
16 | *
17 | ******************************************************************************
18 | */
19 | /* USER CODE END Header */
20 |
21 | /* Define to prevent recursive inclusion -------------------------------------*/
22 | #ifndef __USBD_CONF__H__
23 | #define __USBD_CONF__H__
24 |
25 | #ifdef __cplusplus
26 | extern "C" {
27 | #endif
28 |
29 | /* Includes ------------------------------------------------------------------*/
30 | #include
31 | #include
32 | #include
33 | #include "main.h"
34 | #include "stm32f1xx.h"
35 | #include "stm32f1xx_hal.h"
36 |
37 | /* USER CODE BEGIN INCLUDE */
38 |
39 | /* USER CODE END INCLUDE */
40 |
41 | /** @addtogroup USBD_OTG_DRIVER
42 | * @{
43 | */
44 |
45 | /** @defgroup USBD_CONF USBD_CONF
46 | * @brief Configuration file for Usb otg low level driver.
47 | * @{
48 | */
49 |
50 | /** @defgroup USBD_CONF_Exported_Variables USBD_CONF_Exported_Variables
51 | * @brief Public variables.
52 | * @{
53 | */
54 |
55 | /**
56 | * @}
57 | */
58 |
59 | /** @defgroup USBD_CONF_Exported_Defines USBD_CONF_Exported_Defines
60 | * @brief Defines for configuration of the Usb device.
61 | * @{
62 | */
63 |
64 | /*---------- -----------*/
65 | #define USBD_MAX_NUM_INTERFACES 1
66 | /*---------- -----------*/
67 | #define USBD_MAX_NUM_CONFIGURATION 1
68 | /*---------- -----------*/
69 | #define USBD_MAX_STR_DESC_SIZ 512
70 | /*---------- -----------*/
71 | #define USBD_DEBUG_LEVEL 0
72 | /*---------- -----------*/
73 | #define USBD_SELF_POWERED 1
74 | /*---------- -----------*/
75 | #define MAX_STATIC_ALLOC_SIZE 512
76 |
77 | /****************************************/
78 | /* #define for FS and HS identification */
79 | #define DEVICE_FS 0
80 |
81 | /**
82 | * @}
83 | */
84 |
85 | /** @defgroup USBD_CONF_Exported_Macros USBD_CONF_Exported_Macros
86 | * @brief Aliases.
87 | * @{
88 | */
89 |
90 | /* Memory management macros */
91 |
92 | /** Alias for memory allocation. */
93 | #define USBD_malloc (uint32_t *)USBD_static_malloc
94 |
95 | /** Alias for memory release. */
96 | #define USBD_free USBD_static_free
97 |
98 | /** Alias for memory set. */
99 | #define USBD_memset /* Not used */
100 |
101 | /** Alias for memory copy. */
102 | #define USBD_memcpy /* Not used */
103 |
104 | /** Alias for delay. */
105 | #define USBD_Delay HAL_Delay
106 |
107 | /* For footprint reasons and since only one allocation is handled in the HID class
108 | driver, the malloc/free is changed into a static allocation method */
109 | void *USBD_static_malloc(uint32_t size);
110 | void USBD_static_free(void *p);
111 |
112 | /* DEBUG macros */
113 |
114 | #if (USBD_DEBUG_LEVEL > 0)
115 | #define USBD_UsrLog(...) printf(__VA_ARGS__);\
116 | printf("\n");
117 | #else
118 | #define USBD_UsrLog(...)
119 | #endif
120 |
121 | #if (USBD_DEBUG_LEVEL > 1)
122 |
123 | #define USBD_ErrLog(...) printf("ERROR: ") ;\
124 | printf(__VA_ARGS__);\
125 | printf("\n");
126 | #else
127 | #define USBD_ErrLog(...)
128 | #endif
129 |
130 | #if (USBD_DEBUG_LEVEL > 2)
131 | #define USBD_DbgLog(...) printf("DEBUG : ") ;\
132 | printf(__VA_ARGS__);\
133 | printf("\n");
134 | #else
135 | #define USBD_DbgLog(...)
136 | #endif
137 |
138 | /**
139 | * @}
140 | */
141 |
142 | /** @defgroup USBD_CONF_Exported_Types USBD_CONF_Exported_Types
143 | * @brief Types.
144 | * @{
145 | */
146 |
147 | /**
148 | * @}
149 | */
150 |
151 | /** @defgroup USBD_CONF_Exported_FunctionsPrototype USBD_CONF_Exported_FunctionsPrototype
152 | * @brief Declaration of public functions for Usb device.
153 | * @{
154 | */
155 |
156 | /* Exported functions -------------------------------------------------------*/
157 |
158 | /**
159 | * @}
160 | */
161 |
162 | /**
163 | * @}
164 | */
165 |
166 | /**
167 | * @}
168 | */
169 |
170 | #ifdef __cplusplus
171 | }
172 | #endif
173 |
174 | #endif /* __USBD_CONF__H__ */
175 |
176 |
--------------------------------------------------------------------------------
/projectbldc.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KoSik-prog/STM32F103_BLDC_Driver/3d108960543fd65714011477147a4a047ca86acc/projectbldc.png
--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 |
4 | Schematic: https://a360.co/3iP8vQz
5 |
6 | 3D view: https://a360.co/3f0I6O4
7 |
8 | YouTube: https://youtu.be/0DW3Gm4tZaE
9 |
10 |
11 | Problems or ideas, write me: kosik84@gmail.com
12 |
--------------------------------------------------------------------------------