dmarkova/WoodDrone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Dana Markova
2025-07-28 13:21:36 +03:00
commit 0de214c9a1
547 changed files with 287132 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
drv/gpio.cpp Normal file
View File

@ -0,0 +1,37 @@
#include "stm32g4xx.h"
#include "gpio.h"
void GPIO_InitPin(unsigned long I_Pin)
{
unsigned long port = (I_Pin & 0x000000F0UL) >> 4;
GPIO_TypeDef* gpio = (GPIO_TypeDef*)(((unsigned char*)GPIOA) + (port * 0x0400));
unsigned long rcc = 1UL << port;
unsigned long pin = I_Pin & 0x0000000FUL;
unsigned long af = (I_Pin & 0x0F000000UL) >> 24;
unsigned long pupd = (I_Pin & 0x00F00000UL) >> 20;
unsigned long ospeed = (I_Pin & 0x000F0000UL) >> 16;
unsigned long mode = (I_Pin & 0x0000F000UL) >> 12;
unsigned long otype = (I_Pin & 0x00000100UL) >> 8;
unsigned long set = (I_Pin & 0x00000200UL) >> 9;
//---
if (!(RCC->AHB2ENR & rcc)) RCC->AHB2ENR |= rcc;
//---
gpio->AFR[pin >> 3] &= ~(0x0000000FUL << ((pin & 0x07) * 4));
gpio->AFR[pin >> 3] |= af << ((pin & 0x07) * 4);
//---
gpio->OSPEEDR &= ~(0x00000003UL << (pin * 2));
gpio->OSPEEDR |= ospeed << (pin * 2);
//---
gpio->OTYPER &= ~(0x00000001UL << pin);
gpio->OTYPER |= otype << pin;
//---
gpio->PUPDR &= ~(0x00000003UL << (pin * 2));
gpio->PUPDR |= pupd << (pin * 2);
//---
gpio->BSRR = 1 << (set ? pin : pin+16);
//---
gpio->MODER &= ~(0x00000003UL << (pin * 2));
gpio->MODER |= mode << (pin * 2);
}
//------------------------------------------------------------------------------

69
drv/gpio.h Normal file
View File

@ -0,0 +1,69 @@
#pragma once
#define GPIO_PIN_0 0x00000000UL
#define GPIO_PIN_1 0x00000001UL
#define GPIO_PIN_2 0x00000002UL
#define GPIO_PIN_3 0x00000003UL
#define GPIO_PIN_4 0x00000004UL
#define GPIO_PIN_5 0x00000005UL
#define GPIO_PIN_6 0x00000006UL
#define GPIO_PIN_7 0x00000007UL
#define GPIO_PIN_8 0x00000008UL
#define GPIO_PIN_9 0x00000009UL
#define GPIO_PIN_10 0x0000000AUL
#define GPIO_PIN_11 0x0000000BUL
#define GPIO_PIN_12 0x0000000CUL
#define GPIO_PIN_13 0x0000000DUL
#define GPIO_PIN_14 0x0000000EUL
#define GPIO_PIN_15 0x0000000FUL
#define GPIO_PORT_A 0x00000000UL
#define GPIO_PORT_B 0x00000010UL
#define GPIO_PORT_C 0x00000020UL
#define GPIO_PORT_D 0x00000030UL
#define GPIO_PORT_E 0x00000040UL
#define GPIO_PORT_F 0x00000070UL
#define GPIO_PORT_G 0x00000080UL
#define GPIO_PORT_H 0x00000090UL
#define GPIO_PORT_I 0x000000A0UL
#define GPIO_PORT_J 0x000000B0UL
#define GPIO_PORT_K 0x000000C0UL
#define GPIO_PUSHPULL 0x00000000UL
#define GPIO_OPENDRAIN 0x00000100UL
#define GPIO_RESET 0x00000000UL
#define GPIO_SET 0x00000200UL
#define GPIO_INPUT 0x00000000UL
#define GPIO_OUTPUT 0x00001000UL
#define GPIO_ALTER 0x00002000UL
#define GPIO_ANALOG 0x00003000UL
#define GPIO_OSPEED_LOW 0x00000000UL
#define GPIO_OSPEED_MEDIUM 0x00010000UL
#define GPIO_OSPEED_FAST 0x00020000UL
#define GPIO_OSPEED_HIGH 0x00030000UL
#define GPIO_NOPUPD 0x00000000UL
#define GPIO_PULLUP 0x00100000UL
#define GPIO_PULLDOWN 0x00200000UL
#define GPIO_AF0 0x00000000UL
#define GPIO_AF1 0x01000000UL
#define GPIO_AF2 0x02000000UL
#define GPIO_AF3 0x03000000UL
#define GPIO_AF4 0x04000000UL
#define GPIO_AF5 0x05000000UL
#define GPIO_AF6 0x06000000UL
#define GPIO_AF7 0x07000000UL
#define GPIO_AF8 0x08000000UL
#define GPIO_AF9 0x09000000UL
#define GPIO_AF10 0x0A000000UL
#define GPIO_AF11 0x0B000000UL
#define GPIO_AF12 0x0C000000UL
#define GPIO_AF13 0x0D000000UL
#define GPIO_AF14 0x0E000000UL
#define GPIO_AF15 0x0F000000UL
void GPIO_InitPin(unsigned long I_Pin);

165
drv/i2c копия.cpp Normal file
View File

