Embedded/pikapython
1
0
Fork 0
mirror of https://gitee.com/Lyon1998/pikapython.git synced 2025-01-15 17:02:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

add pika_config.c

Browse Source
This commit is contained in:
pikastech 2021-12-01 10:16:35 +08:00
parent 6b89cf9502
commit 1de1badf50
2 changed files with 431 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

367
package/STM32G030Booter/pika_config.c Normal file
View File

@ -0,0 +1,367 @@
#include "pika_config.h"
#include "main.h"
/* support printf */
void HARDWARE_PRINTF_Init(void) {
LL_USART_InitTypeDef USART_InitStruct = {0};
LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
/* Peripheral clock enable */
LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_USART1);
LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);
/**USART1 GPIO Configuration
PA9 ------> USART1_TX
PA10 ------> USART1_RX
*/
GPIO_InitStruct.Pin = LL_GPIO_PIN_9;
GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
GPIO_InitStruct.Alternate = LL_GPIO_AF_1;
LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
GPIO_InitStruct.Pin = LL_GPIO_PIN_10;
GPIO_InitStruct.Mode = LL_GPIO_MODE_ALTERNATE;
GPIO_InitStruct.Speed = LL_GPIO_SPEED_FREQ_LOW;
GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
GPIO_InitStruct.Alternate = LL_GPIO_AF_1;
LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* USART1 interrupt Init */
NVIC_SetPriority(USART1_IRQn, 0);
NVIC_EnableIRQ(USART1_IRQn);
USART_InitStruct.PrescalerValue = LL_USART_PRESCALER_DIV1;
USART_InitStruct.BaudRate = 115200;
USART_InitStruct.DataWidth = LL_USART_DATAWIDTH_8B;
USART_InitStruct.StopBits = LL_USART_STOPBITS_1;
USART_InitStruct.Parity = LL_USART_PARITY_NONE;
USART_InitStruct.TransferDirection = LL_USART_DIRECTION_TX_RX;
USART_InitStruct.HardwareFlowControl = LL_USART_HWCONTROL_NONE;
USART_InitStruct.OverSampling = LL_USART_OVERSAMPLING_16;
LL_USART_Init(USART1, &USART_InitStruct);
LL_USART_SetTXFIFOThreshold(USART1, LL_USART_FIFOTHRESHOLD_1_8);
LL_USART_SetRXFIFOThreshold(USART1, LL_USART_FIFOTHRESHOLD_1_8);
LL_USART_DisableFIFO(USART1);
LL_USART_ConfigAsyncMode(USART1);
LL_USART_Enable(USART1);
/* Polling USART1 initialisation */
while ((!(LL_USART_IsActiveFlag_TEACK(USART1))) ||
(!(LL_USART_IsActiveFlag_REACK(USART1)))) {
}
/* open interrupt */
LL_USART_EnableIT_RXNE(USART1);
LL_USART_EnableIT_PE(USART1);
}
#pragma import(__use_no_semihosting)
void _sys_exit(int x) {
x = x;
}
struct __FILE{
int handle;
};
FILE __stdout;
int fputc(int ch, FILE* f) {
LL_USART_TransmitData8(USART1, ch);
while (LL_USART_IsActiveFlag_TC(USART1) != 1)
;
return ch;
}
/* support delay_us */
void delay_us(uint32_t udelay) {
uint32_t startval, tickn, delays, wait;
startval = SysTick->VAL;
tickn = HAL_GetTick();
delays = udelay * 64; // delay 1us when delays = 64
if (delays > startval) {
while (HAL_GetTick() == tickn) {
}
wait = 64000 + startval - delays;
while (wait < SysTick->VAL) {
}
} else {
wait = startval - delays;
while (wait < SysTick->VAL && HAL_GetTick() == tickn) {
}
}
}
/* support pika Asm to flash */
uint32_t globalWriteAddress = 0;
uint32_t GetPage(uint32_t Addr) {
return (Addr - FLASH_BASE) / FLASH_PAGE_SIZE;
}
int32_t __eriseSelecttedFlash(uint32_t flashStart, uint32_t flashEnd) {
uint32_t FirstPage = 0, NbOfPages = 0;
uint32_t PageError = 0;
__IO uint32_t data32 = 0, MemoryProgramStatus = 0;
static FLASH_EraseInitTypeDef EraseInitStruct = {0};
HAL_FLASH_Unlock();
/* Get the 1st page to erase */
FirstPage = GetPage(flashStart);
/* Get the number of pages to erase from 1st page */
NbOfPages = GetPage(flashEnd) - FirstPage + 1;
/* Fill EraseInit structure*/
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
EraseInitStruct.Page = FirstPage;
EraseInitStruct.NbPages = NbOfPages;
if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK) {
return 1;
}
return 0;
}
uint32_t flash_write_char(uint32_t bassAddr,
uint32_t flash_addr,
char ch_input) {
static uint8_t writeBuff[8] = {0};
static uint8_t offset = 0;
if (offset > 7) {
offset = 0;
uint64_t writeData64 = 0;
for (int i = 7; i >= 0; i--) {
char ch = writeBuff[i];
writeData64 = writeData64 << 8;
writeData64 += ch;
}
__platformDisableIrqHandle();
if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD,
bassAddr + flash_addr, writeData64) != HAL_OK) {
while (1) {
offset = 0;
}
}
__platformDisableIrqHandle();
flash_addr = flash_addr + 8;
}
writeBuff[offset] = ch_input;
offset++;
return flash_addr;
}
uint8_t __platformAsmIsToFlash(char* pyMultiLine) {
if (strCountSign(pyMultiLine, '\n') > 1) {
return 1;
}
return 0;
}
int32_t __saveStrToFlash(char* str,
uint32_t flashStart,
uint32_t flashEnd,
uint32_t* writeAddress_p) {
uint32_t size = strGetSize(str);
for (int i = 0; i < size; i++) {
(*writeAddress_p) =
flash_write_char(flashStart, (*writeAddress_p), str[i]);
}
return 0;
}
char* __platformLoadPikaAsm() {
return (char*)FLASH_PIKA_ASM_START_ADDR;
}
int32_t __platformSavePikaAsm(char* PikaAsm) {
if (0 == globalWriteAddress) {
__eriseSelecttedFlash(FLASH_PIKA_ASM_START_ADDR,
FLASH_PIKA_ASM_END_ADDR);
}
return __saveStrToFlash(PikaAsm, FLASH_PIKA_ASM_START_ADDR,
FLASH_PIKA_ASM_END_ADDR, &globalWriteAddress);
}
int32_t __platformSavePikaAsmEOF() {
for (int i = 0; i < 16; i++) {
globalWriteAddress = flash_write_char(FLASH_PIKA_ASM_START_ADDR,
globalWriteAddress, '\0');
}
return 0;
}
/* support mem pool */
#if use_mem_pool
/* use mem pool */
Pool pikaPool;
void* __impl_pikaMalloc(size_t size) {
void* mem = pool_malloc(&pikaPool, size);
return mem;
}
void __impl_pikaFree(void* ptrm, size_t size) {
pool_free(&pikaPool, ptrm, size);
}
#endif
/* support download python script by uart1 */
uint8_t pika_memory_lock = 0;
uint8_t __isLocked_pikaMemory(void){
return pika_memory_lock;
}
CodeHeap codeHeap;
void STM32_Code_Init(void) {
codeHeap.size = 0;
codeHeap.content = pikaMalloc(codeHeap.size + 1);
codeHeap.ena = 0;
}
uint8_t STM32_Code_reciveHandler(char* data, uint32_t rxSize) {
char buff[RX_BUFF_LENGTH] = {0};
if (0 == codeHeap.ena) {
char* strLine = strGetLastLine(buff, data);
if (strIsStartWith(strLine, "import ")) {
codeHeap.reciveTime = uwTick;
codeHeap.ena = 1;
data = strLine;
}
}
if (1 == codeHeap.ena) {
if(!pika_memory_lock){
pika_memory_lock = 1;
#if use_mem_pool
__platformDisableIrqHandle();
pool_deinit(&pikaPool);
__platformEnableIrqHandle();
#endif
}
codeHeap.reciveTime = uwTick;
codeHeap.oldSize = codeHeap.size;
codeHeap.size += rxSize;
codeHeap.content = realloc(codeHeap.content, codeHeap.size + 1);
memcpy(codeHeap.content + codeHeap.oldSize, data, rxSize);
codeHeap.content[codeHeap.size] = 0;
/* reciving code */
return 1;
}
/* not work */
return 0;
}
void STM32_Code_flashHandler(void) {
if (!codeHeap.ena) {
/* recive not activate */
return;
}
if (uwTick - codeHeap.reciveTime < 200) {
/* still reciving */
return;
}
/* transmite is finished */
STM32_Code_reciveHandler("\n\n", 2);
uint32_t FirstPage = 0, NbOfPages = 0;
uint32_t PageError = 0;
__IO uint32_t data32 = 0, MemoryProgramStatus = 0;
static FLASH_EraseInitTypeDef EraseInitStruct = {0};
printf("==============[Programer]==============\r\n");
printf("[info]: Recived byte: %d\r\n", codeHeap.size);
printf("[info]: Programing... \r\n");
HAL_FLASH_Unlock();
/* Get the 1st page to erase */
FirstPage = GetPage(FLASH_SCRIPT_START_ADDR);
/* Get the number of pages to erase from 1st page */
NbOfPages = GetPage(FLASH_SCRIPT_END_ADDR) - FirstPage + 1;
/* Fill EraseInit structure*/
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
EraseInitStruct.Page = FirstPage;
EraseInitStruct.NbPages = NbOfPages;
printf("[info]: Erasing flash... \r\n");
if (HAL_FLASHEx_Erase(&EraseInitStruct, &PageError) != HAL_OK) {
printf("[error]: Erase faild! \r\n");
while (1) {
}
}
printf("[ OK ]: Erase flash ok! \r\n");
printf("[info]: Writing flash... \r\n");
uint32_t baseAddress = FLASH_SCRIPT_START_ADDR;
uint32_t writeAddress = 0;
uint64_t writeData64 = 0;
while (writeAddress < codeHeap.size + 1) {
writeData64 = 0;
for (int i = 7; i >= 0; i--) {
char ch = codeHeap.content[writeAddress + i];
writeData64 = writeData64 << 8;
writeData64 += ch;
}
if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD,
baseAddress + writeAddress,
writeData64) == HAL_OK) {
writeAddress = writeAddress + 8;
} else {
printf("[error]: Write flash faild. \r\n");
while (1) {
}
}
}
HAL_FLASH_Lock();
printf("[ OK ]: Write flash ok! \r\n");
baseAddress = FLASH_SCRIPT_START_ADDR;
MemoryProgramStatus = 0x0;
printf("[info]: Checking flash... \r\n");
char* codeInFlash = (char*)baseAddress;
printf("\r\n");
printf("----[code in flash]-----\r\n");
for (int i = 0; i < strGetSize(codeHeap.content); i++) {
if ('\n' == codeHeap.content[i]) {
fputc('\r', (FILE*)!NULL);
}
fputc(codeHeap.content[i], (FILE*)!NULL);
}
printf("----[code in flash]-----\r\n");
printf("\r\n");
if (!strEqu(codeInFlash, codeHeap.content)) {
printf("[error]: Check flash faild.\r\n");
printf("\r\n");
printf("\r\n\r\n");
printf("---------[code in heap]----------\r\n");
printf("\r\n");
for (int i = 0; i < strGetSize(codeHeap.content); i++) {
if ('\n' == codeHeap.content[i]) {
fputc('\r', (FILE*)!NULL);
}
fputc(codeHeap.content[i], (FILE*)!NULL);
}
printf("\r\n\r\n");
printf("---------[code in heap]----------\r\n");
while (1) {
}
}
printf("[ OK ]: Checking flash ok! \r\n");
printf("[ OK ]: Programing ok! \r\n");
printf("[info]: Restarting... \r\n");
printf("==============[Programer]==============\r\n");
printf("\r\n");
HAL_NVIC_SystemReset();
}
void __platformWait(void){
while(1){
pika_memory_lock ++;
}
}

