lzx/ls1x-master-v0.4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
chenzitong 2025-01-15 10:57:40 +08:00
parent 9362b4a3cc
commit 85e56f1581
14 changed files with 587 additions and 1539 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
case/SHT-31/1c102_dev_SHT31.c Normal file
View File

@ -0,0 +1,67 @@
#include "ls1x.h"
#include "Config.h"
#include "1c102_myI2C.h"
#include "1c102_dev_SHT31.h"
/*
* CRC-8 formula from page 14 of SHT spec pdf
* Test data 0xBE, 0xEF should yield 0x92
* Initialization data 0xFF
* Polynomial 0x31 (x8 + x5 +x4 +1)
* Final XOR 0x00
*/
uint8_t CRC_8(const uint8_t *data, int len)
{
const uint8_t POLYNOMIAL = 0x31;
uint8_t crc = 0xFF;
int j;
int i;
for(j = len; j; --j)
{
crc ^= *data++;
for(i = 8; i; --i)
{
crc = (crc&0x80)? (crc << 1)^POLYNOMIAL:(crc << 1);
}
}
return crc;
}
void Get_TandRH()
{
uint8_t buf[10];
int buf_len = 0;
uint8_t cmd[2] = {0x24, 0x0B};
uint32_t temp, rh = 0;
myI2C_write_mult(SHT31_INTERFACE_ADDR, SHT31_DEFAULT_ADDR, cmd, 2);
buf_len = myI2C_read_mult(SHT31_INTERFACE_ADDR, SHT31_DEFAULT_ADDR, buf);
printf("buf_len = %d\n", buf_len);
if(buf_len >= 6)
{
temp = (buf[0]&0xFF)<<8 | buf[1];
rh = (buf[3]&0xFF)<<8 | buf[4];
printf("Temp=0x%02x, RH=0x%02x.\n", temp, rh);
temp = (175*(temp/0xFFFF))-45;
rh = 100*(rh/0xFFFF);
}
return;
}
void Get_RegValue()
{
return;
}
void Set_RegValue()
{
return;
}

36
case/SHT-31/1c102_dev_SHT31.h Normal file
View File

@ -0,0 +1,36 @@
#ifndef LS1X_MASTER_V0_4_1C102_DEV_SHT31_H
#define LS1X_MASTER_V0_4_1C102_DEV_SHT31_H
#define SHT31_INTERFACE_ADDR 1
#define SHT31_DEFAULT_ADDR 0x44
#define SHT31_READ_SERIALNO 0x3780
#define SHT31_MEAS_HIGHREP_STRETCH 0x2C06 // Doesn't work on PI
#define SHT31_MEAS_MEDREP_STRETCH 0x2C0D // Seems to work on PI but shouldn't
#define SHT31_MEAS_LOWREP_STRETCH 0x2C10 // Seems to work on PI but shouldn't
#define SHT31_MEAS_HIGHREP 0x2400 // Doesn't work on PI
#define SHT31_MEAS_MEDREP 0x240B
#define SHT31_MEAS_LOWREP 0x2416
#define SHT31_READSTATUS 0xF32D
#define SHT31_CLEARSTATUS 0x3041
#define SHT31_SOFTRESET 0x30A2
#define SHT31_HEATER_ENABLE 0x306D
#define SHT31_HEATER_DISABLE 0x3066
#define SHT32_DEFAULT_READ SHT31_MEAS_MEDREP
#define SHT31D_FIX_INITIAL_FAIL 1
typedef enum
{
SHT31_OK = 0,
SHT31_CRC_CHECK_FAILED = 1,
SHT31_BAD = 2,
SHT31_READ_FAILED = 3,
SHT31_WRITE_FAILED = 4
} sht31rtn;
uint8_t CRC_8(const uint8_t *data, int len);
void Get_TandRH();
void Get_RegValue();
void Set_RegValue();
#endif //LS1X_MASTER_V0_4_1C102_DEV_SHT31_H

43
private/ls1c102/1c102_myGPIO.c Normal file
View File

@ -0,0 +1,43 @@
#include "ls1x.h"
#include "Config.h"
#include "UserGpio.h"
#include "ls1x_gpio.h"
#include "1c102_myGPIO.h"
/*
*
*/
void Set_gpio_value(unsigned char GPIOx, unsigned char mode, unsigned char value)
{
unsigned char data = 0;
assert_param(IS_GPIO_PIN(GPIOx));
if(mode)
{
data = (mode<<1) | value;
PMU_GPIOBit(GPIOx) = data;
}
return;
}
void remap_gpio(unsigned char gpio_NO, GPIOFunc_TypeDef gpio_fun)
{
switch(gpio_NO/16)
{
case 0:
AFIO_RemapConfig(AFIOA, 0x1<<(gpio_NO%16), gpio_fun);
break;
case 1:
AFIO_RemapConfig(AFIOB, 0x1<<(gpio_NO%16), gpio_fun);
break;
case 2:
AFIO_RemapConfig(AFIOC, 0x1<<(gpio_NO%16), gpio_fun);
break;
case 3:
AFIO_RemapConfig(AFIOD, 0x1<<(gpio_NO%16), gpio_fun);
break;
default:
break;
}
}

6
private/ls1c102/1c102_myGPIO.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef LS1X_MASTER_V0_4_1C102_MYGPIO_H
#define LS1X_MASTER_V0_4_1C102_MYGPIO_H
void Set_gpio_value(unsigned char GPIOx, unsigned char mode, unsigned char value);
void remap_gpio(unsigned char gpio_NO, GPIOFunc_TypeDef gpio_fun);
#endif //LS1X_MASTER_V0_4_1C102_MYGPIO_H

242
private/ls1c102/1c102_myI2C.c Normal file
View File

