DashyFox/PingPong
1
0
Fork 0
mirror of https://github.com/DashyFox/StackSport.git synced 2025-05-04 07:10:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

window clip variant

Browse Source
This commit is contained in:
DashyFox 2024-09-17 23:01:04 +03:00
parent 2ef50d8b07
commit 953593d32a
9 changed files with 842 additions and 646 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
Core/Inc/EEPROM.h
View File

@ -3,10 +3,13 @@
#ifndef INC_EEPROM_H_
#define INC_EEPROM_H_
#include <assert.h>
#define AT24C_ADRESS 0x50 // i2c slave adress EEPROM
#define START_ADR_STAT 0x0000 //00000
#define STAT_BLOCKSIZE sizeof(InfoBlock)
#define STAT_BLOCKSIZE 128
#define START_ADR_SHOT (START_ADR_STAT+STAT_BLOCKSIZE)
#define SHOT_BLOCKSIZE 10
@ -34,7 +37,7 @@ typedef enum MemoryStatus {
EEPROM_OK
} MemoryStatus;
typedef struct Shot {
typedef struct __attribute__((packed)) {
unsigned char isExist;
unsigned char countRepeatShot; // 0 = inf
unsigned char speedRollerTop; // 0 .. 100 .. 200
@ -45,83 +48,87 @@ typedef struct Shot {
unsigned char rotationVertical; // 0 .. 90 .. 180
} Shot;
typedef struct ProgramHeader {
typedef struct __attribute__((packed)) {
unsigned char isExist;
unsigned char countRepeat;
unsigned char options;
} ProgramHeader;
typedef struct ProgramShot {
typedef struct __attribute__((packed)) {
unsigned char id;
unsigned char speedScrew;
} ProgramShot;
typedef struct Program {
typedef struct __attribute__((packed)) {
ProgramHeader header;
ProgramShot shots[MAX_SHOT_COUNT_IN_PROGRAMS];
} Program;
typedef struct MacroHeader {
typedef struct __attribute__((packed)) {
unsigned char isExist;
} MacroHeader;
typedef struct MacroProgram {
typedef struct __attribute__((packed)) {
unsigned char id;
unsigned char speedScrew;
unsigned char countRepeat;
unsigned char options;
} MacroProgram;
typedef struct Macro {
typedef struct __attribute__((packed)) {
MacroHeader header;
MacroProgram programs[MAX_PROGRAM_COUNT_IN_MACRO];
} Macro;
typedef struct ServoSetting {
typedef struct __attribute__((packed)) {
uint8_t invert;
uint16_t min;
uint16_t def;
uint16_t max;
} ServoSetting;
typedef struct DelayTimes{
typedef struct __attribute__((packed)) {
uint16_t preRun;
}DelayTimes;
} DelayTimes;
typedef struct Motors{
typedef struct __attribute__((packed)) {
uint16_t speed_Rollers_min;
// uint16_t speed_Rollers_max;
uint16_t speed_Screw_min;
// uint16_t speed_Screw_max;
}Motors;
} Motors;
typedef struct HardwareInit_t{
typedef struct __attribute__((packed)) {
DelayTimes timings;
ServoSetting servos[3];
Motors motors;
}HardwareInit_t;
} HardwareInit_t;
typedef struct Statistics{
typedef struct __attribute__((packed)) {
uint32_t totalShots;
uint32_t totalPrograms;
uint32_t totalMacros;
}Statistics;
} Statistics;
typedef struct InfoBlock{
typedef struct __attribute__((packed)) {
char init_uid[11];
HardwareInit_t hwInfo;
Statistics statInfo;
}InfoBlock;
} InfoBlock;
_Static_assert(sizeof(InfoBlock) <= STAT_BLOCKSIZE, "Error: InfoBlock size exceeds 128 bytes.");
extern InfoBlock infoBlock;
// read from EEPROM infoBlock
// or write to EEPROM default infoBlock
MemoryStatus EEPROM_INIT();
MemoryStatus EEPROM_EARSE();
MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number, uint8_t *writeData, uint16_t dataSize);
MemoryStatus FLASH_ReadBlock(uint16_t startAddr, uint8_t number, uint8_t *readData, uint16_t dataSize);
MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number,
uint8_t *writeData, uint16_t dataSize);
MemoryStatus FLASH_ReadBlock(uint16_t startAddr, uint8_t number,
uint8_t *readData, uint16_t dataSize);
MemoryStatus saveShot(unsigned char number, Shot *shot);
MemoryStatus getShot(unsigned char number, Shot *shot);
@ -132,7 +139,7 @@ MemoryStatus getProg(unsigned char number, Program *prog);
MemoryStatus saveMacro(unsigned char number, Macro *macro);
MemoryStatus getMacro(unsigned char number, Macro *macro);
MemoryStatus saveInfoBlock(InfoBlock *infoBlock);
MemoryStatus getInfoBlock(InfoBlock *infoBlock);
MemoryStatus saveInfoBlock();
MemoryStatus getInfoBlock();
#endif /* INC_EEPROM_H_ */

5
Core/Inc/RobotFunctions.h
View File

@ -51,6 +51,7 @@ typedef struct CurrentInfo {
CurrentMacro macro;
} CurrentInfo;
void Robot_INIT();
void doShot(Shot*);
void doShotForever(uint8_t number);
@ -60,11 +61,13 @@ uint8_t prepareShot(uint8_t number);
void startShooting();
void stopShooting();
int16_t map(int16_t x, int16_t in_min, int16_t in_max, int16_t out_min,
int16_t out_max);
void setPos(uint8_t axial, uint8_t horizontal, uint8_t vertical);
void setPosSingle(ServoMap servo, uint8_t value);
void setPosDefault();
void setPosDefaultSingle(ServoMap servo);
// 0 .. 100
void setScrewkSpeed(uint8_t speed);

2
Core/Inc/UART3_CMD_Handler.h
View File

@ -26,6 +26,8 @@ void UART3_SetServoOffset(uint8_t *dataPtr, uint8_t len);
void UART3_GetServoOffset(uint8_t *dataPtr, uint8_t len);
void UART3_SetServoMaxAngle(uint8_t *dataPtr, uint8_t len);
void UART3_GetServoMaxAngle(uint8_t *dataPtr, uint8_t len);
void UART3_SetServoMinAngle(uint8_t *dataPtr, uint8_t len);
void UART3_GetServoMinAngle(uint8_t *dataPtr, uint8_t len);
void UART3_MoveServoToInitialPosition(uint8_t *dataPtr, uint8_t len);
void UART3_SetStartupDelay(uint8_t *dataPtr, uint8_t len);
void UART3_GetStartupDelay(uint8_t *dataPtr, uint8_t len);

237
Core/Src/EEPROM.c
View File

@ -6,123 +6,7 @@
InfoBlock infoBlock;
MemoryStatus saveInfoBlock(InfoBlock *infoBlock) {
return FLASH_WriteBlock(START_ADR_STAT, 0, (uint8_t*) infoBlock,
sizeof(InfoBlock));
}
MemoryStatus getInfoBlock(InfoBlock *infoBlock) {
MemoryStatus status = FLASH_ReadBlock(START_ADR_STAT, 0,
(uint8_t*) infoBlock, sizeof(InfoBlock));
if (status != EEPROM_OK) {
return EEPROM_FAIL;
}
return EEPROM_OK;
}
MemoryStatus saveShot(unsigned char number, Shot *shot) {
if (FLASH_WriteBlock(START_ADR_SHOT, number, (uint8_t*) shot,
SHOT_BLOCKSIZE) == EEPROM_OK) {
return EEPROM_OK;
}
return EEPROM_FAIL;
}
MemoryStatus getShot(unsigned char number, Shot *shot) {
if (FLASH_ReadBlock(START_ADR_SHOT, number, (uint8_t*) shot, SHOT_BLOCKSIZE)
!= EEPROM_OK) {
return EEPROM_FAIL;
}
if (!shot->isExist) {
return EEPROM_MISSING_ELEMENT;
}
return EEPROM_OK;
}
MemoryStatus saveProg(unsigned char number, Program *prog) {
MemoryStatus result = EEPROM_OK;
for (uint16_t i = 0; i < MAX_SHOT_COUNT_IN_PROGRAMS; ++i) {
Shot shot;
MemoryStatus stat = getShot(prog->shots[i].id, &shot);
if (!(stat == EEPROM_OK || stat == EEPROM_MISSING_ELEMENT)) {
return EEPROM_FAIL;
}
if (!shot.isExist) {
// todo: добавить в запросы для загрузки снимков
result = EEPROM_MISSING_ELEMENT;
}
}
if (FLASH_WriteBlock(START_ADR_PROGRAM, number, (uint8_t*) prog,
PROGRAM_BLOCKSIZE) != EEPROM_OK) {
return EEPROM_FAIL;
}
return result;
}
MemoryStatus getProg(unsigned char number, Program *prog) {
if (FLASH_ReadBlock(START_ADR_PROGRAM, number, (uint8_t*) prog,
PROGRAM_BLOCKSIZE) != EEPROM_OK) {
return EEPROM_FAIL;
}
if (!prog->header.isExist) {
return EEPROM_MISSING_ELEMENT;
}
return EEPROM_OK;
}
MemoryStatus saveMacro(unsigned char number, Macro *macro) {
MemoryStatus result = EEPROM_OK;
for (uint16_t i = 0; i < MAX_PROGRAM_COUNT_IN_MACRO; ++i) {
Program prog;
MemoryStatus stat = getProg(macro->programs[i].id, &prog);
if (!(stat == EEPROM_OK || stat == EEPROM_MISSING_ELEMENT)) {
return EEPROM_FAIL;
}
if (!prog.header.isExist) {
result = EEPROM_MISSING_ELEMENT;
// todo: добавить в запросы для загрузки программ
}
}
if (FLASH_WriteBlock(START_ADR_MACRO, number, (uint8_t*) macro,
MACRO_BLOCKSIZE) != EEPROM_OK) {
return EEPROM_FAIL;
}
return result;
}
MemoryStatus getMacro(unsigned char number, Macro *macro) {
if (FLASH_ReadBlock(START_ADR_MACRO, number, (uint8_t*) macro,
MACRO_BLOCKSIZE) != EEPROM_OK) {
return EEPROM_FAIL;
}
if (!macro->header.isExist) {
return EEPROM_MISSING_ELEMENT;
}
return EEPROM_OK;
}
MemoryStatus EEPROM_EARSE() {
uint16_t addr = 0;
uint16_t old_addr = 0;
do {
uint8_t Buf[255];
memset(Buf, 0xFF, sizeof(Buf));
FLASH_WriteBlock(addr, 0, Buf, (uint8_t) sizeof(Buf));
old_addr = addr;
addr += sizeof(Buf);
} while (old_addr <= addr);
return EEPROM_OK;
}
//*********************** EEPROM_INIT ********************************//
MemoryStatus EEPROM_INIT() {
memset(&infoBlock, 0x00, sizeof(infoBlock));
MemoryStatus status = getInfoBlock(&infoBlock);
@ -241,6 +125,125 @@ MemoryStatus EEPROM_INIT() {
return status;
}
//************************************************************//
MemoryStatus saveInfoBlock() {
return FLASH_WriteBlock(START_ADR_STAT, 0, (uint8_t*) &infoBlock,
sizeof(InfoBlock));
}
MemoryStatus getInfoBlock() {
MemoryStatus status = FLASH_ReadBlock(START_ADR_STAT, 0,
(uint8_t*) &infoBlock, sizeof(InfoBlock));
if (status != EEPROM_OK) {
return EEPROM_FAIL;
}
return EEPROM_OK;
}
MemoryStatus saveShot(unsigned char number, Shot *shot) {
if (FLASH_WriteBlock(START_ADR_SHOT, number, (uint8_t*) shot,
SHOT_BLOCKSIZE) == EEPROM_OK) {
return EEPROM_OK;
}
return EEPROM_FAIL;
}
MemoryStatus getShot(unsigned char number, Shot *shot) {
if (FLASH_ReadBlock(START_ADR_SHOT, number, (uint8_t*) shot, SHOT_BLOCKSIZE)
!= EEPROM_OK) {
return EEPROM_FAIL;
}
if (!shot->isExist) {
return EEPROM_MISSING_ELEMENT;
}
return EEPROM_OK;
}
MemoryStatus saveProg(unsigned char number, Program *prog) {
MemoryStatus result = EEPROM_OK;
for (uint16_t i = 0; i < MAX_SHOT_COUNT_IN_PROGRAMS; ++i) {
Shot shot;
MemoryStatus stat = getShot(prog->shots[i].id, &shot);
if (!(stat == EEPROM_OK || stat == EEPROM_MISSING_ELEMENT)) {
return EEPROM_FAIL;
}
if (!shot.isExist) {
// todo: добавить в запросы для загрузки снимков
result = EEPROM_MISSING_ELEMENT;
}
}
if (FLASH_WriteBlock(START_ADR_PROGRAM, number, (uint8_t*) prog,
PROGRAM_BLOCKSIZE) != EEPROM_OK) {
return EEPROM_FAIL;
}
return result;
}
MemoryStatus getProg(unsigned char number, Program *prog) {
if (FLASH_ReadBlock(START_ADR_PROGRAM, number, (uint8_t*) prog,
PROGRAM_BLOCKSIZE) != EEPROM_OK) {
return EEPROM_FAIL;
}
if (!prog->header.isExist) {
return EEPROM_MISSING_ELEMENT;
}
return EEPROM_OK;
}
MemoryStatus saveMacro(unsigned char number, Macro *macro) {
MemoryStatus result = EEPROM_OK;
for (uint16_t i = 0; i < MAX_PROGRAM_COUNT_IN_MACRO; ++i) {
Program prog;
MemoryStatus stat = getProg(macro->programs[i].id, &prog);
if (!(stat == EEPROM_OK || stat == EEPROM_MISSING_ELEMENT)) {
return EEPROM_FAIL;
}
if (!prog.header.isExist) {
result = EEPROM_MISSING_ELEMENT;
// todo: добавить в запросы для загрузки программ
}
}
if (FLASH_WriteBlock(START_ADR_MACRO, number, (uint8_t*) macro,
MACRO_BLOCKSIZE) != EEPROM_OK) {
return EEPROM_FAIL;
}
return result;
}
MemoryStatus getMacro(unsigned char number, Macro *macro) {
if (FLASH_ReadBlock(START_ADR_MACRO, number, (uint8_t*) macro,
MACRO_BLOCKSIZE) != EEPROM_OK) {
return EEPROM_FAIL;
}
if (!macro->header.isExist) {
return EEPROM_MISSING_ELEMENT;
}
return EEPROM_OK;
}
MemoryStatus EEPROM_EARSE() {
uint16_t addr = 0;
uint16_t old_addr = 0;
do {
uint8_t Buf[255];
memset(Buf, 0xFF, sizeof(Buf));
FLASH_WriteBlock(addr, 0, Buf, (uint8_t) sizeof(Buf));
old_addr = addr;
addr += sizeof(Buf);
} while (old_addr <= addr);
return EEPROM_OK;
}
MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number,
uint8_t *writeData, uint16_t dataSize) {

140
Core/Src/RobotFunctions.c
View File

@ -6,7 +6,10 @@
*/
#include "RobotFunctions.h"
#include "pca9685.h"
#include "UART3_Handler.h"
#include "EEPROM.h"
#include "ShiftReg.h"
#include "Print.h"
uint8_t isPause = 0;
@ -14,19 +17,84 @@ uint8_t isShooting = 0;
CurrentInfo currentInfo;
HardwareInit_t hwSettings = {
/*DelayTimes*/{
/*preRun*/0 },
/*ServoSetting*/{ { 0, 0, 90, 180 }, { 0, 0, 90, 180 }, { 0, 0, 90, 180 } },
/*Motors*/{ 0, 0 } };
extern int16_t Vz1;
extern int16_t Vz2;
unsigned char Shiftreg[3];
int16_t map(int16_t x, int16_t in_min, int16_t in_max, int16_t out_min,
int16_t out_max) {
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
void Robot_INIT() {
memset(&currentInfo, 0x00, sizeof(currentInfo));
// NULL
currentInfo.shot.index = 0xFF;
currentInfo.program.index = 0xFF;
currentInfo.macro.index = 0xFF;
initPCA9685();
EEPROM_INIT();
UART3_START();
setPosDefault();
Shiftreg[0] = 0x00;
Shiftreg[1] = 0x44;
Shiftreg[2] = 0x00;
SetShiftReg(Shiftreg);
HAL_Delay(10);
Shiftreg[0] = 0x00;
Shiftreg[1] = 0x66;
Shiftreg[2] = 0x00;
SetShiftReg(Shiftreg);
HAL_Delay(10);
Shiftreg[0] = 0x00;
Shiftreg[1] = 0x77;
Shiftreg[2] = 0x00;
SetShiftReg(Shiftreg);
HAL_Delay(10);
Shiftreg[0] = 0x01;
Shiftreg[1] = 0x77;
Shiftreg[2] = 0x01;
SetShiftReg(Shiftreg);
HAL_Delay(10);
Shiftreg[0] = 0x03;
Shiftreg[1] = 0x77;
Shiftreg[2] = 0x03;
SetShiftReg(Shiftreg);
HAL_Delay(10);
Shiftreg[0] = 0x07;
Shiftreg[1] = 0x77;
Shiftreg[2] = 0x07;
SetShiftReg(Shiftreg);
HAL_Delay(10);
Shiftreg[0] = 0x0F;
Shiftreg[1] = 0x77;
Shiftreg[2] = 0x0F;
SetShiftReg(Shiftreg);
HAL_Delay(10);
Shiftreg[0] = 0x1F;
Shiftreg[1] = 0x77;
Shiftreg[2] = 0x1F;
SetShiftReg(Shiftreg);
HAL_Delay(10);
Shiftreg[0] = 0x3F;
Shiftreg[1] = 0x77;
Shiftreg[2] = 0x3F;
SetShiftReg(Shiftreg);
HAL_Delay(10);
Shiftreg[0] = 0x7F;
Shiftreg[1] = 0x77;
Shiftreg[2] = 0x7F;
SetShiftReg(Shiftreg);
HAL_Delay(10);
Shiftreg[0] = 0x00;
Shiftreg[1] = 0x00;
Shiftreg[2] = 0x00;
SetShiftReg(Shiftreg);
HAL_Delay(10);
//testing
}
void doShot(Shot *shot) {
SetServo(0, shot->rotationHorizontal);
@ -106,21 +174,45 @@ uint8_t prepareShot(uint8_t number) {
}
void setPosSingle(ServoMap servo, uint8_t value) {
if (hwSettings.servos[servo].invert)
value = 180 - value;
SetServo(servo, value);
ServoSetting* currentServo = &infoBlock.hwInfo.servos[servo];
uint8_t inv = currentServo->invert;
if (servo == SERVO_AXIAL)
inv = !inv;
uint8_t deviationToMax = currentServo->max > currentServo->def
? currentServo->max - currentServo->def
: currentServo->def - currentServo->max;
uint8_t deviationToMin = currentServo->def > currentServo->min
? currentServo->def - currentServo->min
: currentServo->min - currentServo->def;
uint8_t maxDeviation = (deviationToMax > deviationToMin) ? deviationToMax : deviationToMin;
uint8_t minLimit = (currentServo->def >= maxDeviation) ? currentServo->def - maxDeviation : 0;
uint8_t maxLimit = (currentServo->def + maxDeviation <= 180) ? currentServo->def + maxDeviation : 180;
if (value > maxLimit) {
value = maxLimit;
} else if (value < minLimit) {
value = minLimit;
}
if (inv)
value = 180 - value;
SetServo(servo, value);
}
void setPos(uint8_t axial, uint8_t horizontal, uint8_t vertical) {
setPosSingle(SERVO_AXIAL, axial);
setPosSingle(SERVO_HORIZONTAL, horizontal);
setPosSingle(SERVO_VERTICAL, vertical);
}
void setPosDefault() {
setPos(
hwSettings.servos[SERVO_AXIAL].def,
hwSettings.servos[SERVO_HORIZONTAL].def,
hwSettings.servos[SERVO_VERTICAL].def
);
setPos(infoBlock.hwInfo.servos[SERVO_AXIAL].def,
infoBlock.hwInfo.servos[SERVO_HORIZONTAL].def,
infoBlock.hwInfo.servos[SERVO_VERTICAL].def);
}
void setPosDefaultSingle(ServoMap servo) {
setPosSingle(servo, infoBlock.hwInfo.servos[servo].def);
}
// 0 .. 100
@ -130,7 +222,9 @@ void setScrewkSpeed(uint8_t speed) {
if (speed > 100)
speed = 100;
speed = map(speed, 0, 100, hwSettings.motors.speed_Screw_min, 100);
// speed = map(speed, 0, 100, infoBlock.hwInfo.motors.speed_Screw_min, 100);
if (speed && speed < infoBlock.hwInfo.motors.speed_Screw_min)
speed = infoBlock.hwInfo.motors.speed_Screw_min;
TIM1->CCR1 = 0;
TIM1->CCR2 = (uint16_t) (40 * speed);
@ -140,15 +234,23 @@ void setScrewkSpeed(uint8_t speed) {
void setRollersSpeed(uint8_t up, uint8_t down) {
if (up < 100) {
up = map(up, 0, 100, 0, 100 - hwSettings.motors.speed_Screw_min);
// up = map(up, 0, 100, 0, 100 - infoBlock.hwInfo.motors.speed_Screw_min);
// if (100 - up < min_speed) {
// up = 100 - min_speed;
// }
} else {
up = map(up, 0, 100, 0, 100 + hwSettings.motors.speed_Screw_min);
// up = map(up, 0, 100, 0, 100 + infoBlock.hwInfo.motors.speed_Screw_min);
// if (up - 100 < min_speed) { // Ограничиваем положительную скорость минимальной
// up = 100 + min_speed;
// }
}
if (down < 100) {
map(down, 0, 100, 0, 100 - hwSettings.motors.speed_Screw_min);
// map(down, 0, 100, 0, 100 - infoBlock.hwInfo.motors.speed_Screw_min);
} else {
map(down, 0, 100, 0, 100 + hwSettings.motors.speed_Screw_min);
// map(down, 0, 100, 0, 100 + infoBlock.hwInfo.motors.speed_Screw_min);
}
Vz1 = 200 - up; // invert

204
Core/Src/UART3_CMD_Handler.c
View File

@ -13,7 +13,6 @@
#define HIGHBIT(b) (((b)>>8)&0xff)
#define LOWBIT(b) ((b)&0xff)
extern CurrentInfo currentInfo;
extern InfoBlock infoBlock;
@ -33,10 +32,20 @@ uint8_t checkLen(uint8_t cmd, uint8_t current_length, uint8_t required_length) {
}
void UART3_SaveShot(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
const uint8_t MIN_PARAM_LENGTH = 8;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
uint8_t shotIndx = dataPtr[1];
Shot shot;
shot.countRepeatShot = dataPtr[2];
shot.speedRollerTop = dataPtr[3]+100;
shot.speedRollerBottom = dataPtr[4]+100;
shot.speedScrew = map(dataPtr[6], 0, 120, 0, 100);
shot.rotationAxial = map(dataPtr[5], -99, 99, 0, 180);
shot.rotationHorizontal = map(dataPtr[6], -99, 99, 90-45, 90+45);
SendResponse(dataPtr[0], 0, NULL, 0);
}
@ -112,78 +121,160 @@ void UART3_DeleteMacro(uint8_t *dataPtr, uint8_t len) {
SendResponse(dataPtr[0], 0, NULL, 0);
}
//120
void UART3_DeleteAllData(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
EEPROM_EARSE();
SendResponse(dataPtr[0], 0, NULL, 0);
}
//180
void UART3_GetDeviceStatus(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
SendResponse(dataPtr[0], 0, NULL, 0);
uint8_t res = currentInfo.state.isShooting;
SendResponse(dataPtr[0], 0, &res, sizeof(res));
}
//200
void UART3_SetServoOffset(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
const uint8_t MIN_PARAM_LENGTH = 3;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
SendResponse(dataPtr[0], 0, NULL, 0);
ServoMap servo = dataPtr[1];
ServoSetting *currentServo = &infoBlock.hwInfo.servos[servo];
int16_t newDef = (dataPtr[2] << 8) | dataPtr[3];
newDef+=90; // from center
if (newDef < 0) newDef = 0;
if (newDef > 180) newDef = 180;
int16_t maxDeviation = (currentServo->max > currentServo->def)
? currentServo->max - currentServo->def
: currentServo->def - currentServo->min;
currentServo->def = newDef;
int16_t newMax = currentServo->def + maxDeviation;
int16_t newMin = currentServo->def - maxDeviation;
if (newMax > 180) newMax = 180;
if (newMin < 0) newMin = 0;
currentServo->max = newMax;
currentServo->min = newMin;
saveInfoBlock();
SendResponse(dataPtr[0], 0, NULL, 0);
}
//204
void UART3_GetServoOffset(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
const uint8_t MIN_PARAM_LENGTH = 1;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
SendResponse(dataPtr[0], 0, NULL, 0);
ServoMap servo = dataPtr[1];
ServoSetting *currentServo = &infoBlock.hwInfo.servos[servo];
int16_t def = currentServo->def - 90; // offset from center
uint8_t res[2];
res[0] = HIGHBIT(def);
res[1] = LOWBIT(def);
SendResponse(dataPtr[0], 0, res, sizeof(res));
}
//201
void UART3_SetServoMaxAngle(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
const uint8_t MIN_PARAM_LENGTH = 3;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
SendResponse(dataPtr[0], 0, NULL, 0);
ServoMap servo = dataPtr[1];
uint16_t maxAngl = (dataPtr[2] << 8) | dataPtr[3];
ServoSetting *currentServo = &infoBlock.hwInfo.servos[servo];
int16_t newMax = currentServo->def + maxAngl;
int16_t newMin = currentServo->def - maxAngl;
if (newMax > 180) newMax = 180;
if (newMin < 0) newMin = 0;
currentServo->max = newMax;
currentServo->min = newMin;
saveInfoBlock();
SendResponse(dataPtr[0], 0, NULL, 0);
}
//202
void UART3_GetServoMaxAngle(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
const uint8_t MIN_PARAM_LENGTH = 1;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
SendResponse(dataPtr[0], 0, NULL, 0);
ServoMap servo = dataPtr[1];
ServoSetting *currentServo = &infoBlock.hwInfo.servos[servo];
uint8_t deviationToMax = currentServo->max > currentServo->def
? currentServo->max - currentServo->def
: currentServo->def - currentServo->max;
uint8_t deviationToMin = currentServo->def > currentServo->min
? currentServo->def - currentServo->min
: currentServo->min - currentServo->def;
uint8_t maxAngl = (deviationToMax > deviationToMin) ? deviationToMax : deviationToMin;
uint8_t res[2];
res[0] = HIGHBIT(maxAngl);
res[1] = LOWBIT(maxAngl);
SendResponse(dataPtr[0], 0, res, sizeof(res));
}
//203
void UART3_MoveServoToInitialPosition(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
const uint8_t MIN_PARAM_LENGTH = 1;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
setPosDefaultSingle(dataPtr[1]);
SendResponse(dataPtr[0], 0, NULL, 0);
}
//206
void UART3_SetStartupDelay(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
const uint8_t MIN_PARAM_LENGTH = 2;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
infoBlock.hwInfo.timings.preRun = (dataPtr[1] << 8) | dataPtr[2];
saveInfoBlock();
SendResponse(dataPtr[0], 0, NULL, 0);
}
//207
void UART3_GetStartupDelay(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
SendResponse(dataPtr[0], 0, NULL, 0);
uint8_t res[2];
res[0] = HIGHBIT(infoBlock.hwInfo.timings.preRun);
res[1] = LOWBIT(infoBlock.hwInfo.timings.preRun);
SendResponse(dataPtr[0], 0, res, sizeof(res));
}
//210 !!!!!!!!
void UART3_SetMinRollerSpeed(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
@ -192,67 +283,96 @@ void UART3_SetMinRollerSpeed(uint8_t *dataPtr, uint8_t len) {
SendResponse(dataPtr[0], 0, NULL, 0);
}
//211 !!!!!!!!!!!
void UART3_GetMinRollerSpeed(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
SendResponse(dataPtr[0], 0, NULL, 0);
uint8_t res[1];
// res[0] = ;
SendResponse(dataPtr[0], 0, res, sizeof(res));
}
//212
void UART3_SetMinScrewSpeed(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
const uint8_t MIN_PARAM_LENGTH = 1;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
infoBlock.hwInfo.motors.speed_Screw_min = dataPtr[1];
saveInfoBlock();
SendResponse(dataPtr[0], 0, NULL, 0);
}
//215
void UART3_GetMinScrewSpeed(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
SendResponse(dataPtr[0], 0, NULL, 0);
uint8_t res[1];
res[0] = infoBlock.hwInfo.motors.speed_Screw_min;
SendResponse(dataPtr[0], 0, res, sizeof(res));
}
//214
void UART3_SetServoInvertFlag(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
const uint8_t MIN_PARAM_LENGTH = 1;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
uint8_t inv = dataPtr[1];
infoBlock.hwInfo.servos[SERVO_AXIAL].invert = inv;
infoBlock.hwInfo.servos[SERVO_HORIZONTAL].invert = inv;
infoBlock.hwInfo.servos[SERVO_VERTICAL].invert = inv;
saveInfoBlock();
SendResponse(dataPtr[0], 0, NULL, 0);
}
//215
void UART3_GetServoInvertFlag(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
SendResponse(dataPtr[0], 0, NULL, 0);
uint8_t res[1];
res[0] = (infoBlock.hwInfo.servos[SERVO_AXIAL].invert
|| infoBlock.hwInfo.servos[SERVO_HORIZONTAL].invert
|| infoBlock.hwInfo.servos[SERVO_VERTICAL].invert);
SendResponse(dataPtr[0], 0, res, sizeof(res));
}
// 181
void UART3_ReadStatistics(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
typedef struct __attribute__((packed)){
uint8_t status;
uint8_t macro_number;
uint8_t program_number;
uint8_t shot_number;
uint8_t total_macro_done_HIGH;
uint8_t total_macro_done_LOW;
uint8_t total_program_done_HIGH;
uint8_t total_program_done_LOW;
uint8_t total_shot_done_HIGH;
uint8_t total_shot_done_LOW;
typedef struct __attribute__((packed)) {
uint8_t status;
uint8_t macro_number;
uint8_t program_number;
uint8_t shot_number;
uint8_t total_macro_done_HIGH;
uint8_t total_macro_done_LOW;
uint8_t total_program_done_HIGH;
uint8_t total_program_done_LOW;
uint8_t total_shot_done_HIGH;
uint8_t total_shot_done_LOW;
} StatusStruct;
StatusStruct res;
res.status = currentInfo.state.isShooting && !currentInfo.state.isPause;
res.status = currentInfo.state.isShooting;
res.shot_number = currentInfo.shot.index;
res.program_number = currentInfo.program.index;
res.macro_number = currentInfo.macro.index;
@ -266,14 +386,18 @@ void UART3_ReadStatistics(uint8_t *dataPtr, uint8_t len) {
res.total_macro_done_HIGH = HIGHBIT(infoBlock.statInfo.totalMacros);
res.total_macro_done_LOW = LOWBIT(infoBlock.statInfo.totalMacros);
SendResponse(dataPtr[0], 0, (uint8_t*)&res, sizeof(res));
SendResponse(dataPtr[0], 0, (uint8_t*) &res, sizeof(res));
}
// 121
void UART3_ResetStatistics(uint8_t *dataPtr, uint8_t len) {
const uint8_t MIN_PARAM_LENGTH = 0;
if (!checkLen(dataPtr[0], len, MIN_PARAM_LENGTH))
return;
memset(&infoBlock.statInfo, 0x00, sizeof(infoBlock.statInfo));
saveInfoBlock();
SendResponse(dataPtr[0], 0, NULL, 0);
}

3
Core/Src/UART3_Handler.c
View File

@ -51,7 +51,7 @@ void handle_rx_complete(uint8_t *data, uint16_t len)
// CDC_Transmit_FS((uint8_t*) byte_info, strlen(byte_info));
// }
// Проверка правильности пакета (первый байт должен быть 0xF0)
// Проверка 0xF0
if (data[0] != 0xF0) {
char error_msg[64];
snprintf(error_msg, sizeof(error_msg),
@ -89,7 +89,6 @@ void handle_rx_complete(uint8_t *data, uint16_t len)
// CDC_Transmit_FS((uint8_t*)"\n\n", 2);
// Если пакет корректен, передать управление обработчику команд
uint8_t *data_ptr = &data[2];
UART3_CMD_Handler(data_ptr, length);
}

830
Core/Src/main.c
View File

@ -68,8 +68,6 @@ uint8_t velosety[600];
uint8_t rxcomlite = 0;
uint8_t initcomlete = 0;
unsigned char Shiftreg[3];
uint8_t rejim[60]; // 0 - chislo rejimov, 1-6 - rejim1, 7-12 - rejim2...
uint8_t avto = 0; // vkl/otkl avtomaticheskoi raboti
uint8_t rejim_number = 1; // nomer tekyshego rejima
@ -105,536 +103,486 @@ static void MX_USART3_UART_Init(void);
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
* @brief The application entry point.
* @retval int
*/
int main(void) {
/* USER CODE BEGIN 1 */
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
HAL_Delay(10);
/* USER CODE END Init */
/* USER CODE BEGIN Init */
HAL_Delay(10);
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
// Установка приоритета прерывания
// NVIC_SetPriority(SysTick_IRQn, 0);
// Настройка SysTick таймера на 1 мс
SysTick->LOAD = 479999; // 1ms Sys timer
// SysTick_Config(SystemCoreClock / 1000);
/* USER CODE BEGIN SysInit */
__HAL_RCC_USB_FORCE_RESET();
HAL_Delay(10);
__HAL_RCC_USB_RELEASE_RESET();
HAL_Delay(10);
/* USER CODE END SysInit */
SysTick->LOAD = 479999;
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_I2C1_Init();
MX_USB_DEVICE_Init();
MX_TIM1_Init();
MX_TIM2_Init();
MX_TIM3_Init();
MX_USART3_UART_Init();
/* USER CODE BEGIN 2 */
HAL_Delay(10);
__HAL_RCC_USART3_CLK_ENABLE();
HAL_Delay(10);
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_Delay(10);
__HAL_RCC_USB_FORCE_RESET();
HAL_Delay(10);
__HAL_RCC_USB_RELEASE_RESET();
HAL_Delay(10);
/* USER CODE END SysInit */
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1); //PA8
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_DMA_Init();
MX_I2C1_Init();
MX_USB_DEVICE_Init();
MX_TIM1_Init();
MX_TIM2_Init();
MX_TIM3_Init();
MX_USART3_UART_Init();
/* USER CODE BEGIN 2 */
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1); //PA8
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_2); //PA9
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1); //PA0
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_2); //PA1
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_3); //PA2
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4); //PA3
initPCA9685();
Robot_INIT();
Shiftreg[0] = 0x00; Shiftreg[1] = 0x44; Shiftreg[2] = 0x00; SetShiftReg(Shiftreg); HAL_Delay(10);
Shiftreg[0] = 0x00; Shiftreg[1] = 0x66; Shiftreg[2] = 0x00; SetShiftReg(Shiftreg); HAL_Delay(10);
Shiftreg[0] = 0x00; Shiftreg[1] = 0x77; Shiftreg[2] = 0x00; SetShiftReg(Shiftreg); HAL_Delay(10);
EEPROM_INIT();
Shiftreg[0] = 0x01; Shiftreg[1] = 0x77; Shiftreg[2] = 0x01; SetShiftReg(Shiftreg); HAL_Delay(10);
Shiftreg[0] = 0x03; Shiftreg[1] = 0x77; Shiftreg[2] = 0x03; SetShiftReg(Shiftreg); HAL_Delay(10);
Shiftreg[0] = 0x07; Shiftreg[1] = 0x77; Shiftreg[2] = 0x07; SetShiftReg(Shiftreg); HAL_Delay(10);
Shiftreg[0] = 0x0F; Shiftreg[1] = 0x77; Shiftreg[2] = 0x0F; SetShiftReg(Shiftreg); HAL_Delay(10);
Shiftreg[0] = 0x1F; Shiftreg[1] = 0x77; Shiftreg[2] = 0x1F; SetShiftReg(Shiftreg); HAL_Delay(10);
Shiftreg[0] = 0x3F; Shiftreg[1] = 0x77; Shiftreg[2] = 0x3F; SetShiftReg(Shiftreg); HAL_Delay(10);
Shiftreg[0] = 0x7F; Shiftreg[1] = 0x77; Shiftreg[2] = 0x7F; SetShiftReg(Shiftreg); HAL_Delay(10);
Shiftreg[0] = 0x00; Shiftreg[1] = 0x00; Shiftreg[2] = 0x00; SetShiftReg(Shiftreg); HAL_Delay(10);
initcomlete = 1;
initcomlete = 1;
HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_1); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 1 <20>6 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> PA0 PA1
HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_2);
HAL_TIM_Base_Start_IT(&htim3);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_1); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 1 <20>6 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> PA0 PA1
HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_2);
/* USER CODE END 2 */
HAL_TIM_Base_Start_IT(&htim3);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
UART3_START();
/* Infinite loop */
/* USER CODE BEGIN WHILE */
/* USER CODE END 2 */
while (1) {
/* Infinite loop */
/* USER CODE BEGIN WHILE */
IR_CMD_Handler();
UART3_Handler();
forTimer(blinkTimer, 500)
{
resetForTimer(blinkTimer);
GPIOC->ODR ^= GPIO_PIN_13;
// unsigned char text[] = "Hello\n";
// printNumber(SysTick->LOAD);
// CDC_Transmit_FS(text, sizeof(text));
// char buffer[100]; // Буфер для формата строки
Shot testShot;
memset(&testShot, 0x00, sizeof(Shot));
getShot(3, &testShot);
// extern uint32_t vsk1;
// extern uint32_t vsk2;
// extern uint16_t timing1;
// extern uint16_t timing2;
// // Форматируем строку для вывода timing1, timing2, vsk1, vsk2
// sprintf(buffer,
// "timing1: %u ms, timing2: %u ms, vsk1: %u RPM, vsk2: %u RPM\n",
// timing1, timing2, vsk1, vsk2);
//
// // Отправляем строку через CDC (USB)
// CDC_Transmit_FS((uint8_t*) buffer, strlen(buffer));
}
if(!testShot.isExist){
testShot.countRepeatShot = 1;
testShot.speedRollerTop = 200;
testShot.speedRollerBottom = 200;
testShot.speedScrew = 100;
testShot.rotationAxial = 90;
testShot.rotationHorizontal = 90;
testShot.rotationVertical = 90;
/* USER CODE END WHILE */
saveShot(3, &testShot);
}
while (1)
{
IR_CMD_Handler();
UART3_Handler();
forTimer(blinkTimer, 500)
{
resetForTimer(blinkTimer);
GPIOC->ODR ^= GPIO_PIN_13;
// unsigned char text[] = "Hello\n";
// printNumber(SysTick->LOAD);
// CDC_Transmit_FS(text, sizeof(text));
}
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void) {
RCC_OscInitTypeDef RCC_OscInitStruct = { 0 };
RCC_ClkInitTypeDef RCC_ClkInitStruct = { 0 };
RCC_PeriphCLKInitTypeDef PeriphClkInit = { 0 };
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK
| RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
{
Error_Handler();
}
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USB;
PeriphClkInit.UsbClockSelection = RCC_USBCLKSOURCE_PLL;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
{
Error_Handler();
}
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK) {
Error_Handler();
}
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USB;
PeriphClkInit.UsbClockSelection = RCC_USBCLKSOURCE_PLL;
if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK) {
Error_Handler();
}
}
/**
* @brief I2C1 Initialization Function
* @param None
* @retval None
*/
static void MX_I2C1_Init(void)
{
* @brief I2C1 Initialization Function
* @param None
* @retval None
*/
static void MX_I2C1_Init(void) {
/* USER CODE BEGIN I2C1_Init 0 */
/* USER CODE BEGIN I2C1_Init 0 */
/* USER CODE END I2C1_Init 0 */
/* USER CODE END I2C1_Init 0 */
/* USER CODE BEGIN I2C1_Init 1 */
/* USER CODE BEGIN I2C1_Init 1 */
/* USER CODE END I2C1_Init 1 */
hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000;
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
if (HAL_I2C_Init(&hi2c1) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN I2C1_Init 2 */
/* USER CODE END I2C1_Init 1 */
hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000;
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
if (HAL_I2C_Init(&hi2c1) != HAL_OK) {
Error_Handler();
}
/* USER CODE BEGIN I2C1_Init 2 */
/* USER CODE END I2C1_Init 2 */
/* USER CODE END I2C1_Init 2 */
}
/**
* @brief TIM1 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM1_Init(void)
{
* @brief TIM1 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM1_Init(void) {
/* USER CODE BEGIN TIM1_Init 0 */
/* USER CODE BEGIN TIM1_Init 0 */
/* USER CODE END TIM1_Init 0 */
/* USER CODE END TIM1_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
TIM_ClockConfigTypeDef sClockSourceConfig = { 0 };
TIM_MasterConfigTypeDef sMasterConfig = { 0 };
TIM_OC_InitTypeDef sConfigOC = { 0 };
TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = { 0 };
/* USER CODE BEGIN TIM1_Init 1 */
/* USER CODE BEGIN TIM1_Init 1 */
/* USER CODE END TIM1_Init 1 */
htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 4000;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
{
Error_Handler();
}
sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
sBreakDeadTimeConfig.DeadTime = 0;
sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM1_Init 2 */
/* USER CODE END TIM1_Init 1 */
htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 4000;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim1) != HAL_OK) {
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK) {
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim1) != HAL_OK) {
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig)
!= HAL_OK) {
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1)
!= HAL_OK) {
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2)
!= HAL_OK) {
Error_Handler();
}
sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
sBreakDeadTimeConfig.DeadTime = 0;
sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig)
!= HAL_OK) {
Error_Handler();
}
/* USER CODE BEGIN TIM1_Init 2 */
/* USER CODE END TIM1_Init 2 */
HAL_TIM_MspPostInit(&htim1);
/* USER CODE END TIM1_Init 2 */
HAL_TIM_MspPostInit(&htim1);
}
/**
* @brief TIM2 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM2_Init(void)
{
* @brief TIM2 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM2_Init(void) {
/* USER CODE BEGIN TIM2_Init 0 */
/* USER CODE BEGIN TIM2_Init 0 */
/* USER CODE END TIM2_Init 0 */
/* USER CODE END TIM2_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
TIM_ClockConfigTypeDef sClockSourceConfig = { 0 };
TIM_MasterConfigTypeDef sMasterConfig = { 0 };
TIM_OC_InitTypeDef sConfigOC = { 0 };
/* USER CODE BEGIN TIM2_Init 1 */
/* USER CODE BEGIN TIM2_Init 1 */
/* USER CODE END TIM2_Init 1 */
htim2.Instance = TIM2;
htim2.Init.Prescaler = 0;
htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
htim2.Init.Period = 4000;
htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM2_Init 2 */
/* USER CODE END TIM2_Init 1 */
htim2.Instance = TIM2;
htim2.Init.Prescaler = 0;
htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
htim2.Init.Period = 4000;
htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim2) != HAL_OK) {
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK) {
Error_Handler();
}
if (HAL_TIM_PWM_Init(&htim2) != HAL_OK) {
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig)
!= HAL_OK) {
Error_Handler();
}
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1)
!= HAL_OK) {
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2)
!= HAL_OK) {
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3)
!= HAL_OK) {
Error_Handler();
}
if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_4)
!= HAL_OK) {
Error_Handler();
}
/* USER CODE BEGIN TIM2_Init 2 */
/* USER CODE END TIM2_Init 2 */
HAL_TIM_MspPostInit(&htim2);
/* USER CODE END TIM2_Init 2 */
HAL_TIM_MspPostInit(&htim2);
}
/**
* @brief TIM3 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM3_Init(void)
{
* @brief TIM3 Initialization Function
* @param None
* @retval None
*/
static void MX_TIM3_Init(void) {
/* USER CODE BEGIN TIM3_Init 0 */
__HAL_RCC_TIM3_CLK_ENABLE();
/* USER CODE END TIM3_Init 0 */
/* USER CODE BEGIN TIM3_Init 0 */
__HAL_RCC_TIM3_CLK_ENABLE();
/* USER CODE END TIM3_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_IC_InitTypeDef sConfigIC = {0};
TIM_ClockConfigTypeDef sClockSourceConfig = { 0 };
TIM_MasterConfigTypeDef sMasterConfig = { 0 };
TIM_IC_InitTypeDef sConfigIC = { 0 };
/* USER CODE BEGIN TIM3_Init 1 */
/* USER CODE BEGIN TIM3_Init 1 */
/* USER CODE END TIM3_Init 1 */
htim3.Instance = TIM3;
htim3.Init.Prescaler = 47;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 65000;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_IC_Init(&htim3) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
sConfigIC.ICFilter = 0;
if (HAL_TIM_IC_ConfigChannel(&htim3, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
{
Error_Handler();
}
if (HAL_TIM_IC_ConfigChannel(&htim3, &sConfigIC, TIM_CHANNEL_2) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM3_Init 2 */
/* USER CODE END TIM3_Init 1 */
htim3.Instance = TIM3;
htim3.Init.Prescaler = 47;
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
htim3.Init.Period = 65000;
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim3) != HAL_OK) {
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK) {
Error_Handler();
}
if (HAL_TIM_IC_Init(&htim3) != HAL_OK) {
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig)
!= HAL_OK) {
Error_Handler();
}
sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
sConfigIC.ICFilter = 0;
if (HAL_TIM_IC_ConfigChannel(&htim3, &sConfigIC, TIM_CHANNEL_1) != HAL_OK) {
Error_Handler();
}
if (HAL_TIM_IC_ConfigChannel(&htim3, &sConfigIC, TIM_CHANNEL_2) != HAL_OK) {
Error_Handler();
}
/* USER CODE BEGIN TIM3_Init 2 */
/* USER CODE END TIM3_Init 2 */
/* USER CODE END TIM3_Init 2 */
}
/**
* @brief USART3 Initialization Function
* @param None
* @retval None
*/
static void MX_USART3_UART_Init(void)
{
* @brief USART3 Initialization Function
* @param None
* @retval None
*/
static void MX_USART3_UART_Init(void) {
/* USER CODE BEGIN USART3_Init 0 */
/* USER CODE BEGIN USART3_Init 0 */
/* USER CODE END USART3_Init 0 */
/* USER CODE END USART3_Init 0 */
/* USER CODE BEGIN USART3_Init 1 */
/* USER CODE BEGIN USART3_Init 1 */
/* USER CODE END USART3_Init 1 */
huart3.Instance = USART3;
huart3.Init.BaudRate = 9600;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart3) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN USART3_Init 2 */
/* USER CODE END USART3_Init 1 */
huart3.Instance = USART3;
huart3.Init.BaudRate = 9600;
huart3.Init.WordLength = UART_WORDLENGTH_8B;
huart3.Init.StopBits = UART_STOPBITS_1;
huart3.Init.Parity = UART_PARITY_NONE;
huart3.Init.Mode = UART_MODE_TX_RX;
huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
huart3.Init.OverSampling = UART_OVERSAMPLING_16;
if (HAL_UART_Init(&huart3) != HAL_OK) {
Error_Handler();
}
/* USER CODE BEGIN USART3_Init 2 */
// if (HAL_UART_Receive_IT(&huart3, uart_rx_buffer, UART_BUFFER_SIZE) != HAL_OK)
// {
// Error_Handler();
// }
/* USER CODE END USART3_Init 2 */
/* USER CODE END USART3_Init 2 */
}
/**
* Enable DMA controller clock
*/
static void MX_DMA_Init(void)
{
* Enable DMA controller clock
*/
static void MX_DMA_Init(void) {
/* DMA controller clock enable */
__HAL_RCC_DMA1_CLK_ENABLE();
/* DMA controller clock enable */
__HAL_RCC_DMA1_CLK_ENABLE();
/* DMA interrupt init */
/* DMA1_Channel3_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
/* DMA interrupt init */
/* DMA1_Channel3_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}
/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void) {
GPIO_InitTypeDef GPIO_InitStruct = { 0 };
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOA, LED_DATA_Pin|LED_CLK_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOA, LED_DATA_Pin | LED_CLK_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin : PC13 */
GPIO_InitStruct.Pin = GPIO_PIN_13;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/*Configure GPIO pin : PC13 */
GPIO_InitStruct.Pin = GPIO_PIN_13;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/*Configure GPIO pins : LED_DATA_Pin LED_CLK_Pin */
GPIO_InitStruct.Pin = LED_DATA_Pin|LED_CLK_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pins : LED_DATA_Pin LED_CLK_Pin */
GPIO_InitStruct.Pin = LED_DATA_Pin | LED_CLK_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*Configure GPIO pin : BALL_EXT_Pin */
GPIO_InitStruct.Pin = BALL_EXT_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(BALL_EXT_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pin : BALL_EXT_Pin */
GPIO_InitStruct.Pin = BALL_EXT_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(BALL_EXT_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pin : IR_EXT_Pin */
GPIO_InitStruct.Pin = IR_EXT_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(IR_EXT_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pin : IR_EXT_Pin */
GPIO_InitStruct.Pin = IR_EXT_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitStruct.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(IR_EXT_GPIO_Port, &GPIO_InitStruct);
/* EXTI interrupt init*/
HAL_NVIC_SetPriority(EXTI0_IRQn, 7, 0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
/* EXTI interrupt init*/
HAL_NVIC_SetPriority(EXTI0_IRQn, 7, 0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
HAL_NVIC_SetPriority(EXTI1_IRQn, 7, 0);
HAL_NVIC_EnableIRQ(EXTI1_IRQn);
HAL_NVIC_SetPriority(EXTI1_IRQn, 7, 0);
HAL_NVIC_EnableIRQ(EXTI1_IRQn);
/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}
/* USER CODE BEGIN 4 */
@ -642,19 +590,17 @@ static void MX_GPIO_Init(void)
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
// GPIOC->ODR &= ~GPIO_PIN_13;
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void) {
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
// GPIOC->ODR &= ~GPIO_PIN_13;
while (1) {
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT

12
TODO.md
View File

@ -1,3 +1,12 @@
Логика:
Ограничение скорости роликов!
Ограничение углов сервы
Уточнить, в ТЗ только обработка 201 команды и учитывается только макс угол
Начальное смещение:
Корректировать макс углы ?
Не корректировать углы ?
Работа с памятью:
V Припаять i2c!!!
Сохранение выстрела
@ -28,6 +37,7 @@ IR:
Функция отображения скорости
Обратный отсчёт
Индикация ошибок
Процесс удаления
Звук:
Звук приёма IR
@ -37,5 +47,5 @@ IR:
Ошибки:
В некоторый момент PID регулятор выдаёт 0 и двигатель не запускается не зависимо от входного значенияPWM
V В некоторый момент PID регулятор выдаёт 0 и двигатель не запускается не зависимо от входного значенияPWM