64
package/STM32G030Booter/pika_config.h Normal file
View File

@ -0,0 +1,64 @@
#ifndef __STM32G030_PIKA_PORT__H
#define __STM32G030_PIKA_PORT__H
#define use_mem_pool 1
#include <stdint.h>
#include "pikaObj.h"
typedef struct _CodeHeap {
char* content;
uint32_t size;
uint8_t ena;
uint32_t reciveTime;
uint32_t oldSize;
} CodeHeap;
/* support std lib for stm32 */
#define delay_ms HAL_Delay
#undef u16
#undef u8
#undef u32
#define u16 uint16_t
#define u8 uint8_t
#define u32 uint32_t
#define GPIO_Pin_0 GPIO_PIN_0
#define GPIO_Pin_1 GPIO_PIN_1
#define GPIO_Pin_2 GPIO_PIN_2
#define GPIO_Pin_3 GPIO_PIN_3
#define GPIO_Pin_4 GPIO_PIN_4
#define GPIO_Pin_5 GPIO_PIN_5
#define GPIO_Pin_6 GPIO_PIN_6
#define GPIO_Pin_7 GPIO_PIN_7
#define GPIO_Pin_8 GPIO_PIN_8
#define GPIO_Pin_9 GPIO_PIN_9
#define GPIO_Pin_10 GPIO_PIN_10
#define GPIO_Pin_11 GPIO_PIN_11
#define GPIO_Pin_12 GPIO_PIN_12
#define GPIO_Pin_13 GPIO_PIN_13
#define GPIO_Pin_14 GPIO_PIN_14
#define GPIO_Pin_15 GPIO_PIN_15
/* support pinrtf */
void HARDWARE_PRINTF_Init(void);
/* support write asm to flash */
#define FLASH_SCRIPT_START_ADDR \
(FLASH_BASE + ((FLASH_PAGE_NB - 2) * FLASH_PAGE_SIZE))
#define FLASH_SCRIPT_END_ADDR (FLASH_BASE + FLASH_SIZE - 1)
#define FLASH_PIKA_ASM_START_ADDR FLASH_SCRIPT_START_ADDR
#define FLASH_PIKA_ASM_END_ADDR FLASH_SCRIPT_END_ADDR
#define RX_BUFF_LENGTH 64
/* support download python script by uart1 */
uint8_t STM32_Code_reciveHandler(char* data, uint32_t rxSize);
void STM32_Code_Init(void);
void STM32_Code_flashHandler(void);
/* handler for usart1 */
void __PIKA_USART1_IRQHandler(char rx_char);
#endif
/* delay_us */
void delay_us(uint32_t udelay);