@ -0,0 +1,165 @@
#include "stm32g4xx.h"
#include "gpio.h"
#include "i2c.h"
static void Init(I2C_TypeDef* I2C)
{
I2C->TIMINGR = 0x00303D5BUL; // 100kHz
I2C->CR1 = I2C_CR1_PE;
while(I2C->ISR & I2C_ISR_BUSY) { }
}
//------------------------------------------------------------------------------
void I2C2_Init()
{
if (RCC->APB1ENR1 & RCC_APB1ENR1_I2C2EN) return;
RCC->APB1ENR1 |= RCC_APB1ENR1_I2C2EN;
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN;
GPIO_InitPin(GPIO_PIN_8 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF4 | GPIO_OSPEED_HIGH | GPIO_OPENDRAIN | GPIO_PULLUP);
GPIO_InitPin(GPIO_PIN_9 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF4 | GPIO_OSPEED_HIGH | GPIO_OPENDRAIN | GPIO_PULLUP);
Init(I2C2);
}
//------------------------------------------------------------------------------
void I2C1_Init()
{
if (RCC->APB1ENR1 & RCC_APB1ENR1_I2C1EN) return;
RCC->APB1ENR1 |= RCC_APB1ENR1_I2C1EN;
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOBEN;
GPIO_InitPin(GPIO_PIN_8 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF4 | GPIO_OSPEED_HIGH | GPIO_OPENDRAIN | GPIO_PULLUP);
GPIO_InitPin(GPIO_PIN_9 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF4 | GPIO_OSPEED_HIGH | GPIO_OPENDRAIN | GPIO_PULLUP);
Init(I2C1);
}
//------------------------------------------------------------------------------
static void Stop(I2C_TypeDef* I2C)
{
I2C->CR2 |= I2C_CR2_STOP;
while (!(I2C->ISR & I2C_ISR_STOPF)) { asm volatile("NOP"); }
I2C->ICR = I2C_ICR_STOPCF;
}
//------------------------------------------------------------------------------
static void Read(I2C_TypeDef* I2C, unsigned char Address, unsigned char* Data, unsigned char Size)
{
I2C->CR2 &= ~(I2C_CR2_SADD_Msk | I2C_CR2_NBYTES_Msk);
I2C->CR2 |= (Address << (I2C_CR2_SADD_Pos + 1)) | I2C_CR2_RD_WRN | (((unsigned long)Size)<<I2C_CR2_NBYTES_Pos);
I2C->CR2 |= I2C_CR2_START;
while(I2C->CR2 & I2C_CR2_START) { asm volatile("NOP"); }
while (Size--)
{
while (!(I2C->ISR & I2C_ISR_RXNE)) { }
*Data++ = I2C->RXDR;
}
}
//------------------------------------------------------------------------------
static void Write(I2C_TypeDef* I2C, unsigned char Address, const unsigned char* Data, unsigned char Size)
{
I2C->CR2 &= ~(I2C_CR2_SADD_Msk | I2C_CR2_RD_WRN | I2C_CR2_NBYTES_Msk);
I2C->CR2 |= (Address << (I2C_CR2_SADD_Pos + 1)) | (((unsigned long)Size)<<I2C_CR2_NBYTES_Pos);
I2C->CR2 |= I2C_CR2_START;
while(I2C->CR2 & I2C_CR2_START) { asm volatile("NOP"); }
while (Size--)
{
while (!(I2C->ISR & I2C_ISR_TXE)) { asm volatile("NOP"); }
I2C->TXDR = *Data++;
}
while(!(I2C->ISR & I2C_ISR_TC)) { asm volatile("NOP"); }
}
//------------------------------------------------------------------------------
static void Write2(I2C_TypeDef* I2C, unsigned char Address, const unsigned char* Data1, unsigned char Size1, const unsigned char* Data2, unsigned char Size2)
{
I2C->CR2 &= ~(I2C_CR2_SADD_Msk | I2C_CR2_RD_WRN | I2C_CR2_NBYTES_Msk);
I2C->CR2 |= (Address << (I2C_CR2_SADD_Pos + 1)) | (((unsigned long)Size1+Size2)<<I2C_CR2_NBYTES_Pos);
I2C->CR2 |= I2C_CR2_START;
while(I2C->CR2 & I2C_CR2_START) { asm volatile("NOP"); }
while (Size1--)
{
while (!(I2C->ISR & I2C_ISR_TXE)) { asm volatile("NOP"); }
I2C->TXDR = *Data1++;
}
while (Size2--)
{
while (!(I2C->ISR & I2C_ISR_TXE)) { asm volatile("NOP"); }
I2C->TXDR = *Data2++;
}
while(!(I2C->ISR & I2C_ISR_TC)) { asm volatile("NOP"); }
}
//------------------------------------------------------------------------------
void I2C2_Write(unsigned char Address, unsigned char Data)
{
Write(I2C2, Address, &Data, 1);
}
//------------------------------------------------------------------------------
void I2C2_Write(unsigned char Address, const void* Data, unsigned char Size)
{
Write(I2C2, Address, (unsigned char*)Data, Size);
}
//------------------------------------------------------------------------------
void I2C2_Read(unsigned char Address, void* Data, unsigned char Size)
{
Read(I2C2, Address, (unsigned char*)Data, Size);
}
//------------------------------------------------------------------------------
void I2C2_Stop()
{
Stop(I2C2);
}
//------------------------------------------------------------------------------
void I2C1_Write(unsigned char Address, unsigned char Data)
{
Write(I2C1, Address, &Data, 1);
}
//------------------------------------------------------------------------------
void I2C1_Write(unsigned char Address, const void* Data, unsigned char Size)
{
Write(I2C1, Address, (unsigned char*)Data, Size);
}
//------------------------------------------------------------------------------
void I2C1_Write2(unsigned char Address, const void* Data1, unsigned char Size1, const void* Data2, unsigned char Size2)
{
Write2(I2C1, Address, (unsigned char*)Data1, Size1, (unsigned char*)Data2, Size2);
}
//------------------------------------------------------------------------------
void I2C1_Read(unsigned char Address, void* Data, unsigned char Size)
{
Read(I2C1, Address, (unsigned char*)Data, Size);
}
//------------------------------------------------------------------------------
void I2C1_Stop()
{
Stop(I2C1);
}
//------------------------------------------------------------------------------

316
drv/i2c.cpp Normal file
View File