@ -0,0 +1,242 @@
#include "Config.h"
#include "ls1x.h"
#include "ls1x_latimer.h"
#include "ls1x_clock.h"
#include "ls1x_gpio.h"
#include "1c102_myGPIO.h"
#include "1c102_myI2C.h"
/**初始化部分**/
void MY_I2C_StructInit(I2C_InitTypeDef *I2C_InitStruct)
{
/*---------------- Reset I2C init structure parameters values ----------------*/
/* initialize the I2C_ClockSpeed member */
I2C_InitStruct->I2C_ClockSpeed = 100000;
/* Initialize the I2C_Mode member */
I2C_InitStruct->I2C_Mode = I2C_Mode_Master;
// I2C_InitStruct->I2C_Mode = I2C_Mode_Slave;
/* Initialize the I2C_OwnAddress1 member */
I2C_InitStruct->I2C_OwnAddress1 = 0x2A;
/* Initialize the I2C_Buslock Check */
I2C_InitStruct->I2C_BuslockCheckEn = I2C_Buslock_Check_Enable;
/* Initialize the I2C_Slave_Autoreset */
I2C_InitStruct->I2C_SlvAutoresetEn = I2C_Slv_Autoreset_Disable;
}
void MY_I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct)
{
uint32_t tmp = 0;
uint32_t pclk1 = SystemFreq;
/*---------------------------- I2Cx Configuration ------------------------*/
I2Cx->CTRL = 0x20; //访问分频寄存器
tmp = pclk1/I2C_InitStruct->I2C_ClockSpeed;
tmp = (tmp>>2)-1;
I2Cx->PRERL = tmp;
I2Cx->PRERH = tmp >> 8;
/* Enable the selected I2C peripheral */
I2Cx->CTRL = 0x80|(I2C_InitStruct->I2C_Mode)|(I2C_InitStruct->I2C_BuslockCheckEn)|(I2C_InitStruct->I2C_SlvAutoresetEn);
if (I2C_InitStruct->I2C_BuslockCheckEn)
{
I2Cx->CR_SR = 0x04;
}
I2Cx->SADDR = I2C_InitStruct->I2C_OwnAddress1;
I2C_wait(I2C);
return;
}
void MY_I2C_InitTask()
{
remap_gpio(MYI2C_SDA_GPIO_INDEX, GPIO_FUNC_MAIN);
remap_gpio(MYI2C_SCL_GPIO_INDEX, GPIO_FUNC_MAIN);
I2C_InitTypeDef My_I2C_InitStruct;
MY_I2C_StructInit(&My_I2C_InitStruct);
My_I2C_InitStruct.I2C_ClockSpeed = MYI2C_CLOCK_FAST_SPEED;
I2C_Init(I2C, &My_I2C_InitStruct);
delay_ms(500);
return;
}
/**工具部分*/
void myI2C_write_signal(unsigned char dev_addr, unsigned char reg_addr, unsigned char w_data)
{
//unsigned int v = SaveDisableInt();
I2C_GenerateSTART(I2C,ENABLE);
I2C_wait(I2C);
I2C_Send7bitAddress(I2C, dev_addr & 0xff, I2C_Direction_Transmitter);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send 7 bit address failed\n");
goto exit_point;
}
I2C_SendData(I2C, reg_addr);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send reg address failed\n");
goto exit_point;
}
I2C_SendData(I2C, w_data);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send data failed\n");
goto exit_point;
}
I2C_GenerateSTOP(I2C,ENABLE);
I2C_wait(I2C);
exit_point:
//recvEnableInt(v);
return;
}
void myI2C_write_mult(uint8_t dev_addr, uint8_t reg_addr, uint8_t *w_data, uint8_t num)
{
int i=0;
I2C_GenerateSTART(I2C,ENABLE);
I2C_wait(I2C);
I2C_Send7bitAddress(I2C, dev_addr & 0xff, I2C_Direction_Transmitter);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send 7 bit address failed\n");
goto exit_point;
}
I2C_SendData(I2C, reg_addr);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send reg address failed\n");
goto exit_point;
}
for(i=0; i<num; ++i)
{
I2C_SendData(I2C, w_data[i]);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send data failed\n");
goto exit_point;
}
}
I2C_GenerateSTOP(I2C,ENABLE);
I2C_wait(I2C);
exit_point:
//recvEnableInt(v);
return;
}
unsigned char myI2C_read_signal(unsigned char dev_addr, unsigned char reg_addr)
{
//unsigned int v = SaveDisableInt();
unsigned char ret = 0xff;
I2C_GenerateSTART(I2C,ENABLE);
I2C_wait(I2C);
I2C_Send7bitAddress(I2C, dev_addr & 0xff, I2C_Direction_Transmitter);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send 7 bit address failed\n");
goto exit_point;
}
I2C_SendData(I2C,reg_addr);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send reg address failed\n");
goto exit_point;
}
I2C_Send7bitAddress(I2C, dev_addr & 0xff, I2C_Direction_Receiver);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send 7 bit address failed\n");
goto exit_point;
}
I2C_ReceiveData(I2C,I2C_NACK,I2C_STOP);
I2C_wait(I2C);
ret = (uint8_t)I2C->DR;
exit_point:
//recvEnableInt(v);
return ret;
}
unsigned char myI2C_read_mult(uint8_t dev_addr, uint8_t reg_addr, uint8_t *rece_data)
{
unsigned char i = 0;
unsigned char ret = 0xFF;
I2C_GenerateSTART(I2C,ENABLE);
I2C_wait(I2C);
I2C_Send7bitAddress(I2C, dev_addr & 0xff, I2C_Direction_Transmitter);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send 7 bit address failed\n");
goto exit_point;
}
I2C_SendData(I2C,reg_addr);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send reg address failed\n");
goto exit_point;
}
I2C_Send7bitAddress(I2C, dev_addr&0xFF, I2C_Direction_Receiver);
I2C_wait(I2C);
if(I2C->CR_SR & 0x80)
{
printf("I2C send 7 bit address failed\n");
goto exit_point;
}
unsigned char chk = 0;
while (!chk)
{
if(I2C->CR_SR && 0x80){
I2C_ReceiveData(I2C, I2C_NACK, I2C_STOP);
I2C_wait(I2C);
ret = (uint8_t)I2C->DR;
chk = 1;
}
else{
I2C_ReceiveData(I2C,I2C_ACK,I2C_NSTOP);
I2C_wait(I2C);
ret = (uint8_t)I2C->DR;
chk = 0;
}
rece_data[i++] = ret;
}
rece_data[i] = '\0';
exit_point:
//recvEnableInt(v);
return i;
}

19
private/ls1c102/1c102_myI2C.h Normal file
View File

@ -0,0 +1,19 @@
#ifndef LS1X_MASTER_V0_4_1C102_MYI2C_H
#define LS1X_MASTER_V0_4_1C102_MYI2C_H
#include "ls1c102_i2c.h"
//INDEX的定义统一按照GPIO序号定义
#define MYI2C_SDA_GPIO_INDEX 5
#define MYI2C_SCL_GPIO_INDEX 4
//I2C总线速率
#define MYI2C_CLOCK_FAST_SPEED 400000
#define MYI2C_CLOCK_SPEED 100000
void MY_I2C_StructInit(I2C_InitTypeDef *I2C_InitStruct);
void MY_I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct);
void MY_I2C_InitTask();
void myI2C_write_signal(unsigned char dev_addr, unsigned char reg_addr, unsigned char w_data);
void myI2C_write_mult(uint8_t dev_addr, uint8_t reg_addr, uint8_t *w_data, uint8_t num);
unsigned char myI2C_read_signal(unsigned char dev_addr, unsigned char reg_addr);
unsigned char myI2C_read_mult(uint8_t dev_addr, uint8_t reg_addr, uint8_t *rece_data);
#endif //LS1X_MASTER_V0_4_1C102_MYI2C_H

7
private/ls1c102/1c102_mySysTime.c Normal file
View File

@ -0,0 +1,7 @@
#include "../../include/ls1x.h"
#include "1c102_mySysTime.h"
void Get_My_SysTimer()
{
}

5
private/ls1c102/1c102_mySysTime.h Normal file
View File

@ -0,0 +1,5 @@
#ifndef LS1X_MASTER_V0_4_1C102_MYSYSTIME_H
#define LS1X_MASTER_V0_4_1C102_MYSYSTIME_H
#endif //LS1X_MASTER_V0_4_1C102_MYSYSTIME_H

83
private/ls1c102/1c102_mytimer.c Normal file
View File

