mirror of
https://gitee.com/Lyon1998/pikapython.git
synced 2025-01-22 17:12:55 +08:00
278 lines
8.0 KiB
C
278 lines
8.0 KiB
C
#include <stdint.h>
|
|
#include "BaseObj.h"
|
|
#include "STM32G0_GPIO.h"
|
|
#include "STM32G0_common.h"
|
|
#include "dataStrs.h"
|
|
#include "pika_hal.h"
|
|
|
|
typedef struct platform_data_GPIO {
|
|
GPIO_TypeDef* gpioPort;
|
|
uint16_t gpioPin;
|
|
uint32_t pinMode;
|
|
uint32_t gpioPull;
|
|
} platform_data_GPIO;
|
|
|
|
int pika_hal_platform_GPIO_open(pika_dev* dev, char* name) {
|
|
__platform_printf("Open: %s \r\n", name);
|
|
GPIO_TypeDef* gpioPort = GPIO_get_Group(name);
|
|
if (NULL == gpioPort) {
|
|
__platform_printf("Error: get GPIO group failed.\r\n");
|
|
return -1;
|
|
}
|
|
uint16_t gpioPin = GPIO_get_pin(name);
|
|
if (0 == gpioPin) {
|
|
__platform_printf("Error: get GPIO Pin failed.\r\n");
|
|
return -1;
|
|
}
|
|
platform_data_GPIO* data = pikaMalloc(sizeof(platform_data_GPIO));
|
|
data->gpioPin = gpioPin;
|
|
data->gpioPort = gpioPort;
|
|
dev->platform_data = data;
|
|
return 0;
|
|
}
|
|
|
|
int pika_hal_platform_GPIO_close(pika_dev* dev) {
|
|
if (NULL != dev->platform_data) {
|
|
pikaFree(dev->platform_data, sizeof(platform_data_GPIO));
|
|
dev->platform_data = NULL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int pika_hal_platform_GPIO_read(pika_dev* dev, void* buf, size_t count) {
|
|
platform_data_GPIO* data = dev->platform_data;
|
|
uint32_t level = LL_GPIO_IsInputPinSet(data->gpioPort, data->gpioPin);
|
|
if (level != 1 && level != 0) {
|
|
return -1;
|
|
}
|
|
memcpy(buf, &level, count);
|
|
return 0;
|
|
}
|
|
|
|
int pika_hal_platform_GPIO_write(pika_dev* dev, void* buf, size_t count) {
|
|
platform_data_GPIO* data = dev->platform_data;
|
|
uint32_t level = 0;
|
|
memcpy(&level, buf, count);
|
|
if (level == 0) {
|
|
LL_GPIO_ResetOutputPin(data->gpioPort, data->gpioPin);
|
|
return 0;
|
|
}
|
|
if (level == 1) {
|
|
LL_GPIO_SetOutputPin(data->gpioPort, data->gpioPin);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int _enable_gpio_clk(GPIO_TypeDef* gpio_group) {
|
|
if (gpio_group == GPIOA) {
|
|
__HAL_RCC_GPIOA_CLK_ENABLE();
|
|
return 0;
|
|
}
|
|
if (gpio_group == GPIOB) {
|
|
__HAL_RCC_GPIOB_CLK_ENABLE();
|
|
return 0;
|
|
}
|
|
if (gpio_group == GPIOC) {
|
|
__HAL_RCC_GPIOC_CLK_ENABLE();
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int pika_hal_platform_GPIO_ioctl_enable(pika_dev* dev) {
|
|
platform_data_GPIO* data = dev->platform_data;
|
|
|
|
if (0 != _enable_gpio_clk(data->gpioPort)) {
|
|
return -1;
|
|
}
|
|
|
|
/*Configure GPIO pin Output Level */
|
|
LL_GPIO_ResetOutputPin(data->gpioPort, data->gpioPin);
|
|
|
|
LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
|
|
/*Configure GPIO*/
|
|
GPIO_InitStruct.Pin = data->gpioPin;
|
|
GPIO_InitStruct.Mode = data->pinMode;
|
|
GPIO_InitStruct.Pull = data->gpioPull;
|
|
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
|
|
LL_GPIO_Init(data->gpioPort, &GPIO_InitStruct);
|
|
return 0;
|
|
}
|
|
|
|
int pika_hal_platform_GPIO_ioctl_disable(pika_dev* dev) {
|
|
platform_data_GPIO* data = dev->platform_data;
|
|
LL_GPIO_DeInit(data->gpioPort);
|
|
return 0;
|
|
}
|
|
|
|
int pika_hal_platform_GPIO_ioctl_config(pika_dev* dev,
|
|
pika_hal_GPIO_config* cfg) {
|
|
platform_data_GPIO* data = dev->platform_data;
|
|
switch (cfg->dir) {
|
|
case PIKA_HAL_GPIO_DIR_IN:
|
|
data->pinMode = LL_GPIO_MODE_INPUT;
|
|
case PIKA_HAL_GPIO_DIR_OUT:
|
|
data->pinMode = LL_GPIO_MODE_OUTPUT;
|
|
default:
|
|
data->pinMode = LL_GPIO_MODE_OUTPUT;
|
|
}
|
|
switch (cfg->pull) {
|
|
case PIKA_HAL_GPIO_PULL_UP:
|
|
data->gpioPull = LL_GPIO_PULL_UP;
|
|
case PIKA_HAL_GPIO_PULL_DOWN:
|
|
data->gpioPull = LL_GPIO_PULL_DOWN;
|
|
default:
|
|
data->gpioPull = LL_GPIO_PULL_NO;
|
|
}
|
|
LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
|
|
/*Configure GPIO*/
|
|
GPIO_InitStruct.Pin = data->gpioPin;
|
|
GPIO_InitStruct.Mode = data->pinMode;
|
|
GPIO_InitStruct.Pull = data->gpioPull;
|
|
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
|
|
LL_GPIO_Init(data->gpioPort, &GPIO_InitStruct);
|
|
return 0;
|
|
}
|
|
|
|
typedef struct platform_data_SPI {
|
|
SPI_HandleTypeDef* hspi;
|
|
pika_dev* cs;
|
|
} platform_data_SPI;
|
|
|
|
SPI_HandleTypeDef hspi1;
|
|
DMA_HandleTypeDef hdma_spi1_tx;
|
|
|
|
platform_data_SPI platform_data_SPI_spi1 = {
|
|
.hspi = &hspi1,
|
|
};
|
|
|
|
int pika_hal_platform_SPI_open(pika_dev* dev, char* name) {
|
|
if (strEqu(name, "spi1")) {
|
|
dev->platform_data = &platform_data_SPI_spi1;
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int pika_hal_platform_SPI_ioctl_config(pika_dev* dev,
|
|
pika_hal_SPI_config* cfg) {
|
|
return -1;
|
|
}
|
|
|
|
#define SPI_DMA
|
|
|
|
void MX_SPI1_Init(void) {
|
|
hspi1.Instance = SPI1;
|
|
hspi1.Init.Mode = SPI_MODE_MASTER;
|
|
hspi1.Init.Direction = SPI_DIRECTION_1LINE;
|
|
hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
|
|
hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
|
|
hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
|
|
hspi1.Init.NSS = SPI_NSS_SOFT;
|
|
hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
|
|
hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
|
|
hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
|
|
hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
|
|
hspi1.Init.CRCPolynomial = 10;
|
|
hspi1.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
|
|
hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
|
|
HAL_SPI_Init(&hspi1);
|
|
}
|
|
|
|
static void MX_DMA_Init(void) {
|
|
/* DMA controller clock enable */
|
|
__HAL_RCC_DMA1_CLK_ENABLE();
|
|
|
|
/* DMA interrupt init */
|
|
/* DMA1_Channel1_IRQn interrupt configuration */
|
|
HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
|
|
HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
|
|
}
|
|
|
|
void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi) {
|
|
GPIO_InitTypeDef GPIO_InitStruct = {0};
|
|
__HAL_RCC_SPI1_CLK_ENABLE();
|
|
__HAL_RCC_GPIOA_CLK_ENABLE();
|
|
GPIO_InitStruct.Pin = GPIO_PIN_1 | GPIO_PIN_2;
|
|
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
|
|
GPIO_InitStruct.Pull = GPIO_NOPULL;
|
|
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
|
|
GPIO_InitStruct.Alternate = GPIO_AF0_SPI1;
|
|
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
|
|
hdma_spi1_tx.Instance = DMA1_Channel1;
|
|
hdma_spi1_tx.Init.Request = DMA_REQUEST_SPI1_TX;
|
|
hdma_spi1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
|
|
hdma_spi1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
|
|
hdma_spi1_tx.Init.MemInc = DMA_MINC_ENABLE;
|
|
hdma_spi1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
|
|
hdma_spi1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
|
|
hdma_spi1_tx.Init.Mode = DMA_NORMAL;
|
|
hdma_spi1_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
|
|
HAL_DMA_Init(&hdma_spi1_tx);
|
|
__HAL_LINKDMA(hspi, hdmatx, hdma_spi1_tx);
|
|
}
|
|
|
|
void DMA1_Channel1_IRQHandler(void) {
|
|
HAL_DMA_IRQHandler(&hdma_spi1_tx);
|
|
}
|
|
|
|
int pika_hal_platform_SPI_ioctl_enable(pika_dev* dev) {
|
|
platform_data_SPI* data = dev->platform_data;
|
|
/* init GPIO CS */
|
|
data->cs = pika_hal_open(PIKA_HAL_GPIO, "PB1");
|
|
pika_hal_GPIO_config cfg = {
|
|
.dir = PIKA_HAL_GPIO_DIR_OUT,
|
|
.pull = PIKA_HAL_GPIO_PULL_NONE,
|
|
};
|
|
pika_hal_ioctl(data->cs, PIKA_HAL_IOCTL_CONFIG, &cfg);
|
|
uint32_t val = 0;
|
|
pika_hal_write(data->cs, &val, sizeof(val));
|
|
/* init SPI */
|
|
#ifndef SPI_SOFT
|
|
MX_DMA_Init();
|
|
MX_SPI1_Init();
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
int pika_hal_platform_SPI_read(pika_dev* dev, void* buf, size_t count) {
|
|
return -1;
|
|
}
|
|
|
|
int pika_hal_platform_SPI_write(pika_dev* dev, void* buf, size_t count) {
|
|
#ifdef SPI_SOFT
|
|
for (int i = 0; i < size; i++) {
|
|
SPI_Write_u8(pData[i]);
|
|
}
|
|
#else
|
|
#ifdef SPI_DMA
|
|
/* wait spi ready */
|
|
while (hspi1.hdmatx->State != HAL_DMA_STATE_READY ||
|
|
hspi1.State != HAL_SPI_STATE_READY) {
|
|
};
|
|
HAL_SPI_Transmit_DMA(&hspi1, (uint8_t*)buf, count);
|
|
/* wait spi ready */
|
|
while (hspi1.hdmatx->State != HAL_DMA_STATE_READY ||
|
|
hspi1.State != HAL_SPI_STATE_READY) {
|
|
};
|
|
#else
|
|
HAL_SPI_Transmit(&hspi1, pData, size, HAL_MAX_DELAY);
|
|
#endif
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
int pika_hal_platform_SPI_ioctl_disable(pika_dev* dev) {
|
|
platform_data_SPI* data = dev->platform_data;
|
|
uint32_t val = 1;
|
|
pika_hal_write(data->cs, &val, sizeof(val));
|
|
return 0;
|
|
}
|
|
|
|
int pika_hal_platform_SPI_close(pika_dev* dev) {
|
|
platform_data_SPI* data = dev->platform_data;
|
|
pika_hal_close(data->cs);
|
|
return 0;
|
|
}
|