@ -0,0 +1,316 @@
#include "stm32g4xx.h"
#include <string.h>
#include "gpio.h"
#include "i2c.h"
struct I2C_Data
{
I2C_TypeDef* I2C;
IRQn_Type IRQn;
I2C_Request *Head, *Device;
unsigned char Index;
};
static I2C_Data I2C1_Data{ I2C1, I2C1_EV_IRQn, 0, 0, 0 };
static I2C_Data I2C2_Data{ I2C2, I2C2_EV_IRQn, 0, 0, 0 };
static void EV_IRQHandler(I2C_Data& I2C)
{
if((I2C.I2C->CR1 & I2C_CR1_TXIE) && (I2C.I2C->ISR & I2C_ISR_TXE))
{
const I2C_Request& device=*I2C.Device;
I2C.I2C->TXDR = device.Buffer[I2C.Index++];
if(I2C.Index<device.Write) return;
I2C.I2C->CR1 = I2C_CR1_TCIE | I2C_CR1_PE;
I2C.Index=0;
return;
}
//---
if((I2C.I2C->CR1 & I2C_CR1_TCIE) && (I2C.I2C->ISR & I2C_ISR_TC))
{
const I2C_Request& device=*I2C.Device;
if(device.Read)
{
I2C.I2C->CR2 &= ~I2C_CR2_NBYTES_Msk;
I2C.I2C->CR2 |= I2C_CR2_START | I2C_CR2_RD_WRN | (((unsigned long)device.Read)<<I2C_CR2_NBYTES_Pos);
I2C.I2C->CR1 = I2C_CR1_RXIE | I2C_CR1_PE;
}
else
{
I2C.I2C->CR2 |= I2C_CR2_STOP;
I2C.I2C->CR1 = I2C_CR1_STOPIE | I2C_CR1_PE;
}
return;
}
//---
if((I2C.I2C->CR1 & I2C_CR1_RXIE) && (I2C.I2C->ISR & I2C_ISR_RXNE))
{
const I2C_Request& device=*I2C.Device;
device.Buffer[I2C.Index++] = I2C.I2C->RXDR;
if(I2C.Index<device.Read) return;
I2C.I2C->CR1 = I2C_CR1_STOPIE | I2C_CR1_PE;
I2C.I2C->CR2 |= I2C_CR2_STOP;
I2C.Index=0;
return;
}
//---
if((I2C.I2C->CR1 & I2C_CR1_STOPIE) && (I2C.I2C->ISR & I2C_ISR_STOPF))
{
I2C_Request& device=*I2C.Device;
I2C.I2C->ICR = I2C_ICR_STOPCF;
I2C.I2C->CR1 = I2C_CR1_PE;
I2C.I2C->CR2 &= ~(I2C_CR2_SADD_Msk | I2C_CR2_RD_WRN | I2C_CR2_NBYTES_Msk);
unsigned char addr=device.Address;
device.Address=0;
I2C.Device=device.Next;
if(device.CallbackProc) device.CallbackProc(addr, device.Buffer, device.Read);
}
//---
if(I2C.I2C->CR1 == I2C_CR1_PE)
{
if(!I2C.Device)
{
do
{
I2C.Device = (I2C_Request*)__LDREXW((volatile unsigned int*)&I2C.Head);
}while(__STREXW(0, (volatile unsigned int*)&I2C.Head));
if(!I2C.Device) return;
}
const I2C_Request& device=*I2C.Device;
if(!(I2C.I2C->CR2 & I2C_CR2_SADD_Msk))
{
I2C.I2C->CR2 &= ~(I2C_CR2_SADD_Msk | I2C_CR2_RD_WRN | I2C_CR2_NBYTES_Msk);
if(device.Write)
{
I2C.I2C->CR2 |= I2C_CR2_START | (device.Address << (I2C_CR2_SADD_Pos + 1)) | (((unsigned long)device.Write)<<I2C_CR2_NBYTES_Pos);
I2C.I2C->CR1 = I2C_CR1_TXIE | I2C_CR1_PE;
}
else
{
I2C.I2C->CR2 |= I2C_CR2_START | (device.Address << (I2C_CR2_SADD_Pos + 1)) | I2C_CR2_RD_WRN | (((unsigned long)device.Read)<<I2C_CR2_NBYTES_Pos);
I2C.I2C->CR1 = I2C_CR1_RXIE | I2C_CR1_PE;
}
}
return;
}
}
//------------------------------------------------------------------------------
extern "C" void I2C1_EV_IRQHandler()
{
EV_IRQHandler(I2C1_Data);
}
//------------------------------------------------------------------------------
extern "C" void I2C2_EV_IRQHandler()
{
EV_IRQHandler(I2C2_Data);
}
//------------------------------------------------------------------------------
static void Init(I2C_TypeDef* I2C, IRQn_Type IRQn)
{
I2C->TIMINGR = 0x00303D5BUL; // 100kHz
I2C->CR1 = I2C_CR1_PE;
while(I2C->ISR & I2C_ISR_BUSY) { }
NVIC_SetPriority(IRQn, 1);
NVIC_EnableIRQ(IRQn);
}
//------------------------------------------------------------------------------
void I2C2_Init()
{
if (RCC->APB1ENR1 & RCC_APB1ENR1_I2C2EN) return;
RCC->APB1ENR1 |= RCC_APB1ENR1_I2C2EN;
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN;
GPIO_InitPin(GPIO_PIN_8 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF4 | GPIO_OSPEED_HIGH | GPIO_OPENDRAIN | GPIO_PULLUP);
GPIO_InitPin(GPIO_PIN_9 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF4 | GPIO_OSPEED_HIGH | GPIO_OPENDRAIN | GPIO_PULLUP);
Init(I2C2, I2C2_EV_IRQn);
}
//------------------------------------------------------------------------------
void I2C1_Init()
{
if (RCC->APB1ENR1 & RCC_APB1ENR1_I2C1EN) return;
RCC->APB1ENR1 |= RCC_APB1ENR1_I2C1EN;
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOBEN;
GPIO_InitPin(GPIO_PIN_8 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF4 | GPIO_OSPEED_HIGH | GPIO_OPENDRAIN | GPIO_PULLUP);
GPIO_InitPin(GPIO_PIN_9 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF4 | GPIO_OSPEED_HIGH | GPIO_OPENDRAIN | GPIO_PULLUP);
Init(I2C1, I2C1_EV_IRQn);
}
//------------------------------------------------------------------------------
static void Stop(I2C_TypeDef* I2C)
{
I2C->CR2 |= I2C_CR2_STOP;
while (!(I2C->ISR & I2C_ISR_STOPF)) { asm volatile("NOP"); }
I2C->ICR = I2C_ICR_STOPCF;
I2C->CR2 = 0;
}
//------------------------------------------------------------------------------
static void Read(I2C_TypeDef* I2C, unsigned char Address, unsigned char* Data, unsigned char Size)
{
I2C->CR2 &= ~(I2C_CR2_SADD_Msk | I2C_CR2_NBYTES_Msk);
I2C->CR2 |= (Address << (I2C_CR2_SADD_Pos + 1)) | I2C_CR2_RD_WRN | (((unsigned long)Size)<<I2C_CR2_NBYTES_Pos);
I2C->CR2 |= I2C_CR2_START;
while (Size--)
{
while (!(I2C->ISR & I2C_ISR_RXNE)) { }
*Data++ = I2C->RXDR;
}
}
//------------------------------------------------------------------------------
static void Write(I2C_TypeDef* I2C, unsigned char Address, const unsigned char* Data, unsigned char Size)
{
I2C->CR2 &= ~(I2C_CR2_SADD_Msk | I2C_CR2_RD_WRN | I2C_CR2_NBYTES_Msk);
I2C->CR2 |= (Address << (I2C_CR2_SADD_Pos + 1)) | (((unsigned long)Size)<<I2C_CR2_NBYTES_Pos);
I2C->CR2 |= I2C_CR2_START;
while(I2C->CR2 & I2C_CR2_START) { asm volatile("NOP"); }
while (Size--)
{
while (!(I2C->ISR & I2C_ISR_TXE)) { asm volatile("NOP"); }
I2C->TXDR = *Data++;
}
while(!(I2C->ISR & I2C_ISR_TC)) { asm volatile("NOP"); }
}
//------------------------------------------------------------------------------
static bool Trans(I2C_Data& I2C, I2C_Request* Request, unsigned char Address, const unsigned char* Data, unsigned char SizeWrite, unsigned char SizeRead)
{
if(Request->Address || SizeWrite>Request->Size || SizeRead>Request->Size || (SizeWrite==0 && SizeRead==0)) return false;
if(SizeWrite) memcpy(Request->Buffer, Data, SizeWrite);
Request->Write=SizeWrite;
Request->Read=SizeRead;
Request->Address=Address;
do
{
I2C_Request* dev = (I2C_Request*)__LDREXW((volatile unsigned int*)&I2C.Head);
Request->Next=dev;
}while(__STREXW((unsigned int)Request, (volatile unsigned int*)&I2C.Head));
if(I2C.I2C->CR1 == I2C_CR1_PE) NVIC_SetPendingIRQ(I2C.IRQn);
//---
return true;
}
//------------------------------------------------------------------------------
static void Write2(I2C_TypeDef* I2C, unsigned char Address, const unsigned char* Data1, unsigned char Size1, const unsigned char* Data2, unsigned char Size2)
{
I2C->CR2 &= ~(I2C_CR2_SADD_Msk | I2C_CR2_RD_WRN | I2C_CR2_NBYTES_Msk);
I2C->CR2 |= (Address << (I2C_CR2_SADD_Pos + 1)) | (((unsigned long)Size1+Size2)<<I2C_CR2_NBYTES_Pos);
I2C->CR2 |= I2C_CR2_START;
while (Size1--)
{
while (!(I2C->ISR & I2C_ISR_TXE)) { asm volatile("NOP"); }
I2C->TXDR = *Data1++;
}
while (Size2--)
{
while (!(I2C->ISR & I2C_ISR_TXE)) { asm volatile("NOP"); }
I2C->TXDR = *Data2++;
}
while(!(I2C->ISR & I2C_ISR_TC)) { asm volatile("NOP"); }
}
//------------------------------------------------------------------------------
bool I2C2_Trans(I2C_Request* Request, unsigned char Address, const unsigned char* Data, unsigned char SizeWrite, unsigned char SizeRead)
{
return Trans(I2C2_Data, Request, Address, Data, SizeWrite, SizeRead);
}
void I2C2_Write(unsigned char Address, unsigned char Data)
{
Write(I2C2, Address, &Data, 1);
}
//------------------------------------------------------------------------------
void I2C2_Write(unsigned char Address, const void* Data, unsigned char Size)
{
Write(I2C2, Address, (unsigned char*)Data, Size);
}
//------------------------------------------------------------------------------
void I2C2_Read(unsigned char Address, void* Data, unsigned char Size)
{
Read(I2C2, Address, (unsigned char*)Data, Size);
}
//------------------------------------------------------------------------------
void I2C2_Stop()
{
Stop(I2C2);
}
//------------------------------------------------------------------------------
bool I2C1_Trans(I2C_Request* Request, unsigned char Address, const unsigned char* Data, unsigned char SizeWrite, unsigned char SizeRead)
{
return Trans(I2C1_Data, Request, Address, Data, SizeWrite, SizeRead);
}
void I2C1_Write(unsigned char Address, unsigned char Data)
{
Write(I2C1, Address, &Data, 1);
}
//------------------------------------------------------------------------------
void I2C1_Write(unsigned char Address, const void* Data, unsigned char Size)
{
Write(I2C1, Address, (unsigned char*)Data, Size);
}
//------------------------------------------------------------------------------
void I2C1_Write2(unsigned char Address, const void* Data1, unsigned char Size1, const void* Data2, unsigned char Size2)
{
Write2(I2C1, Address, (unsigned char*)Data1, Size1, (unsigned char*)Data2, Size2);
}
//------------------------------------------------------------------------------
void I2C1_Read(unsigned char Address, void* Data, unsigned char Size)
{
Read(I2C1, Address, (unsigned char*)Data, Size);
}
//------------------------------------------------------------------------------
void I2C1_Stop()
{
Stop(I2C1);
}
//------------------------------------------------------------------------------