@ -0,0 +1,83 @@
#include "../../include/ls1x.h"
#include "../../include/Config.h"
#include "ls1c102_ptimer.h"
#include "1c102_mytimer.h"
#define TIMER_NUM 100
Timertask_Typedef mytimer_que[MYTIME_QUEUE_NUMBER]={0};
char Reg_timer_task(unsigned int exe_time, int (*handle_fun)(void))
{
unsigned char i = 0;
for(i=0; i<=MYTIME_QUEUE_NUMBER-1; ++i)
{
if(!mytimer_que[i].status){
mytimer_que[i].que_number = i;
mytimer_que[i].status = MYTIME_TASK_ENABLE;
mytimer_que[i].execute_time = exe_time/TIMER_NUM;
mytimer_que[i].handle_fun = handle_fun;
break;
}
else {
if (i == MYTIME_QUEUE_NUMBER) {
printf("The queue is full.\n");
return -1;
}
}
}
return mytimer_que[i].que_number;
}
void Del_timer_task(unsigned char que_num)
{
mytimer_que[que_num].status = MYTIME_TASK_DISABLE;
return;
}
void Timer_IRQ_Handle()
{
unsigned char i = 0;
for(i=0; i<=MYTIME_QUEUE_NUMBER-1; ++i)
{
if(mytimer_que[i].status == MYTIME_TASK_ENABLE)
{
if(--mytimer_que[i].execute_time <= 0)
{
mytimer_que[i].handle_fun();
Del_timer_task(mytimer_que[i].que_number); /*执行完删除该定时任务*/
}
}
}
return;
}
unsigned int SystemFreq;
static void timer_start()
{
TIM_InitTypeDef timer_info;
TIM_StructInit(&timer_info);
timer_info.Clock_Freq = SystemFreq;
timer_info.TIME_CMP = ((timer_info.Clock_Freq*TIMER_NUM)/1000); //(1ms*TIMER_NUM)ms
timer_info.TIME_STP = ((timer_info.Clock_Freq*TIMER_NUM)/1000);
TIM_Init(&timer_info);
return;
}
void Timer_Init()
{
int i = 0;
for(i=0; i<MYTIME_QUEUE_NUMBER-1; ++i)
{
mytimer_que[i].status = MYTIME_TASK_DISABLE;
mytimer_que[i].que_number = 0;
mytimer_que[i].execute_time = 0;
mytimer_que[i].handle_fun = NULL;
}
timer_start();
return;
}

20
private/ls1c102/1c102_mytimer.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef LS1X_MASTER_V0_4_1C102_MYTIMER_H
#define LS1X_MASTER_V0_4_1C102_MYTIMER_H
#define MYTIME_TASK_ENABLE 1
#define MYTIME_TASK_DISABLE 0
#define MYTIME_QUEUE_NUMBER 10
typedef struct{
unsigned char que_number;
unsigned char status;
unsigned int execute_time;
int (*handle_fun)(void);
}Timertask_Typedef;
void Timer_Init();
void Timer_IRQ_Handle();
char Reg_timer_task(unsigned int exe_time, int (*handle_fun)(void));
void Del_timer_task(unsigned char que_num);
#endif //LS1X_MASTER_V0_4_1C102_MYTIMER_H

59
user/1c102_main.c Normal file
View File

@ -0,0 +1,59 @@
#include "Config.h"
#include "ls1x_gpio.h"
#include "ls1x_pmu.h"
#include "ls1x_clock.h"
#include "ls1x_common.h"
#include "ls1x_uart.h"
#include "ls1x_wdg.h"
#include "ls1x_string.h"
#include "UserGpio.h"
#include "../case/SHT-31/1c102_dev_SHT31.h"
#include "../private/ls1c102/1c102_mytimer.h"
#include "../private/ls1c102/1c102_myGPIO.h"
#define TEST_GPIO 63
extern uint32_t SystemFreq;
int task1()
{
GPIOMode_TypeDef test_mode = GPIO_Mode_Out;
printf("1s\n");
Set_gpio_value(TEST_GPIO, test_mode, 1);
return 0;
}
int task2()
{
printf("2s\n");
return 0;
}
int task3()
{
printf("3s\n");
return 0;
}
void main()
{
char reg_result = 0;
/* Required initialization modules */
SystemClockInit();
SystemFreq = CLOCK_GetClocksFreq();
GPIOInit();
WdgInit();
/* */
DisableInt();
UartInit();
EnableInt();
ls1x_logo();
Get_TandRH();
while(1);
}

454
user/1c103_Interrupt.c
View File