29
drv/i2c.h Normal file
View File

@ -0,0 +1,29 @@
#pragma once
struct I2C_Request
{
void (*CallbackProc)(unsigned char Address, const unsigned char* Data, unsigned char Size);
unsigned char* Buffer;
unsigned char Size;
unsigned char Address;
unsigned char Write;
unsigned char Read;
I2C_Request* Next;
};
void I2C2_Init();
bool I2C2_Trans(I2C_Request* Request, unsigned char Address, const unsigned char* Data, unsigned char SizeWrite, unsigned char SizeRead);
void I2C2_Write(unsigned char Address, unsigned char Data);
void I2C2_Write(unsigned char Address, const void* Data, unsigned char Size);
void I2C2_Read(unsigned char Address, void* Data, unsigned char Size);
void I2C2_Stop();
void I2C1_Init();
bool I2C1_Trans(I2C_Request* Request, unsigned char Address, const unsigned char* Data, unsigned char SizeWrite, unsigned char SizeRead);
void I2C1_Write(unsigned char Address, unsigned char Data);
void I2C1_Write(unsigned char Address, const void* Data, unsigned char Size);
void I2C1_Write2(unsigned char Address, const void* Data1, unsigned char Size1, const void* Data2, unsigned char Size2);
void I2C1_Read(unsigned char Address, void* Data, unsigned char Size);
void I2C1_Stop();

18
drv/iwdg.cpp Normal file
View File

@ -0,0 +1,18 @@
#include "stm32g4xx.h"
#include "iwdg.h"
void InitIWDG(unsigned short Reload)
{
IWDG->KR=0x0000CCCC;
IWDG->KR=0x00005555;
IWDG->PR=0;
IWDG->RLR=Reload;
while(IWDG->SR) { asm volatile("NOP"); }
IWDG->KR=0x0000AAAA;
}
void PingIWDG()
{
IWDG->KR=0x0000AAAA;
}

4
drv/iwdg.h Normal file
View File

@ -0,0 +1,4 @@
#pragma once
void InitIWDG(unsigned short Reload);
void PingIWDG();

103
drv/pwm.cpp Normal file
View File

@ -0,0 +1,103 @@
#include "stm32g4xx.h"
#include "gpio.h"
#include "pwm.h"
bool PWM_Enable=false;
inline static unsigned short Mid(unsigned short Val, unsigned short Min, unsigned short Max)
{
if(Val<Min) return Min;
if(Val>Max) return Max;
return Val;
}
static void InitTIM(TIM_TypeDef* TIM, unsigned long Freq, unsigned long CCER)
{
TIM->ARR = (1000000/Freq) - 1;
TIM->PSC = (SystemCoreClock / (1000000/Freq) / Freq) - 1;
TIM->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1PE | TIM_CCMR1_OC2M_1 | TIM_CCMR1_OC2M_2 | TIM_CCMR1_OC2PE;
TIM->CCMR2 = TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3M_2 | TIM_CCMR2_OC3PE | TIM_CCMR2_OC4M_1 | TIM_CCMR2_OC4M_2 | TIM_CCMR2_OC4PE;
TIM->CCER = CCER;
TIM->BDTR = TIM_BDTR_MOE;
TIM->CCR1 = 0;
TIM->CCR2 = 0;
TIM->CCR3 = 0;
TIM->CCR4 = 0;
TIM->CR1 = TIM_CR1_CEN;
}
//------------------------------------------------------------------------------
void PWM_Init(unsigned long Freq)
{
RCC->APB1ENR1 |= RCC_APB1ENR1_TIM2EN;
RCC->APB2ENR |= RCC_APB2ENR_TIM1EN | RCC_APB2ENR_TIM16EN | RCC_APB2ENR_TIM17EN;
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN | RCC_AHB2ENR_GPIOBEN;
GPIO_InitPin(GPIO_PIN_0 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF1); // TIM2_CH1
GPIO_InitPin(GPIO_PIN_1 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF1); // TIM2_CH2
GPIO_InitPin(GPIO_PIN_10 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF6); // TIM1_CH3
GPIO_InitPin(GPIO_PIN_11 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF11); // TIM1_CH4
InitTIM(TIM2, Freq, TIM_CCER_CC1E | TIM_CCER_CC2E);
InitTIM(TIM1, Freq, TIM_CCER_CC3E | TIM_CCER_CC4E);
}
//------------------------------------------------------------------------------
static void Stop()
{
PWM_Enable=false;
TIM1->CCER=0;
TIM2->CCER=0;
TIM16->CCER=0;
TIM17->CCER=0;
}
//------------------------------------------------------------------------------
void PWM_SetQuad(short Pow[4], unsigned short Min, unsigned short Max)
{
if(!Pow) { Stop(); return; }
TIM1->CCR4 = Mid(Pow[0], Min, Max);
TIM2->CCR2 = Mid(Pow[1], Min, Max);
TIM2->CCR1 = Mid(Pow[2], Min, Max);
TIM1->CCR3 = Mid(Pow[3], Min, Max);
bool en=false;
for(int a=0; a<4; a++) if(Pow[a]>1050) en=true;
PWM_Enable=en;
}
//------------------------------------------------------------------------------
void PWM_SetHexa(short Pow[6], unsigned short Min, unsigned short Max)
{
if(!Pow) { Stop(); return; }
TIM16->CCR1 = Mid(Pow[0], Min, Max);
TIM17->CCR1 = Mid(Pow[1], Min, Max);
TIM2->CCR1 = Mid(Pow[2], Min, Max);
TIM1->CCR3 = Mid(Pow[3], Min, Max);
TIM1->CCR4 = Mid(Pow[4], Min, Max);
TIM2->CCR2 = Mid(Pow[5], Min, Max);
bool en=false;
for(int a=0; a<4; a++) if(Pow[a]>1050) en=true;
PWM_Enable=en;
}
//------------------------------------------------------------------------------
void PWM_SetAll(unsigned short Pow)
{
TIM2->CCR1 = Pow;
TIM1->CCR3 = Pow;
TIM1->CCR4 = Pow;
TIM2->CCR2 = Pow;
bool en=false;
if(Pow>1050) en=true;
PWM_Enable=en;
}
//------------------------------------------------------------------------------

8
drv/pwm.h Normal file
View File

@ -0,0 +1,8 @@
#pragma once
extern bool PWM_Enable;
void PWM_Init(unsigned long Freq);
void PWM_SetQuad(short M[4], unsigned short Min, unsigned short Max);
void PWM_SetHexa(short M[6], unsigned short Min, unsigned short Max);
void PWM_SetAll(unsigned short Pow);

43
drv/servo.cpp Normal file
View File