@ -1,454 +0,0 @@
#include "ls1c103_tim.h"
#include "ls1c103_map.h"
#include "ls1c103_adc.h"
#include "ls1c103_bldc_tim.h"
#include "ls1c103_bldc_ctrl.h"
#include "ls1c103_dcm_tim.h"
#include "ls1x_exti.h"
#include "ls1x_wdg.h"
#include "ls1x_common.h"
#include "Config.h"
#include "test.h"
#include "foc.h"
extern void mc_ctrl(void);
extern motor_rotate_t motor_drive; // 定义电机驱动管理结构体
#define BEBUG_IRQ() printf("\r\n < line: %d func:%s >\r\n",__LINE__,__FUNCTION__)
void (* const exti_irq_handle[32])(void);
void exti_gpioa0_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A0);
}
void exti_gpioa1_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A1);
}
void exti_gpioa2_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A2);
}
void exti_gpioa3_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A3);
}
void exti_gpioa4_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A4);
}
void exti_gpioa5_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A5);
}
void exti_gpioa6_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A6);
}
void exti_gpioa7_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A7);
}
void exti_gpioa8_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A8);
}
void exti_gpioa9_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A9);
}
void exti_gpioa10_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A10);
}
void exti_gpioa11_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A11);
}
void exti_gpioa12_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A12);
}
void exti_gpioa13_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A13 );
}
void exti_gpioa14_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A14);
}
void exti_gpioa15_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_A15 );
}
void exti_gpiob0_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B0);
}
void exti_gpiob1_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B1);
}
void exti_gpiob2_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B2);
}
void exti_gpiob3_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B3);
}
void exti_gpiob4_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B4);
}
void exti_gpiob5_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B5);
}
void exti_gpiob6_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B6);
}
void exti_gpiob7_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B7);
}
void exti_gpiob8_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B8);
}
void exti_gpiob9_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B9);
}
void exti_gpiob10_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B10);
}
void exti_gpiob11_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B11);
}
void exti_gpiob12_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_B12);
}
void (* const Ext_IrqHandle[29])(void) = {
exti_gpioa0_irq_handler,
exti_gpioa1_irq_handler,
exti_gpioa2_irq_handler,
exti_gpioa3_irq_handler,
exti_gpioa4_irq_handler,
exti_gpioa5_irq_handler,
exti_gpioa6_irq_handler,
exti_gpioa7_irq_handler,
exti_gpioa8_irq_handler,
exti_gpioa9_irq_handler,
exti_gpioa10_irq_handler,
exti_gpioa11_irq_handler,
exti_gpioa12_irq_handler,
exti_gpioa13_irq_handler,
exti_gpioa14_irq_handler,
exti_gpioa15_irq_handler,
exti_gpiob0_irq_handler,
exti_gpiob1_irq_handler,
exti_gpiob2_irq_handler,
exti_gpiob3_irq_handler,
exti_gpiob4_irq_handler,
exti_gpiob5_irq_handler,
exti_gpiob6_irq_handler,
exti_gpiob7_irq_handler,
exti_gpiob8_irq_handler,
exti_gpiob9_irq_handler,
exti_gpiob10_irq_handler,
exti_gpiob11_irq_handler,
exti_gpiob12_irq_handler,
};
void ext_handler(void)
{
INT32U regsrc;// = EXTI->EXINT_SRC;
INT32U regen;// = EXTI->EXINT_SRC;
INT32U irq_no;
BEBUG_IRQ();
regsrc = EXTI->EXINT_SRC;
regen = EXTI->EXINT_EN;
regsrc = (regsrc & regen);
asm("nop");
for(irq_no = 0; irq_no < 32; irq_no++)
{
if((regsrc>>irq_no) & 0x1)
{
Ext_IrqHandle[irq_no]();
}
}
}
void pmu_handler(){
printf("\r\nThis is pmu_handler");
if(PMU_CMDSTS & (1<<16))
{
printf("\n\rTIMER_WAKE_INT\n\r");
PMU_CMDW = (1 << 16); // 清除中断标志
//INT32U SleepEn = PMU_CMDSTS & 0xffffffff;
WDG_DogFeed();
}
}
void intc_handler(){
//printf("\r\nThis is intc_handler!");
if(INT_OUT & 0x1)
{
// printf("\n\rBTIM_INT!");
if(TIM_GetITStatus(TIM6, TIM_IT_Update) == SET){
TIM_ClearFlag(TIM6, TIM_IT_Update);
mc_ctrl();
}
}
}
void adc_handler(){
uint16_t tmpreg[3];
static int i = 0;
if(ADC_GetITStatus(ADC1, ADC_IT_JEOC) == SET){
ADC_ClearITPendingBit(ADC1, ADC_IT_JEOC);
#if 0
if(i<1000){
i++;
}
else{
tmpreg[0] = ((ADC_GetInjectedConversionValue(ADC1, ADC_InjectedChannel_1)*5000)>>12);
tmpreg[1] = ((ADC_GetInjectedConversionValue(ADC1, ADC_InjectedChannel_2)*5000)>>12);
tmpreg[2] = ((ADC_GetInjectedConversionValue(ADC1, ADC_InjectedChannel_3)*5000)>>12);
//printf("U:%d,V:%d,W:%d\n\r",tmpreg[0],tmpreg[1],tmpreg[2]);
//printf("%d\n\r",tmpreg[0]);
i=0;
}
#else
printf("this is adc int\n\r");
#endif
}
}
void bldc_handler(int vector,void *param){
// printf("%d, %s\n",vector,param);
if ((HALL_TIM->SR &(TIM_IT_Trigger)) == (TIM_IT_Trigger)!= RESET)
{
HALL_TIM->SR &= ~(TIM_IT_Trigger);
if ((((HALL_TIM->DIER & TIM_IT_Trigger) == (TIM_IT_Trigger)) ? SET : RESET) != RESET)
{
HALL_TriggerCallback();
}
}
else if ((HALL_TIM->SR &(TIM_FLAG_Update)) == (TIM_FLAG_Update)!= RESET)
{
HALL_TIM->SR &= ~(TIM_IT_Update);
if ((((HALL_TIM->DIER & TIM_IT_Update) == (TIM_IT_Update)) ? SET : RESET) != RESET)
{
HALL_PeriodElapsedCallback();
}
}
}
void dcm_handler(int vector, void *param){
// printf("%d, %s\n",vector,param);
if ((ENCODER_TIM->SR &(TIM_FLAG_Update)) == (TIM_FLAG_Update)!= RESET)
{
ENCODER_TIM->SR &= ~(TIM_IT_Update);
if ((((ENCODER_TIM->DIER & TIM_IT_Update) == (TIM_IT_Update)) ? SET : RESET) != RESET)
{
if((ENCODER_TIM->CR1 &(TIM_CR1_DIR)) == (TIM_CR1_DIR)){
/* 下溢 */
Encoder_Overflow_Count--;
}
else{
/* 上溢 */
Encoder_Overflow_Count++;
}
}
}
}
INT32U g_foc_counter = 0;
extern INT32U g_flags;
void foc_handler(int vector, void *param){
if ((ENCODER_TIM->SR &(TIM_FLAG_Update)) == (TIM_FLAG_Update)!= RESET)
{
ENCODER_TIM->SR &= ~(TIM_IT_Update);
if ((((ENCODER_TIM->DIER & TIM_IT_Update) == (TIM_IT_Update)) ? SET : RESET) != RESET)
{
if(g_flags == 1)
{
g_foc_counter++;
}
else if(g_flags == 2)
{
g_foc_counter=0;
}
// if((ENCODER_TIM->CR1 &(TIM_CR1_DIR)) == (TIM_CR1_DIR)){
// /* 下溢 */
// Encoder_Overflow_Count--;
// motor_drive.timeout = 0;
// }
// else{
// /* 上溢 */
// Encoder_Overflow_Count++;
// motor_drive.timeout = 0;
// }
}
}
}
void atim_handler(){
//if(TIM_GetITStatus(TIM1, TIM_IT_Update) == SET){
// TIM_ClearFlag(TIM1, TIM_IT_Update);
// printf("atim up int\n");
//}
if ((MOTOR_TIM->SR &(TIM_IT_Update)) == (TIM_IT_Update)!= RESET)
{
if ((((MOTOR_TIM->DIER & TIM_IT_Update) == (TIM_IT_Update)) ? SET : RESET) != RESET)
{
MOTOR_TIM->SR &= ~(TIM_IT_Update);
foc_update();
}
}
}
typedef void (*isr_handler_t)(int vector, void *param);
struct irq_desc
{
isr_handler_t handler;
void *param;
};
struct irq_desc irq_handler_table[3];
void irq_default_handler(int vector, void *param)
{
printf("Error !!! BLDC STOP\r\n");
HALL_PeriodElapsedCallback();
}
isr_handler_t motor_interrupt_register(int vector,isr_handler_t handler, void *param)
{
isr_handler_t old_handler = NULL;
if(vector >=0 && vector < 3)
{
old_handler = irq_handler_table[vector].handler;
irq_handler_table[vector].handler = handler;
irq_handler_table[vector].param = param;
}
printf("%s index %d regsiter successful\n",param,vector);
return old_handler;
}
static int g_index = 0;
void gtim_handler(void)
{
void *param;
isr_handler_t irq_func = NULL;
//printf("g_index:%d\r\n",g_index);
irq_func = irq_handler_table[g_index].handler;
param = irq_handler_table[g_index].param;
irq_func(g_index,param);
}
extern void *memset(void *s, int c, int count);
void irq_motor_default(void)
{
int idx;
memset(irq_handler_table, 0x00, sizeof(irq_handler_table));
for(idx=0; idx<3; idx++)
{
irq_handler_table[idx].handler = irq_default_handler;
}
}
void irq_motor_init(int index)
{
if(index == 1)
{
motor_interrupt_register(index,bldc_handler, "bldc_irq");
}
else if(index == 0)
{
motor_interrupt_register(index,dcm_handler, "dcm_irq");
}
else if(index == 2)
{
motor_interrupt_register(index,foc_handler, "foc_irq");
}
else if(index == 3)
{
printf("do nothing\r\n");
}
g_index = index;
}
void TIMER_HANDLER(void)
{
Set_Timer_clear();
printf("Core Timer clear interrupt..\n");
Set_Timer_stop();
}

532
user/1c103_cmd.c
View File

@ -1,532 +0,0 @@
//#include "ls1c103.h"
#include "ls1x.h"
#include "ls1c103_map.h"
#include "ls1x_rtc.h"
#include "ls1x_latimer.h"
#include "ls1x_common.h"
#include "ls1x_string.h"
#include "ls1x_spi.h"
#include "ls1x_wdg.h"
#include "ls1x_gpio.h"
#include "Config.h"
INT32U wdt_caller;
extern uint32_t SystemFreq;
unsigned int str2num(unsigned char *);
extern void cpu_sleep();
extern int spi_cfg(void);
int do_nothing()
{
return 0;
}
int do_d1(int argc, void *argv[])
{
if((argc < 2)||(argc > 3))
{
printf("\n usage: d1 <addr> <num>\n\r");
return 1;
}
INT32U addr;
int i, num;
addr = str2num(argv[1]);
if(argc == 2) num = 1;
else num = str2num(argv[2]);
for(i=0; i<num; i++)
{
if((i%8) == 0)
printf("\n 0x%08x:\t", addr+i);
printf(" %02x ", *(volatile INT8U*)(addr+i));
}
return 0;
}
int do_d4(int argc, void *argv[])
{
if((argc < 2)||(argc > 3))
{
printf("\n usage: d4 <addr> <num>\n\r");
return 1;
}
unsigned int addr;
int i, num;
addr = str2num(argv[1]);
if(argc == 2) num = 1;
else num = str2num(argv[2]);
for(i=0; i<num; i++)
{
if((i%4) == 0)
printf("\n0x%08x:\t", addr+i*4);
printf(" %08x ", *(volatile unsigned int*)(addr+i*4));
}
return 0;
}
int do_m1(int argc, void *argv[])
{
unsigned int addr;
unsigned char value;
if(argc != 3)
{
printf("\n usage: m1 <addr> <value>\n\r");
return 1;
}
addr = str2num(argv[1]);
value = (unsigned char)str2num(argv[2]);
*(volatile unsigned char*)(addr) = value;
return 0;
}
int do_m4(int argc, void *argv[])
{
unsigned int addr;
unsigned int value;
if(argc != 3)
{
printf("\n usage: m4 <addr> <value>\n\r");
return 1;
}
addr = str2num(argv[1]);
value = str2num(argv[2]);
*(volatile unsigned int*)(addr) = value;
return 0;
}
unsigned int str2num(unsigned char *s)
{
unsigned int num = 0;
unsigned int radix;
unsigned int chr;
unsigned int i;
if((*(s)=='0') && (*(s+1)=='x' || *(s+1)=='X'))
{
i = 2;
radix = 16;
}
else if(*(s)=='0')
{
i = 1;
radix = 8;
}
else
{
i = 0;
radix = 10;
}
for(; *(s+i)!='\0'; i++)
{
chr = *(s+i);
switch(radix){
case 16:
if(chr>='0' && chr<='9')
num = num*radix + (chr - '0');
else if(chr>='a' && chr<='f')
num = num*radix + (chr - 'a' + 10);
else if(chr>='A' && chr<='F')
num = num*radix + (chr - 'A' + 10);
else
printf("illegal hex number...\n");
break;
case 10:
case 8:
if(chr>='0' && chr<('0'+radix))
num = num*radix + (chr - '0');
else
printf("illegal number...\n");
break;
default:
break;
}
}
return num;
}
int watch_dog(int argc, void *argv[])
{
INT32U sec;
printf("\r\nwdg test start....argc:%d\n",argc);
if(argc < 2)
{
WDG_DogFeed();
printf("\r\n Usage: wdg <sec>");
return 1;
}
sec = str2num(argv[1]);
WDG_SetWatchDog(sec);
return 0;
}
int delay(int argc, void *argv[])
{
INT32U flags,val;
if(argc < 3)
{
printf("\r\n Usage: delay <mode:1:us,2:ms,3:s> <val>");
return 1;
}
flags = str2num(argv[1]);
val = str2num(argv[2]);
if (flags == 1)
{
delay_us(val);
printf("\r\n%dus",val);
}
else if (flags == 2) {
delay_ms(val);
printf("\r\n%dms",val);
}else if (flags == 3){
delay_s(val);
printf("\r\n%ds",val);
}else {
printf("\r\n Usage: delay <mode:1:us,2:ms,3:s> <val>");
}
return 0;
}
INT32U a_to_n(INT8U chr) //ascii to number
{
if (chr < 0x30 || chr > 0x39)
{
printf("\r\nwrong range of number!\r\n");
return -1;
}
return (chr & 0x0f);
}
/***rtc test***/
int date (int argc, void* argv[])
{
printf("\r\n");
char *param_str [4] = {"-h", "-s", "-i", "-f"};
if (!strcmp(argv[1], param_str[0]))
{
printf("date to display time. \r\n");
printf("date -s yy-mm-dd hh:mm:ss to set time.\r\n");
printf("date -i mm-dd hh:mm:ss to set int.\r\n");
printf("date -f Hz :input freqency in integer to set prescale.\r\n");
return 0;
}
if (!strcmp(argv[1], param_str[1])) //set time
{
if (argc != 4)
{
printf("check parameter\r\n");
return 1;
}
INT32U rtc0, rtc1;
INT32U yy, mm, dd, h, m, s;
INT32U invalid_param;
INT8U *rtc1_str, *rtc0_str;
tsRtcTime rtc_param;
rtc1_str = (INT8U*) argv[2];
rtc0_str = (INT8U*) argv[3];
yy = 10*a_to_n(*(rtc1_str+0))+a_to_n(*(rtc1_str+1));
mm = 10*a_to_n(*(rtc1_str+3))+a_to_n(*(rtc1_str+4));
dd = 10*a_to_n(*(rtc1_str+6))+a_to_n(*(rtc1_str+7));
h = 10*a_to_n(*(rtc0_str+0))+a_to_n(*(rtc0_str+1));
m = 10*a_to_n(*(rtc0_str+3))+a_to_n(*(rtc0_str+4));
s = 10*a_to_n(*(rtc0_str+6))+a_to_n(*(rtc0_str+7));
invalid_param = mm > 12 || mm == 0 || dd > 31 ||
dd == 0 ||(mm == 2) && (dd > 29) ||
h > 24 || m > 60 || s > 60 ;
if (invalid_param)
{
printf("invalid param");
return 1;
}
rtc_param.sec = s;
rtc_param.min = m;
rtc_param.hour = h;
rtc_param.day = dd;
rtc_param.mon = mm;
rtc_param.year = yy;
RtcUpdateData(0, &rtc_param);
}
else if (!strcmp(argv[1], param_str[2])) //set int
{
if (argc != 4)
{
printf("check parameter\r\n");
return 1;
}
INT32U mm, dd, h, m, s;
INT32U invalid_param;
INT8U *cfg_str0,*cfg_str1;
tsRtcTime rtc_param;
cfg_str0 = (INT8U*) argv[2];
cfg_str1 = (INT8U*) argv[3];
mm = 10*a_to_n(*(cfg_str0+0))+a_to_n(*(cfg_str0+1));
dd = 10*a_to_n(*(cfg_str0+3))+a_to_n(*(cfg_str0+4));
h = 10*a_to_n(*(cfg_str1+0))+a_to_n(*(cfg_str1+1));
m = 10*a_to_n(*(cfg_str1+3))+a_to_n(*(cfg_str1+4));
s = 10*a_to_n(*(cfg_str1+6))+a_to_n(*(cfg_str1+7));
invalid_param = mm > 12 || mm == 0 || dd > 31 ||
dd == 0 ||(mm == 2) && (dd > 29) ||
h > 24 || m > 60 || s > 60 ;
if (invalid_param)
{
printf("invalid param");
return 1;
}
rtc_param.sec = s;
rtc_param.min = m;
rtc_param.hour = h;
rtc_param.day = dd;
rtc_param.mon = mm;
// bsp_rtc_alarm_set(&rtc_param);
return 0;
}
else if (!strcmp(argv[1], param_str[3])) //set prescale
{
INT32U freq_in = str2num(argv[2]);
if (freq_in <30000 | freq_in > 50000)
{
printf("\r\nshould be close to 32768 Hz\r\n");
return 1;
}
INT32U freq, freq_int, freq_frac;
freq_int=freq_in >> 4;
freq_frac = freq_in%16;
//RTC_FREQ = freq;
return 0;
}
else // or display time
{
if (argc != 1)
printf("date -h for usage\r\n");
INT32U yy, mm, dd, h, m, s;
tsRtcTime rtc_param;
RtcUpdateData(1,&rtc_param);
yy = rtc_param.year;
mm = rtc_param.mon;
dd = rtc_param.day;
h = rtc_param.hour;
m = rtc_param.min;
s = rtc_param.sec;
printf("20%02d-%02d-%02d ", yy, mm, dd);
printf("%02d:%02d:%02d", h, m, s);
return 0;
}
}
#define ERASE_CMD 0xa0000000
#define PAGE_CMD 0xe0000000
#define CLRPL_CMD 0x40000000
#define UPKEY_CMD 0xf0000000
#define UPBND_CMD 0x90000000
#define VERIF_CMD 0x10000000
#define TESTK_CMD 0x20000000
#define INTCLR_CMD 0x30000000
#define SLEEP_CMD 0xc0000000
int copy_to_flash(unsigned int src, unsigned int offset, unsigned int size)
{
unsigned int j;
unsigned int start = offset;
unsigned int end = offset + size;
FLASH_CAH_REG = 0xffffffff;
FLASH_CAL_REG = 0xffffffff;
FLASH_PET_REG = 0x18;
printf("\r\nprogram start\r\n");
for (offset=start;offset<end;offset=offset + 0x80)
{
FLASH_CMD_REG = ERASE_CMD|offset;
WDG_DogFeed();
printf(".");
FLASH_CMD_REG = CLRPL_CMD;
for (j=offset;j<offset+0x80;j=j+4)
{
*(volatile unsigned int*)(FLASH_MEM_BASE + j) = *(volatile unsigned int*)(src + j);
}
FLASH_CMD_REG = PAGE_CMD|offset;
}
printf("\r\nprogram done\r\n");
printf("\r\ncheck start\r\n");
for (offset=start;offset<end;offset=offset+0x80)
{
for (j=offset;j<offset+0x80;j=j+4)
{
if (*(volatile unsigned int*)(FLASH_MEM_BASE + j) != *(volatile unsigned int*)(src + j))
{
printf("copy error %x\n",j);
}
}
}
printf("\r\ncheck done\r\n");
return 0;
}
int copy(void)
{
copy_to_flash(0x20000000, 0x0, 0x10000);
return 0;
}
int wakeup(int argc, void *argv[])
{
INT32U sec;
printf("\r\nTimer Wake Up start....argc:%d\r\n",argc);
DisableInt();
if(argc < 2)
{
Wake_Set(0);
printf("\r\n Usage: wakeup <sec>");
return 1;
}
sec = str2num(argv[1]);
Wake_Set(sec);
cpu_sleep();
return 0;
}
int coremark_test(int argc, void *argv[])
{
if (argc != 2)
{
printf("\n usage: coremark <n> \n");
return 1;
}
INT32U loop = str2num(argv[1]);
//core_main(0,0,0x66,loop,7,1,2000);
printf("\ncoremark test pass!\n");
return 0;
}
int spi_flash(int argc, void *argv[])
{
uint8_t *data;
data = (uint8_t *)0x10000700;
uint16_t flash_id;
uint32_t addr = 0x0;
uint32_t i,k,j=0,count;
spi_cfg();
// SPI->SPCR = 0x52; // enable mstr
// SPI->PARAM = 0x20; // ~memory_en
/*Get flash id*/
flash_id = Spiflash_Rdid();
printf("\r\nid=0x%x\r\n",flash_id);
/*Erase chip*/
Spiflash_Block64k_Erase(addr);
/*Program */
printf("program start\n");
count = 256;
for(k=0;k<count;k++)
{
j=k*0x100;
for(i=0;i<0x100;i++)
{
data[i] = *(volatile uint8_t*)(0x18000000+j+i);
}
Spiflash_Page_Program(addr+j,data,0x100);
printf(". ");
}
printf("\r\nprogram done\n");
printf("\r\ncheckout start\n");
count = 256;
for(k=0;k<count;k++)
{
j=k*0x100;
Spiflash_Read_Bytes(addr+j, data, 0x100);
for(i=0;i<0x100;i++)
{
if(data[i] != *(volatile uint8_t*)(0x18000000+j+i))
{
printf("\ncheck error rdata=%x iaddr=%x\n",data[i],0x18000000+j+i);
break;
}
}
printf(". ");
}
printf("\r\ncheck done\n");
return 0;
}
int latimer(int argc, void *argv[])
{
uint32_t sec;
printf("\r\n core timer start....argc:%d\n",argc);
if(argc < 2)
{
Set_Timer_stop();
printf("\r\n Usage: latimer <sec>");
return 1;
}
sec = str2num(argv[1]);
//Set_Timer_Init(sec*8000000);
Set_Timer_Init(sec*10667000);
return 0;
}
int tmp(int argc, void *argv[])
{
uint32_t tmp =0;
return 0;
}
int copy_iram(void)
{
unsigned int j;
printf("\r\ncopyiram start\r\n");
for (j = 0x0;j < 0x2000; j=j + 4)
{
*(volatile unsigned int*)(0x10000000+j) = 0x0;
}
for (j = 0x0;j < 0x2000; j=j + 4)
{
*(volatile unsigned int*)(0x10000000+j) = *(volatile unsigned int*)(0x20010000 + j);
}
for (j = 0x0;j < 0x2000; j=j + 4)
{
if(*(volatile unsigned int*)(0x10000000+j) != *(volatile unsigned int*)(0x20010000 + j))
{
printf("copy error %x,%x,%x\n",j,*(volatile unsigned int*)(0x10000000+j), *(volatile unsigned int*)(0x20010000 + j));
}
}
asm volatile (\
"li.w $r12, 0x10000000;\n" \
"jirl $r0, $r12 , 0x0;\n"\
);
return 0;
}