@ -0,0 +1,43 @@
#include "servo.h"
#include "stm32g4xx.h"
#include "gpio.h"
static void InitTIM16(TIM_TypeDef* TIM, unsigned long Freq, unsigned long CCER)
{
TIM->ARR = (1000000/Freq) - 1;
TIM->PSC = (SystemCoreClock / (1000000/Freq) / Freq) - 1;
TIM->CCMR1 = TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1PE | TIM_CCMR1_OC2M_1 | TIM_CCMR1_OC2M_2 | TIM_CCMR1_OC2PE;
TIM->CCMR2 = TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3M_2 | TIM_CCMR2_OC3PE | TIM_CCMR2_OC4M_1 | TIM_CCMR2_OC4M_2 | TIM_CCMR2_OC4PE;
TIM->CCER = CCER;
TIM->BDTR = TIM_BDTR_MOE;
TIM->CCR1 = 0;
TIM->CCR2 = 0;
TIM->CCR3 = 0;
TIM->CCR4 = 0;
TIM->CR1 = TIM_CR1_CEN;
}
//------------------------------------------------------------------------------
void Servo_init(unsigned long Freq)
{
RCC->APB1ENR1 |= RCC_APB1ENR1_TIM2EN;
RCC->APB2ENR |= RCC_APB2ENR_TIM1EN | RCC_APB2ENR_TIM16EN | RCC_APB2ENR_TIM17EN;
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN | RCC_AHB2ENR_GPIOBEN;
GPIO_InitPin(GPIO_PIN_12 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF1); // TIM16_CH1
InitTIM16(TIM16, Freq, TIM_CCER_CC1E);
}
//------------------------------------------------------------------------------
void Servo_update(unsigned short Pow)
{
TIM16->CCR1 = Pow;
}
//------

5
drv/servo.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
void Servo_init(unsigned long Freq);
void Servo_update(unsigned short Pow);

82
drv/spi.cpp Normal file
View File

@ -0,0 +1,82 @@
#include "stm32g4xx.h"
#include "gpio.h"
#include "spi.h"
static void Init(SPI_TypeDef* SPI)
{
SPI->CR1 = SPI_CR1_CPHA | SPI_CR1_CPOL | SPI_CR1_SSI | SPI_CR1_SSM | (SPI_CR1_BR_0 | SPI_CR1_BR_1) | SPI_CR1_MSTR;
SPI->CR2 = SPI_CR2_DS_0 | SPI_CR2_DS_1 | SPI_CR2_DS_2 | SPI_CR2_FRXTH;
SPI->CR1 |= SPI_CR1_SPE;
}
//------------------------------------------------------------------------------
void SPI1_Init()
{
if(RCC->APB2ENR & RCC_APB2ENR_SPI1EN) return;
RCC->APB2ENR |= RCC_APB2ENR_SPI1EN;
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN;
GPIO_InitPin(GPIO_PIN_5 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF5 | GPIO_OSPEED_HIGH); // SCK
GPIO_InitPin(GPIO_PIN_6 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF5 | GPIO_OSPEED_HIGH); // MISO
GPIO_InitPin(GPIO_PIN_7 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF5 | GPIO_OSPEED_HIGH); // MOSI
GPIO_InitPin(GPIO_PIN_4 | GPIO_PORT_A | GPIO_OUTPUT | GPIO_OSPEED_HIGH | GPIO_SET); // NCS -> PMW3901
Init(SPI1);
}
//------------------------------------------------------------------------------
static void Trans(SPI_TypeDef* SPI, const void* WriteData, void* ReadData, unsigned long Size)
{
unsigned char* dr=(unsigned char*)ReadData;
unsigned char* dw=(unsigned char*)WriteData;
volatile char& DR = *((volatile char*)&(SPI->DR));
while (Size--)
{
while (!(SPI->SR & SPI_SR_TXE)) { asm volatile("NOP"); }
if (dw) DR = *(dw++);
else DR = 0x00;
while (!(SPI->SR & SPI_SR_RXNE)) { asm volatile("NOP"); }
if (dr) *(dr++) = DR;
else volatile char t = DR;
}
while (SPI->SR & SPI_SR_BSY) { asm volatile("NOP"); }
}
//------------------------------------------------------------------------------
static inline void CS_IMU(bool En)
{
if(En) GPIOA->BSRR = GPIO_BSRR_BR_4;
else GPIOA->BSRR = GPIO_BSRR_BS_4;
for (unsigned long a = 0; a < 21; a++) { asm volatile("NOP"); }
}
//------------------------------------------------------------------------------
void SPI1_TransferCons(const void* WriteData, unsigned long WriteSize, void* ReadData, unsigned long ReadSize)
{
CS_IMU(true);
Trans(SPI1, WriteData, 0, WriteSize);
Trans(SPI1, 0, ReadData, ReadSize);
CS_IMU(false);
}
//------------------------------------------------------------------------------
void SPI1_TransferParallel(const void* WriteData, void* ReadData, unsigned long Size)
{
CS_IMU(true);
Trans(SPI1, WriteData, ReadData, Size);
CS_IMU(false);
}
//------------------------------------------------------------------------------

6
drv/spi.h Normal file
View File

@ -0,0 +1,6 @@
#pragma once
void SPI1_Init();
void SPI1_TransferCons(const void* WriteData, unsigned long WriteSize, void* ReadData, unsigned long ReadSize);
void SPI1_TransferParallel(const void* WriteData, void* ReadData, unsigned long Size);

27
drv/tick.cpp Normal file
View File

@ -0,0 +1,27 @@
#include "stm32g4xx.h"
#include "tim.h"
static unsigned long Tick = 0;
extern "C" void SysTick_Handler()
{
Tick++;
}
//------------------------------------------------------------------------------
void TICK_Init()
{
SysTick->LOAD = SystemCoreClock / 1000;
SysTick->VAL = 0UL;
SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_ENABLE_Msk;
NVIC_SetPriority(SysTick_IRQn, 0);
}
//------------------------------------------------------------------------------
unsigned long TICK_GetCount() // ms
{
return Tick;
}
//------------------------------------------------------------------------------

4
drv/tick.h Normal file
View File

@ -0,0 +1,4 @@
#pragma once
void TICK_Init();
unsigned long TICK_GetCount();

34
drv/tim.cpp Normal file
View File

@ -0,0 +1,34 @@
#include "stm32g4xx.h"
#include "tim.h"
static void (*TIM7_Proc)() = 0;
extern "C" void TIM7_IRQHandler()
{
TIM7->SR = 0;
TIM7_Proc();
}
//------------------------------------------------------------------------------
void TIM7_Init(long Priority)
{
RCC->APB1ENR1 |= RCC_APB1ENR1_TIM7EN;
TIM7->CR1 = 0;
TIM7->ARR = 1000 - 1;
TIM7->DIER = TIM_DIER_UIE;
NVIC_SetPriority(TIM7_IRQn, Priority);
NVIC_EnableIRQ(TIM7_IRQn);
}
//------------------------------------------------------------------------------
void TIM7_Update(unsigned long Freq, void (*Proc)())
{
TIM7->CR1 = 0;
TIM7->PSC = (SystemCoreClock / 1000 / Freq) - 1;
TIM7_Proc = Proc;
TIM7->CR1 = TIM_CR1_CEN;
}
//------------------------------------------------------------------------------

4
drv/tim.h Normal file
View File

@ -0,0 +1,4 @@
#pragma once
void TIM7_Init(long Priority);
void TIM7_Update(unsigned long Freq, void (*UpdateProc)());

226
drv/uart копия.cpp Normal file
View File