553
user/1c103_cmdline.c
View File

@ -1,553 +0,0 @@
#include "Config.h"
#include "UserGpio.h"
#include "ls1x.h"
#include "ls1x_pmu.h"
#include "ls1x_string.h"
#include "ls1x_wdg.h"
#include "ls1x_gpio.h"
#include "ls1x_uart.h"
#include "ls1x_common.h"
#include "ls1x_clock.h"
#include "ls1c103_tim.h"
extern void wakeup_reset(void);
extern void TIM6_timebase(void);
extern int do_d1(int argc,void *argv[]);
extern int do_d4(int argc,void *argv[]);
extern int do_m1(int argc,void *argv[]);
extern int do_m4(int argc,void *argv[]);
// add
extern int do_nothing();
extern unsigned int str2num(unsigned char);
extern int coremark_test(int argc, void *argv[]);
/*foc*/
extern int tim_foc(int argc, void *argv[]);
extern int foc_speed_test(int argc, void *argv[]);
extern int foc_speed_set(int argc, void *argv[]);
/*bldc*/
extern int tim_motor();
extern int speed_set(int argc, void *argv[]);
extern int speed_keyset(int argc, void *argv[]);
/*dcm*/
extern int tim_dcm(int argc, void *argv[]);
extern int speed_set_dcm(int argc, void *argv[]);
extern int speed_keyset_dcm(int argc, void *argv[]);
extern int tim_dcm_enc(int argc, void *argv[]);
extern int enc_speed_set(int argc, void *argv[]);
extern int enc_speed_keyset(int argc, void *argv[]);
extern int show_local();
/*steer*/
extern int tim_steer(int argc, void *argv[]);
extern int angle_set(int argc, void *argv[]);
extern int angle_keyset(int argc, void *argv[]);
/*general*/
extern int latimer(int argc,void *argv[]);
extern int watch_dog(int argc, void *argv[]);
extern int crc(int argc, void *argv[]);
extern int dma_ram(int argc, void *argv[]);
extern int key(int argc, void *argv[]);
extern int key_int(int argc, void *argv[]);
extern int adc_single_test(int argc, void *argv[]);
extern int regular_test(int argc, void *argv[]);
extern int atim_int(int argc, void *argv[]);
extern int btim_int(int argc, void *argv[]);
extern int myspi_init(int argc, void *argv[]);
extern int spi_erase(int argc, void *argv[]);
extern int spi_dma_write(int argc, void *argv[]);
extern int spi_dma_read(int argc, void *argv[]);
extern int spi_flash(int argc, void *argv[]);
extern int tim_int(int argc, void *argv[]);
extern int tim_test();
extern int adc_tim_test(int argc, void *argv[]);
extern int uart1_init(int argc, void *argv[]);
extern int uart1_dma_tx(int argc, void *argv[]);
extern int uart1_dma_rx(int argc, void *argv[]);
extern int i2c_init(int argc, void *argv[]);
extern int i2c_recover(int argc, void *argv[]);
extern int i2c_wr(int argc, void *argv[]);
extern int i2c_rd(int argc, void *argv[]);
extern int i2c_wr_master(int argc, void *argv[]);
extern int i2c_wr_slaver(int argc, void *argv[]);
extern int copy();
extern int copy_iram();
extern int delay(int argc, void *argv[]);
extern int date(int argc, void* argv[]);
extern int wakeup(int argc, void *argv[]);
extern int ry(int argc, void *argv[]);
extern int tmp(int argc, void *argv[]);
int do_help(int argc, void *argv[]);
int do_exit(int argc, void *argv[]);
unsigned int nmi_caller;
static struct cmd_struct {
const char *cmdname;
int (*func)(int, void *[]);
const char *usage;
const char *expression;
} cmd[] __attribute__((section(".rodata"))) = {
{"exit", do_exit, "exit", ""},
{"d1", do_d1, "[d1 <addr> <num>]", "--dump address byte"},
{"d4", do_d4, "[d4 <addr> <num>]", "--dump address word"},
{"help", do_help, "[help <command>]", "--cmd list"},
{"m1", do_m1, "[m1 <addr> <value>]", "--modify address byte"},
{"m4", do_m4, "[m4 <addr> <value>]", "--modify address word"},
/*foc*/
{"foc", tim_foc, "[tim_foc]", "--tim_foc "},
{"foc_adjust", foc_speed_test, "[tim_foc]", "--tim_foc "},
{"foc_speed", foc_speed_set, "[tim_foc]", "--tim_foc "},
/*bldc*/
{"mt", tim_motor, "[mt]", "--tim motor test "},
{"ss", speed_set, "[ss]", "--speed_set "},
{"sks", speed_keyset, "[sks]", "--speed_set "},
/*dcm*/
{"dcm1", tim_dcm, "[tim_dcm]", "--tim_dcm "},
{"ss1", speed_set_dcm, "[speed_set]", "--speed_set "},
{"sks1", speed_keyset_dcm, "[speed_keyset]", "--speed_keyset "},
{"dcm2", tim_dcm_enc, "[tim_dcm_enc]", "--tim_dcm_enc "},
{"ss2", enc_speed_set, "[speed_set]", "--speed_set "},
{"sks2", enc_speed_keyset, "[speed_keyset]", "--speed_keyset "},
{"enc", show_local, "[show_local]", "--show_local "},
/*steer*/
{"steer", tim_steer, "[tim_steer]", "--tim_steer "},
{"ags", angle_set, "[angle_set]", "--angle_set "},
{"agks", angle_keyset, "[angle_keyset]", "--angle_keyset "},
{"coremark", coremark_test, "[coremark test]", "coremark_test"},
/*general*/
{"wdg", watch_dog, "[wdg test", "--v1"},
{"crc", crc, "[crc]", "--crc test"},
{"dma", dma_ram, "[dma_ram]", "--dma_ram test"},
{"key", key, "[key]", "--key test"},
{"key_int", key_int, "[key]", "--key int test"},
{"adc_single", adc_single_test, "[adc]", "--adc single test"},
{"adc_regular", regular_test, "[adc]", "--adc regular test"},
{"atim_int", atim_int, "[tim]", "--atim int test"},
{"btim_int", btim_int, "[tim]", "--btim int test"},
{"tim_test", tim_test, "[tim]", "--tim"},
{"spinit", myspi_init, "[spi]", "--spi_init"},
{"sperase", spi_erase, "[spi]", "--spi_init"},
{"spw", spi_dma_write, "[spi]", "--spi_dma_write"},
{"spr", spi_dma_read, "[spi]", "--spi_dma_read"},
{"sflash", spi_flash, "[spi_flash]", "--v1"},
{"adc_tim_int", tim_int, "[tim]", "--adc tim int test"},
{"adc_tim", adc_tim_test, "[adc]", "--adc tim test"},
{"u1init", uart1_init , "[uart1]", "--uart1_init"},
{"u1tx", uart1_dma_tx , "[uart1]", "--uart1_dma_tx"},
{"u1rx", uart1_dma_rx , "[uart1]", "--uart1_dma_rx"},
{"i2cinit", i2c_init, "[i2c]", "--i2c_init"},
{"i2crec", i2c_recover, "[i2c]", "--i2c_recover"},
{"i2cw", i2c_wr, "[i2c]", "--i2cw"},
{"i2cm", i2c_wr_master, "[i2c]", "--i2cr"},
{"i2cs", i2c_wr_slaver, "[i2c]", "--i2cr"},
{"i2cr", i2c_rd, "[i2c]", "--i2cr"},
{"copy", copy, "[copy]", "--batdet <n>"},
{"copy_iram", copy_iram, "[copy]", "--batdet <n>"},
{"delay", delay, "[latimer]", "--latimer"},
{"latimer", latimer, "[core timer test]", "--v1"},
{"date", date, "[rtc test]", "--v1"},
{"wakeup", wakeup, "[wakeup test]", "--v1"},
{"ry", ry, "[ymodem]", "--v1"},
{"t", tmp, "[tmp]", "--v1"},
{"NULL", do_nothing, "NULL", "NULL"}
};
int do_exit(int argc, void *argv[])
{
}
int do_help(int argc, void *argv[])
{
unsigned int i;
char *s;
switch(argc)
{
case 1:
{
printf("\ncommands:\n\n");
for(i=0;strcmp("NULL", cmd[i].cmdname)!=0; i++)
{
printf("\t %2d:%s\n\r",i+1, cmd[i].cmdname);
}
}
break;
case 2:
{
s = (char *)argv[1];
for(i=0; strcmp("NULL", cmd[i].cmdname)!=0; i++)
{
if(strcmp(s, cmd[i].cmdname)==0)
{
printf("\n\t%s\t%s\t%s\n", cmd[i].cmdname, cmd[i].usage, cmd[i].expression);
break;
}
}
if(strcmp("NULL", cmd[i].cmdname)==0)
{
printf("\n\tERROR: undefine command!!!\n");
}
}
break;
default:
printf("\n usage: help <cmd>\n\r");
break;
}
return 0;
}
int cmdline(void)
{
TIM6_timebase();
INT_EN = 0x0;
char c;
char cmdbuffer[80];
char cmdpara[8][30];
int (*op)(int argc, void *argv[]);
char *p[8];
char *cmdptr;
short cp, i, j, k, num;
short h = 0;
int tmp = 11;
char history_str[13][80];
for(j=0;j<13;j++)
{
for(i=0; i<80; i++)
{
history_str[j][i] = '\0';
}
}
while(1)
{
START:
for(i=0; i<80; i++)
{
cmdbuffer[i] = '\0';
}
printf("\n$ ");
cmdptr = cmdpara[0];
cp = 0;
while(1)
{
c = getchar();
//printf("%x",c);
if((c>0x1f)&&(c<0x7f))
{
if(h > 0)
{
for(i=0; i<h ; i++)
{
cmdbuffer[cp-i] = cmdbuffer[cp-i-1];
}
cmdbuffer[cp-h] = c;
cp++;
for(i=h; i>=0; i--)
{
putchar(cmdbuffer[cp-i]);
}
for(i=0; i<cp-1; i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
}
for(i=0; cmdbuffer[i]; i++)
{
putchar(cmdbuffer[i]);
}
for(i=h; i>0; i--)
{
putchar(0x08);
}
}
else
{
cmdbuffer[cp++] = c;
putchar(c);
}
}
else if(c == 0x8)
{
if((h != 0) && (cp-h > 0))
{
for(i=h; i>=0; i--)
{
putchar(cmdbuffer[cp-i]);
}
for(i=0; i<cp; i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
}
for(i=h; i>0 ; i--)
{
cmdbuffer[cp-i-1] = cmdbuffer[cp-i];
}
cmdbuffer[--cp] = '\0';
for(i=0; cmdbuffer[i]; i++)
{
putchar(cmdbuffer[i]);
}
for(i=h; i>0; i--)
{
putchar(0x08);
}
}
else
{
if((cp != 0) && (h == 0))
{
cmdbuffer[--cp] = '\0';
putchar(0x8);
putchar(0x20);
putchar(0x8);
}
}
}
else if((c==0xa) || (c==0xd))
{
if(cmdbuffer[0] == '\0')
{
goto START;
}
h = 0;
tmp = 11;
for(j=0;cmdbuffer[j];j++)
{
history_str[11][j] = cmdbuffer[j];
}
break;
}
/****************************************************************************/
else if(c==0x1b)
{
c = getchar();
if(c==0x5b)
{
c = getchar();
switch(c)
{
case 0x44:
if(h < cp)
{
putchar(0x8);
h++;
}
else
h = cp;
break;
case 0x41:
if(tmp>=1)
{
if(tmp==1)
{
tmp = 1;
break;
}
else
tmp--;
for(; h != 0; h--)
{
putchar(cmdbuffer[cp-h]);
}
if((cmdbuffer[0] != 0)||(cp == 0))
{
for(i=0;cmdbuffer[i];i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
cmdbuffer[i] = '\0';
}
}
else
{
for(i=0;history_str[tmp+1][i];i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
}
}
for(j=0;history_str[tmp][j];j++)
{
cmdbuffer[j] = history_str[tmp][j];
putchar(cmdbuffer[j]);
}
}
cp = j;
break;
case 0x43:
if(h > 0)
{
putchar(cmdbuffer[cp-h]);
h--;
}
else
h = 0;
break;
case 0x42:
if(tmp <= 11)
{
if(tmp == 11)
{
tmp = 11;
break;
}
else
tmp++;
for(; h != 0; h--)
{
putchar(cmdbuffer[cp-h]);
}
if((cmdbuffer[0] != 0)||(cp == 0))
{
for(i=0;cmdbuffer[i];i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
cmdbuffer[i] = '\0';
}
}
else
{
for(i=0;history_str[tmp-1][i];i++)
{
putchar(0x8);
putchar(0x20);
putchar(0x8);
}
}
for(j=0;history_str[tmp][j];j++)
{
cmdbuffer[j] = history_str[tmp][j];
putchar(cmdbuffer[j]);
}
}
cp = j;
break;
default :
break;
}
}
c = 0;
}
/***********************************************************************/
}
/***********************************************************************/
if(tmp == 11)
{
for(j=1;j<12;j++)
{
for(i=0;i<30;i++)
history_str[j][i]=history_str[j+1][i];
}
for(i=0; i<30; i++)
{
history_str[11][i] = '\0';
}
}
/***********************************************************************/
if(cp == 0)
{
goto START;
}
else
{
for(i=0; i<8; i++)
for(j=0; j<30; j++)
cmdpara[i][j] = '\0';
num = 0; //argc
// printf("\ncmd:%s\n", cmdbuffer);
for(j = 0,i=0; i<cp; i++) //xpj
{
if(cmdbuffer[i] == 0x20) //space
{
if((cmdbuffer[i+1] != 0x20) && ((cmdbuffer[i+1] != '\0')))
{
j = 0;
num++;
cmdptr = cmdpara[num];
}
}
else
{
*(cmdptr + j) = cmdbuffer[i];
j++;
}
}
cmdptr = cmdpara[0];
if(strcmp(cmdptr, cmd[0].cmdname)==0)
{
break;
}
else
{
for(k=1; strcmp("NULL", cmd[k].cmdname)!=0; k++)
{
if(strcmp(cmdptr, cmd[k].cmdname)==0)
{
op = cmd[k].func;
for(j=0; j<=num; j++)
{
p[j] = (char *)(cmdpara[j]);
// printf("cmdpara[%d]: %s\n", j, cmdpara[j]);
}
op(j, (void *)p);
break;
}
}
if(strcmp("NULL", cmd[k].cmdname)==0)
{
printf("\n\tERROR: undefine command!!!\n");
}
}
}
}
return 0;
}
int main(void)
{
/*Clock Init*/
SystemClockInit();
/*IoRemap Init*/
GPIOInit();
/*WDT Init*/
WdgInit();
/*Serial Init*/
UartInit();
ls1x_logo();
PMU_RstSrc RstSrc = PMU_GetRstRrc();
if (RstSrc == PMU_RSTSRC_ext)
{
if (PMU_GetBootSpiStatus())
{
printf("\r\nspi boot");
}
/*Intr Init */
EnableInt();
cmdline();
}
else if (RstSrc == PMU_RSTSRC_wdg)
{
printf("\r\ndog bark!");
cmdline();
}
else if (RstSrc == PMU_RSTSRC_wake)
{
wakeup_reset();
}
return 0;
}