@ -0,0 +1,226 @@
#include "stm32g4xx.h"
#include <string.h>
#include "gpio.h"
#include "uart.h"
static const unsigned long UART_BuferSize=256;
struct UART_Data
{
USART_TypeDef* UART;
struct
{
unsigned long Size;
unsigned char* Buffer;
unsigned short Head;
unsigned short Tail;
} Recv, Send;
};
static unsigned char UART3_BufferRecv[UART_BuferSize], UART3_BufferSend[UART_BuferSize];
static UART_Data UART3_Data{ USART3, sizeof(UART3_BufferRecv), UART3_BufferRecv, 0, 0, sizeof(UART3_BufferSend), UART3_BufferSend, 0, 0 };
static unsigned char UART2_BufferRecv[UART_BuferSize], UART2_BufferSend[UART_BuferSize];
static UART_Data UART2_Data{ USART2, sizeof(UART2_BufferRecv), UART2_BufferRecv, 0, 0, sizeof(UART2_BufferSend), UART2_BufferSend, 0, 0 };
static unsigned char UART1_BufferRecv[UART_BuferSize], UART1_BufferSend[UART_BuferSize];
static UART_Data UART1_Data{ USART1, sizeof(UART1_BufferRecv), UART1_BufferRecv, 0, 0, sizeof(UART1_BufferSend), UART1_BufferSend, 0, 0 };
static void IRQHandler(UART_Data& Uart)
{
unsigned long isr = Uart.UART->ISR;
if (isr & USART_ISR_RXNE)
{
Uart.Recv.Buffer[Uart.Recv.Head % Uart.Recv.Size] = Uart.UART->RDR;
if (Uart.Recv.Head < Uart.Recv.Tail + Uart.Recv.Size) Uart.Recv.Head++;
}
if (isr & USART_ISR_TXE)
{
if (Uart.Send.Tail != Uart.Send.Head)
{
Uart.UART->TDR = Uart.Send.Buffer[Uart.Send.Tail % Uart.Send.Size];
Uart.Send.Tail++;
}
else Uart.UART->CR1 &= ~USART_CR1_TXEIE;
}
}
//------------------------------------------------------------------------------
extern "C" void USART3_IRQHandler()
{
IRQHandler(UART3_Data);
}
//------------------------------------------------------------------------------
extern "C" void USART2_IRQHandler()
{
IRQHandler(UART2_Data);
}
//------------------------------------------------------------------------------
extern "C" void USART1_IRQHandler()
{
IRQHandler(UART1_Data);
}
//------------------------------------------------------------------------------
static void Init(USART_TypeDef* USART, unsigned long Baud)
{
USART->CR1 = 0;
USART->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_RXNEIE;
//USART->BRR = SystemCoreClock / 4 / Baud;
USART->BRR = SystemCoreClock / Baud;
USART->CR3 |= USART_CR3_OVRDIS;
USART->CR1 |= USART_CR1_UE;
}
//------------------------------------------------------------------------------
void UART3_Init(unsigned long Baud)
{
if (RCC->APB1ENR1 & RCC_APB1ENR1_USART3EN) return;
RCC->APB1ENR1 |= RCC_APB1ENR1_USART3EN;
GPIO_InitPin(GPIO_PIN_10 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
GPIO_InitPin(GPIO_PIN_11 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
Init(USART3, Baud);
NVIC_SetPriority(USART3_IRQn, 0);
NVIC_EnableIRQ(USART3_IRQn);
}
//------------------------------------------------------------------------------
void UART2_Init(unsigned long Baud)
{
if (RCC->APB1ENR1 & RCC_APB1ENR1_USART2EN) return;
RCC->APB1ENR1 |= RCC_APB1ENR1_USART2EN;
GPIO_InitPin(GPIO_PIN_3 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
GPIO_InitPin(GPIO_PIN_4 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
Init(USART2, Baud);
NVIC_SetPriority(USART2_IRQn, 0);
NVIC_EnableIRQ(USART2_IRQn);
}
//------------------------------------------------------------------------------
void UART1_Init(unsigned long Baud)
{
if (RCC->APB2ENR & RCC_APB2ENR_USART1EN) return;
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
GPIO_InitPin(GPIO_PIN_6 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
GPIO_InitPin(GPIO_PIN_7 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
Init(USART1, Baud);
NVIC_SetPriority(USART1_IRQn, 0);
NVIC_EnableIRQ(USART1_IRQn);
}
//------------------------------------------------------------------------------
static unsigned long Recv(UART_Data& Uart, void* Data, unsigned long Size)
{
if(!Data) return Uart.Recv.Head-Uart.Recv.Tail;
unsigned char* data=(unsigned char*)Data;
unsigned long size = 0;
while (size < Size)
{
if (Uart.Recv.Tail == Uart.Recv.Head) break;
data[size++] = Uart.Recv.Buffer[Uart.Recv.Tail % Uart.Recv.Size];
Uart.Recv.Tail++;
}
return size;
}
//------------------------------------------------------------------------------
static unsigned long Send(UART_Data& Uart, const void* Data, unsigned long Size)
{
unsigned char* data=(unsigned char*)Data;
unsigned long size = 0;
while (size < Size)
{
if (Uart.Send.Head - Uart.Send.Tail >= Uart.Send.Size) break;
Uart.Send.Buffer[Uart.Send.Head % Uart.Send.Size] = data[size++];
Uart.Send.Head++;
}
Uart.UART->CR1 |= USART_CR1_TXEIE;
return size;
}
//------------------------------------------------------------------------------
static inline void Flush(UART_Data& Uart)
{
Uart.Recv.Tail=Uart.Recv.Head;
}
//------------------------------------------------------------------------------
unsigned long UART3_Recv(void* Data, unsigned long Size)
{
return Recv(UART3_Data, Data, Size);
}
//------------------------------------------------------------------------------
void UART3_Flush()
{
Flush(UART3_Data);
}
//------------------------------------------------------------------------------
unsigned long UART3_Send(const void* Data, unsigned long Size)
{
return Send(UART3_Data, Data, Size);
}
//------------------------------------------------------------------------------
unsigned long UART2_Recv(void* Data, unsigned long Size)
{
return Recv(UART2_Data, Data, Size);
}
//------------------------------------------------------------------------------
void UART2_Flush()
{
Flush(UART2_Data);
}
//------------------------------------------------------------------------------
unsigned long UART2_Send(const void* Data, unsigned long Size)
{
return Send(UART2_Data, Data, Size);
}
//------------------------------------------------------------------------------
unsigned long UART1_Recv(void* Data, unsigned long Size)
{
return Recv(UART1_Data, Data, Size);
}
//------------------------------------------------------------------------------
void UART1_Flush()
{
Flush(UART1_Data);
}
//------------------------------------------------------------------------------
unsigned long UART1_Send(const void* Data, unsigned long Size)
{
return Send(UART1_Data, Data, Size);
}
//------------------------------------------------------------------------------

237
drv/uart копия2.cpp Normal file
View File

@ -0,0 +1,237 @@
#include "stm32g4xx.h"
#include <string.h>
#include "gpio.h"
#include "uart.h"
static const unsigned long UART_BuferSize=256;
struct UART_Data
{
USART_TypeDef* UART;
struct
{
unsigned long Size;
unsigned char* Buffer;
unsigned short Head;
unsigned short Tail;
unsigned short Push;
unsigned short Pull;
} Recv, Send;
};
static unsigned char UART3_BufferRecv[UART_BuferSize], UART3_BufferSend[UART_BuferSize];
static UART_Data UART3_Data{ USART3, {sizeof(UART3_BufferRecv), UART3_BufferRecv, 0, 0, 0, 0}, {sizeof(UART3_BufferSend), UART3_BufferSend, 0, 0, 0, 0} };
static unsigned char UART2_BufferRecv[UART_BuferSize], UART2_BufferSend[UART_BuferSize];
static UART_Data UART2_Data{ USART2, {sizeof(UART2_BufferRecv), UART2_BufferRecv, 0, 0, 0, 0}, {sizeof(UART2_BufferSend), UART2_BufferSend, 0, 0, 0, 0} };
static unsigned char UART1_BufferRecv[UART_BuferSize], UART1_BufferSend[UART_BuferSize];
static UART_Data UART1_Data{ USART1, {sizeof(UART1_BufferRecv), UART1_BufferRecv, 0, 0, 0, 0}, {sizeof(UART1_BufferSend), UART1_BufferSend, 0, 0, 0, 0} };
static void IRQHandler(UART_Data& Uart)
{
unsigned long isr = Uart.UART->ISR;
if(isr & USART_ISR_RXNE)
{
Uart.Recv.Buffer[Uart.Recv.Head] = Uart.UART->RDR;
if(Uart.Recv.Push-Uart.Recv.Pull<Uart.Recv.Size)
{
Uart.Recv.Head++;
Uart.Recv.Push++;
}
if(Uart.Recv.Head>=Uart.Recv.Size) Uart.Recv.Head=0;
}
if(isr & USART_ISR_TXE)
{
if(Uart.Send.Push != Uart.Send.Pull)
{
Uart.UART->TDR = Uart.Send.Buffer[Uart.Send.Tail++];
if(Uart.Send.Tail>=Uart.Send.Size) Uart.Send.Tail=0;
Uart.Send.Pull++;
}
else Uart.UART->CR1 &= ~USART_CR1_TXEIE;
}
}
//------------------------------------------------------------------------------
extern "C" void USART3_IRQHandler()
{
IRQHandler(UART3_Data);
}
//------------------------------------------------------------------------------
extern "C" void USART2_IRQHandler()
{
IRQHandler(UART2_Data);
}
//------------------------------------------------------------------------------
extern "C" void USART1_IRQHandler()
{
IRQHandler(UART1_Data);
}
//------------------------------------------------------------------------------
static void Init(USART_TypeDef* USART, unsigned long Baud)
{
USART->CR1 = 0;
USART->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_RXNEIE;
//USART->BRR = SystemCoreClock / 4 / Baud;
USART->BRR = SystemCoreClock / Baud;
USART->CR3 |= USART_CR3_OVRDIS;
USART->CR1 |= USART_CR1_UE;
}
//------------------------------------------------------------------------------
void UART3_Init(unsigned long Baud)
{
if (RCC->APB1ENR1 & RCC_APB1ENR1_USART3EN) return;
RCC->APB1ENR1 |= RCC_APB1ENR1_USART3EN;
GPIO_InitPin(GPIO_PIN_10 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
GPIO_InitPin(GPIO_PIN_11 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
Init(USART3, Baud);
NVIC_SetPriority(USART3_IRQn, 0);
NVIC_EnableIRQ(USART3_IRQn);
}
//------------------------------------------------------------------------------
void UART2_Init(unsigned long Baud)
{
if (RCC->APB1ENR1 & RCC_APB1ENR1_USART2EN) return;
RCC->APB1ENR1 |= RCC_APB1ENR1_USART2EN;
GPIO_InitPin(GPIO_PIN_3 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
GPIO_InitPin(GPIO_PIN_4 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
Init(USART2, Baud);
NVIC_SetPriority(USART2_IRQn, 0);
NVIC_EnableIRQ(USART2_IRQn);
}
//------------------------------------------------------------------------------
void UART1_Init(unsigned long Baud)
{
if (RCC->APB2ENR & RCC_APB2ENR_USART1EN) return;
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
GPIO_InitPin(GPIO_PIN_6 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
GPIO_InitPin(GPIO_PIN_7 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
Init(USART1, Baud);
NVIC_SetPriority(USART1_IRQn, 0);
NVIC_EnableIRQ(USART1_IRQn);
}
//------------------------------------------------------------------------------
static unsigned long Recv(UART_Data& Uart, void* Data, unsigned long Size)
{
if(!Data) return Uart.Recv.Push-Uart.Recv.Pull;
unsigned char* data=(unsigned char*)Data;
unsigned long size = 0;
while (size < Size)
{
if (Uart.Recv.Push == Uart.Recv.Pull) break;
data[size++] = Uart.Recv.Buffer[Uart.Recv.Tail++];
if(Uart.Recv.Tail>=Uart.Recv.Size) Uart.Recv.Tail=0;
Uart.Recv.Pull++;
}
return size;
}
//------------------------------------------------------------------------------
static unsigned long Send(UART_Data& Uart, const void* Data, unsigned long Size)
{
unsigned char* data=(unsigned char*)Data;
unsigned long size = 0;
while (size < Size)
{
if (Uart.Send.Push - Uart.Send.Pull >= Uart.Send.Size) break;
Uart.Send.Buffer[Uart.Send.Head++] = data[size++];
if(Uart.Send.Head>=Uart.Send.Size) Uart.Send.Head=0;
Uart.Send.Push++;
}
Uart.UART->CR1 |= USART_CR1_TXEIE;
return size;
}
//------------------------------------------------------------------------------
static inline void Flush(UART_Data& Uart)
{
Uart.Recv.Tail=Uart.Recv.Head;
Uart.Recv.Pull=Uart.Recv.Push;
}
//------------------------------------------------------------------------------
unsigned long UART3_Recv(void* Data, unsigned long Size)
{
return Recv(UART3_Data, Data, Size);
}
//------------------------------------------------------------------------------
void UART3_Flush()
{
Flush(UART3_Data);
}
//------------------------------------------------------------------------------
unsigned long UART3_Send(const void* Data, unsigned long Size)
{
return Send(UART3_Data, Data, Size);
}
//------------------------------------------------------------------------------
unsigned long UART2_Recv(void* Data, unsigned long Size)
{
return Recv(UART2_Data, Data, Size);
}
//------------------------------------------------------------------------------
void UART2_Flush()
{
Flush(UART2_Data);
}
//------------------------------------------------------------------------------
unsigned long UART2_Send(const void* Data, unsigned long Size)
{
return Send(UART2_Data, Data, Size);
}
//------------------------------------------------------------------------------
unsigned long UART1_Recv(void* Data, unsigned long Size)
{
return Recv(UART1_Data, Data, Size);
}
//------------------------------------------------------------------------------
void UART1_Flush()
{
Flush(UART1_Data);
}
//------------------------------------------------------------------------------
unsigned long UART1_Send(const void* Data, unsigned long Size)
{
return Send(UART1_Data, Data, Size);
}
//------------------------------------------------------------------------------

276
drv/uart.cpp Normal file
View File

@ -0,0 +1,276 @@
#include "stm32g4xx.h"
#include <string.h>
#include "gpio.h"
#include "uart.h"
static const unsigned long UART_BuferSize=256+1;
struct UART_Data
{
USART_TypeDef* UART;
struct
{
unsigned long Size;
unsigned char* Buffer;
unsigned short Head;
unsigned short Tail;
bool Overflow;
} Recv, Send;
};
static unsigned char UART3_BufferRecv[UART_BuferSize], UART3_BufferSend[UART_BuferSize];
static UART_Data UART3_Data { USART3, {sizeof(UART3_BufferRecv), UART3_BufferRecv, 0, 0, false}, {sizeof(UART3_BufferSend), UART3_BufferSend, 0, 0, false} };
static unsigned char UART2_BufferRecv[UART_BuferSize], UART2_BufferSend[UART_BuferSize];
static UART_Data UART2_Data { USART2, {sizeof(UART2_BufferRecv), UART2_BufferRecv, 0, 0, false}, {sizeof(UART2_BufferSend), UART2_BufferSend, 0, 0, false} };
static unsigned char UART1_BufferRecv[UART_BuferSize], UART1_BufferSend[UART_BuferSize];
static UART_Data UART1_Data { USART1, {sizeof(UART1_BufferRecv), UART1_BufferRecv, 0, 0, false}, {sizeof(UART1_BufferSend), UART1_BufferSend, 0, 0, false} };
static unsigned char LPUART1_BufferRecv[UART_BuferSize], LPUART1_BufferSend[UART_BuferSize];
static UART_Data LPUART1_Data { LPUART1, {sizeof(LPUART1_BufferRecv), LPUART1_BufferRecv, 0, 0, false}, {sizeof(LPUART1_BufferSend), LPUART1_BufferSend, 0, 0, false} };
static void IRQHandler(UART_Data& Uart)
{
unsigned long isr = Uart.UART->ISR;
if(isr & USART_ISR_RXNE)
{
Uart.Recv.Buffer[Uart.Recv.Head++] = Uart.UART->RDR;
if(Uart.Recv.Head>=Uart.Recv.Size) Uart.Recv.Head=0;
if(Uart.Recv.Head==Uart.Recv.Tail) Uart.Recv.Overflow=true;
}
if(isr & USART_ISR_TXE)
{
if(Uart.Send.Head != Uart.Send.Tail)
{
Uart.UART->TDR = Uart.Send.Buffer[Uart.Send.Tail++];
if(Uart.Send.Tail>=Uart.Send.Size) Uart.Send.Tail=0;
}
else Uart.UART->CR1 &= ~USART_CR1_TXEIE;
}
}
//------------------------------------------------------------------------------
extern "C" void USART3_IRQHandler()
{
IRQHandler(UART3_Data);
}
//------------------------------------------------------------------------------
extern "C" void USART2_IRQHandler()
{
IRQHandler(UART2_Data);
}
//------------------------------------------------------------------------------
extern "C" void USART1_IRQHandler()
{
IRQHandler(UART1_Data);
}
//------------------------------------------------------------------------------
extern "C" void LPUART1_IRQHandler()
{
IRQHandler(LPUART1_Data);
}
//------------------------------------------------------------------------------
static void Init(USART_TypeDef* USART, unsigned long Freq, unsigned long Baud)
{
USART->CR1 = 0;
USART->CR1 = USART_CR1_TE | USART_CR1_RE | USART_CR1_RXNEIE;
USART->BRR = Freq / Baud;
USART->CR3 |= USART_CR3_OVRDIS;
USART->CR1 |= USART_CR1_UE;
}
//------------------------------------------------------------------------------
void UART3_Init(unsigned long Baud)
{
if (RCC->APB1ENR1 & RCC_APB1ENR1_USART3EN) return;
RCC->APB1ENR1 |= RCC_APB1ENR1_USART3EN;
GPIO_InitPin(GPIO_PIN_10 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
GPIO_InitPin(GPIO_PIN_11 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
Init(USART3, SystemCoreClock, Baud);
NVIC_SetPriority(USART3_IRQn, 0);
NVIC_EnableIRQ(USART3_IRQn);
}
//------------------------------------------------------------------------------
void UART2_Init(unsigned long Baud)
{
if (RCC->APB1ENR1 & RCC_APB1ENR1_USART2EN) return;
RCC->APB1ENR1 |= RCC_APB1ENR1_USART2EN;
GPIO_InitPin(GPIO_PIN_3 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
GPIO_InitPin(GPIO_PIN_4 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
Init(USART2, SystemCoreClock, Baud);
NVIC_SetPriority(USART2_IRQn, 0);
NVIC_EnableIRQ(USART2_IRQn);
}
//------------------------------------------------------------------------------
void UART1_Init(unsigned long Baud)
{
if (RCC->APB2ENR & RCC_APB2ENR_USART1EN) return;
RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
GPIO_InitPin(GPIO_PIN_6 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
GPIO_InitPin(GPIO_PIN_7 | GPIO_PORT_B | GPIO_ALTER | GPIO_AF7 | GPIO_OSPEED_HIGH);
Init(USART1, SystemCoreClock, Baud);
NVIC_SetPriority(USART1_IRQn, 0);
NVIC_EnableIRQ(USART1_IRQn);
}
//------------------------------------------------------------------------------
void LPUART1_Init(unsigned long Baud)
{
if (RCC->APB1ENR2 & RCC_APB1ENR2_LPUART1EN) return;
RCC->APB1ENR2 |= RCC_APB1ENR2_LPUART1EN;
GPIO_InitPin(GPIO_PIN_2 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF12 | GPIO_OSPEED_HIGH);
GPIO_InitPin(GPIO_PIN_3 | GPIO_PORT_A | GPIO_ALTER | GPIO_AF12 | GPIO_OSPEED_HIGH);
Init(LPUART1, SystemCoreClock, Baud/256);
NVIC_SetPriority(LPUART1_IRQn, 0);
NVIC_EnableIRQ(LPUART1_IRQn);
}
//------------------------------------------------------------------------------
static unsigned long Recv(UART_Data& Uart, void* Data, unsigned long Size)
{
if(!Data)
{
if(Uart.Recv.Tail<=Uart.Recv.Head) return Uart.Recv.Head-Uart.Recv.Tail;
return Uart.Recv.Size-Uart.Recv.Tail+Uart.Recv.Head;
}
unsigned char* data=(unsigned char*)Data;
unsigned long size = 0;
while (size < Size)
{
if (Uart.Recv.Head==Uart.Recv.Tail) break;
data[size++]=Uart.Recv.Buffer[Uart.Recv.Tail++];
if(Uart.Recv.Tail>=Uart.Recv.Size) Uart.Recv.Tail=0;
}
return size;
}
//------------------------------------------------------------------------------
static unsigned long Send(UART_Data& Uart, const void* Data, unsigned long Size)
{
unsigned char* data=(unsigned char*)Data;
unsigned long size = 0;
while (size < Size)
{
unsigned short head=Uart.Send.Head+1;
if(head>=Uart.Send.Size) head=0;
if (head == Uart.Send.Tail) { Uart.Send.Overflow=true; break; }
Uart.Send.Buffer[Uart.Send.Head] = data[size++];
Uart.Send.Head=head;
}
Uart.UART->CR1 |= USART_CR1_TXEIE;
return size;
}
//------------------------------------------------------------------------------
static inline void Flush(UART_Data& Uart)
{
Uart.Recv.Tail=Uart.Recv.Head=0;
}
//------------------------------------------------------------------------------
unsigned long UART3_Recv(void* Data, unsigned long Size)
{
return Recv(UART3_Data, Data, Size);
}
//------------------------------------------------------------------------------
void UART3_Flush()
{
Flush(UART3_Data);
}
//------------------------------------------------------------------------------
unsigned long UART3_Send(const void* Data, unsigned long Size)
{
return Send(UART3_Data, Data, Size);
}
//------------------------------------------------------------------------------
unsigned long UART2_Recv(void* Data, unsigned long Size)
{
return Recv(UART2_Data, Data, Size);
}
//------------------------------------------------------------------------------
void UART2_Flush()
{
Flush(UART2_Data);
}
//------------------------------------------------------------------------------
unsigned long UART2_Send(const void* Data, unsigned long Size)
{
return Send(UART2_Data, Data, Size);
}
//------------------------------------------------------------------------------
unsigned long UART1_Recv(void* Data, unsigned long Size)
{
return Recv(UART1_Data, Data, Size);
}
//------------------------------------------------------------------------------
void UART1_Flush()
{
Flush(UART1_Data);
}
//------------------------------------------------------------------------------
unsigned long UART1_Send(const void* Data, unsigned long Size)
{
return Send(UART1_Data, Data, Size);
}
//------------------------------------------------------------------------------
unsigned long LPUART1_Recv(void* Data, unsigned long Size)
{
return Recv(LPUART1_Data, Data, Size);
}
//------------------------------------------------------------------------------
void LPUART1_Flush()
{
Flush(LPUART1_Data);
}
//------------------------------------------------------------------------------
unsigned long LPUART1_Send(const void* Data, unsigned long Size)
{
return Send(LPUART1_Data, Data, Size);
}
//------------------------------------------------------------------------------

21
drv/uart.h Normal file
View File

@ -0,0 +1,21 @@
#pragma once
void UART3_Init(unsigned long Baud);
void UART3_Flush();
unsigned long UART3_Recv(void* Data, unsigned long Size);
unsigned long UART3_Send(const void* Data, unsigned long Size);
void UART2_Init(unsigned long Baud);
void UART2_Flush();
unsigned long UART2_Recv(void* Data, unsigned long Size);
unsigned long UART2_Send(const void* Data, unsigned long Size);
void UART1_Init(unsigned long Baud);
void UART1_Flush();
unsigned long UART1_Recv(void* Data, unsigned long Size);
unsigned long UART1_Send(const void* Data, unsigned long Size);
void LPUART1_Init(unsigned long Baud);
void LPUART1_Flush();
unsigned long LPUART1_Recv(void* Data, unsigned long Size);
unsigned long LPUART1_Send(const void* Data, unsigned long Size);