liyepan/La1c102TmpProject
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
liyp
2026-08-25 21:47:54 -04:00
commit c83cd9040d
9 changed files with 2304 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
System/Startup/serial.S
+77
View File
@@ -0,0 +1,77 @@
#include "start.h"
#include "regdef.h"
#include "csrdef.h"
#include "tools-asm.h"
.global serial_out
serial_out:
//v0 > a4
10: li.w a4, UART0_BASEADDR
ld.bu a4, a4, 0x5
andi a4, a4, 0x20
beqz a4, 10b
li.w t0, UART0_BASEADDR
st.b a0, t0, 0x0
jr ra
.global outputaddr
outputaddr:
addi.w sp, sp, -4
st.w ra, sp, 0
la a2, hexdecarr
li.w t1, 0xf0000000
li.w t2, 8
li.w t3, 28
ori a1, a0, 0
1:
beq t2, zero, 1f
and t0, a1, t1
srl.w t0, t0, t3
add.w t0, t0, a2
ld.bu t4, t0, 0
ori a0, t4, 0
bl serial_out
srli.w t1, t1, 4
addi.w t3, t3, -4
addi.w t2, t2, -1
b 1b
1:
li.w a0, 0xa
bl serial_out
ld.w ra, sp, 0
addi.w sp, sp, 4
jr ra
.global outputstring
outputstring:
// v1 > a5
// v0 > a4
move a5, a0
1:
ld.bu t0, a5, 0
beq t0, zero, 1f
10:
li.w a4, UART_BASEADDR
ld.bu a4, a4, 0x5
andi a4, a4, 0x20
beqz a4, 10b
li.w a3, UART_BASEADDR
st.b t0, a3, 0
addi.w a5, a5, 1
b 1b
1:
li.w a4, UART_BASEADDR
ld.bu a4, a4, 0x5
andi a4, a4, 0x40
beqz a4, 1b
jr ra
.section .rodata
.align 5
.global msg_wakeup
msg_wakeup:
.asciz "wakeup!\n"
hexdecarr:
.asciz "0123456789abcdef"
System/Startup/start.S
+141
View File
@@ -0,0 +1,141 @@
#include "regdef.h"
#include "csrdef.h"
#include "tools-asm.h"
#include "start.h"
/* start address for the initialization values of the .data section. defined in ld.script */
.word _sidata
/* start address for the .data section. defined in ld.script */
.word _sdata
/* end address for the .data section. defined in ld.script */
.word _edata
/* start address for the .bss section. defined in ld.script */
.word _sbss
/* end address for the .bss section. defined in ld.script */
.word _ebss
.globl _RAM_BSS
_RAM_BSS = BSS_BASE
.globl _RAM_DATA
_RAM_DATA = DATA_BASE
.section .text._start # begin code segment
.weak _start
.type _start, %function
.globl _start
#All Exception Entries
_start:
move t1 , zero
b LoopCopyDataInit
CopyDataInit:
la.abs t3, _sidata
add.w t4, t3, t1
ld.w t3, t4, 0x0
add.w t4, t0, t1
st.w t3, t4, 0x0
addi.w t1, t1, 0x4
LoopCopyDataInit:
la.abs t0, _sdata
la.abs t3, _edata
add.w t2, t0, t1
bne t2, t3, CopyDataInit
/* clear bss */
la.abs t0, _sbss
la.abs t1, _ebss
beq t1, t0, cpu_init_start
LoopFillZerobss:
st.w zero, t0, 0
addi.w t0, t0, 4
bne t1, t0, LoopFillZerobss
#set up basic system function
/* cpu init*/
cpu_init_start:
### reset normal exception base and Ex config
li.w t0, 0x1c001000
csrwr t0, CSR_EBase
li.w t0, (0<<S_CSR_ExConfig_VS)|(0x0000<<S_CSR_ExConfig_IM) # 4 instruction gap
csrwr t0, CSR_ExConfig
#set int masks
li.w t0, 0x1fff
csrxchg t0, t0, CSR_ExConfig
##set VSEG4(0x80000000~0x9fffffff) to cached, other VSEG to uncached
li.w t0, CACHE_OP
csrwr t0, CSR_SEGCA
##set VSEG4(0x80000000~0x9fffffff) to PSEG0(0x00000000~0x1fffffff), other VSEG unchanged
li.w t0, ADDR_MAP
csrwr t0, CSR_SEGPA
##set DA=0(change DA-mode to AD-mode)
li.w t0, 0x8
csrxchg zero, t0, CSR_CRMD
li.w sp, SP_BASE
bl main
jirl zero, ra, 0
.globl cpu_wait
cpu_wait:
idle 0
jr ra
.org 0x1000
DEFAULT_INT_HANDLER:
SAVE_REGS_FAST(REGS_MEM)
csrrd t0, CSR_ExStatus
andi t1, t0, INT_VECTOR
beqz t1, exception_core_check
exception_pmu:
andi t1,t0,0x4
bnez t1,wake_label
andi t1,t0,0x8
bnez t1,touch_label
andi t1,t0,0x10
bnez t1,uart2_label
andi t1,t0,0x20
bnez t1,bcc_label
andi t1,t0,0x80
bnez t1,exint_label
andi t1,t0,0x800
bnez t1,timer_label
wake_label:
bl TIMER_WAKE_INT
b exception_exit
touch_label:
bl TOUCH
b exception_exit
uart2_label:
bl UART2_INT
b exception_exit
bcc_label:
bl BAT_FAIL
b exception_exit
exint_label:
bl ext_handler
b exception_exit
timer_label:
bl TIMER_HANDLER
b exception_exit
exception_core_check:
andi t1, t0, INTC_VECTOR
beqz t1, exception_exit
bl intc_handler
b exception_exit
exception_exit:
RESTORE_REGS_FAST(REGS_MEM)
ertn
System/Startup/wakeup.S
+28
View File
@@ -0,0 +1,28 @@
#include "regdef.h"
#include "csrdef.h"
#include "tools-asm.h"
#include "start.h"
.global cpu_sleep
cpu_sleep:
SAVE_REGS_ALL(REGS_MEM)
dbar 0
li.w t1, PMU_BASE
1: ld.w t0, t1,PMU_CommandW
andi t0, t0, 0x1
beqz t0, 1b
st.w t0, t1,PMU_CommandW
idle 0
.global wakeup_reset
wakeup_reset:
la a0, msg_wakeup
bl outputstring
RESTORE_REGS_ALL(REGS_MEM)
csrwr t0, CSR_KScratch1
/*enable interrupt*/
li.w t0, 0x4
csrxchg t0, t0, CSR_CRMD //enter pmu_handler
csrrd t0, CSR_KScratch1
jirl zero, ra, 0
System/Sys/ls1c102_Interrupt.c
+409
View File
@@ -0,0 +1,409 @@
#include "../driver/calIn8M.h"
#include"ls1x.h"
#include"ls1x_gpio.h"
#include"ls1x_wdg.h"
#include"ls1x_common.h"
#include"ls1x_exti.h"
#include"ls1c102_interrupt.h"
#include"ls1c102_touch.h"
#include"ls1c102_ptimer.h"
#include"ls1c102_i2c.h"
#include"Config.h"
#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_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_gpioc0_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C0);
}
void exti_gpioc1_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C1);
}
void exti_gpioc2_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C2);
}
void exti_gpioc3_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C3);
}
void exti_gpioc4_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C4);
}
void exti_gpioc5_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C5);
}
void exti_gpioc6_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C6);
}
void exti_gpioc7_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_C7);
}
void exti_gpiod0_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D0);
}
void exti_gpiod1_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D1);
}
void exti_gpiod2_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D2);
}
void exti_gpiod3_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D3);
}
void exti_gpiod4_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D4);
}
void exti_gpiod5_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D5);
}
void exti_gpiod6_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D6);
}
void exti_gpiod7_irq_handler(void)
{
BEBUG_IRQ();
EXTI_ClearITPendingBit(EXTI, IRQ_GPIO_D7);
}
void (* const Ext_IrqHandle[32])(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_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_gpioc0_irq_handler,
exti_gpioc1_irq_handler,
exti_gpioc2_irq_handler,
exti_gpioc3_irq_handler,
exti_gpioc4_irq_handler,
exti_gpioc5_irq_handler,
exti_gpioc6_irq_handler,
exti_gpioc7_irq_handler,
exti_gpiod0_irq_handler,
exti_gpiod1_irq_handler,
exti_gpiod2_irq_handler,
exti_gpiod3_irq_handler,
exti_gpiod4_irq_handler,
exti_gpiod5_irq_handler,
exti_gpiod6_irq_handler,
exti_gpiod7_irq_handler,
};
void ext_handler(void)
{
PMU_CMDW = (1 << 24);
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 SOFT_INT(void)
{
printf("\n.............SOFT_INT..............\n\r");
Set_soft_stop();
}
/***********************************************************************
函数功能: 8M定时器中断处理函数
@param: 无
@other: 无
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
void TIMER_8M_INT(void)
{
PMU_CMDW = (1 << 21); // 清除中断标志
Set_Timer_clear();
Set_Timer_Init(8 * 10000); // 1.25ms
}
/***********************************************************************
函数功能: 定时唤醒中断处理函数
@param: 无
@other: 睡眠下定时喂狗，防止系统复位
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
void TIMER_WAKE_INT(void)
{
//printf("\n.............TIMER_WAKE_INT..............\n\r");
PMU_CMDW = (1 << 16); // 清除中断标志
INT32U SleepEn = PMU_CMDSTS & 0xffffffff;
WDG_DogFeed();
//睡眠后，定时喂狗，否则会不断重启
}
/***********************************************************************
函数功能: 触摸按键中断处理函数
@param: 无
@other: 无
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
#define KEY_CANCLE 8
void TOUCH(void)
{
INT8U i;
INT16U KeyChannel;
INT8U KeyType;
KeyChannel = (TS_STAT >> 16) & 0xfff;
KeyType = TS_STAT & 0xf;
PMU_CMDW = (1 << 17); // 清除中断标志
TS_STAT = 0xf;
printf("\n---touchInt:KeyChannel:0x%x\n",KeyChannel);
// Printf_KeyType(KeyType);
// Printf_KeyChannel(KeyChannel);
// Printf_KeyVal();
}
/***********************************************************************
函数功能: 串口2接收中断处理函数
@param: 无
@other: 无
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
void UART2_INT(void)
{
PMU_CMDW = (1 << 18);
INT8U uart_sr = UART2_IIR;
}
/***********************************************************************
函数功能: 电量检测中断处理函数
@param: 无
@other: 该中断可查看用户手册
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
void BAT_FAIL(void)
{
uint32_t tmp = (PMU_CMDSTS & 0xf80000)>>19;
PMU_CMDW = (PMU_CMDSTS & 0xf80000);
switch(tmp){
case 0x1:
printf("\n.............BAT_FAIL..............\n\r");
PMU_CMDSTS = 0x0; // IT config
break;
case 0x2:
break;
case 0x4:
break;
case 0x8:
break;
case 0x10:
printf("\n.............ADC..............\n\r");
PMU_CMDSTS &= (~0x8000); // IT dis
break;
default:
break;
}
}
/***********************************************************************
函数功能: INTC中断处理函数
@param: 无
@other: 该中断可查看用户手册
@return: 无
@auther : 朱晓宇
@time : 2020年4月9日
***********************************************************************/
void intc_handler(void)
{
INT8U IntReg = INT_OUT;
if(IntReg & IRQ_TIMER)//Timer
{
if(TIM_GetITStatus(TIM_FLAG_Trigger))
{
TIM_ClearIT(TIM_FLAG_Trigger);
printf("Peripherals Timer clear interrupt..\n");
}
}
if (IntReg & UART1_INT_OUT) //Uart1
{
uint8_t chr = UART1_RxData ;
printf("uart1 recv:0x%x\n",chr);
INT_CLR = UART1_INT_CLR;
}
if (IntReg & UART0_INT_OUT) //Uart0
{
uint8_t chr = UART0_RxData ;
// printf("uart0 recv:0x%x\n",chr);
recv_dat_int(chr);
INT_CLR = UART0_INT_CLR;
}
INT_CLR = 0xff;
}
void TIMER_HANDLER(void)
{
Set_Timer_clear();
printf("Core Timer clear interrupt..\n");
Set_Timer_stop();
}
System/Sys/ls1c102_cmd.c
+996
View File
@@ -0,0 +1,996 @@
#include "ls1c102_ptimer.h"
#include "ls1x_common.h"
#include "ls1x_gpio.h"
#include "ls1x_exti.h"
#include "ls1x_latimer.h"
#include "ls1x_rtc.h"
#include "ls1c102_touch.h"
#include "ls1x_string.h"
#include "ls1x_wdg.h"
#include "ls1x_uart.h"
#include "ls1x_spi.h"
#include "ls1c102_i2c.h"
#include "Config.h"
#include "ls1c102_touch.h"
extern void cpu_sleep(void);
extern void dma_start(INT32U source, INT32U count, INT32U mode);
extern void dma_reset(void);
unsigned int str2num(unsigned char *);
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;
}
uint32_t 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 uint8_t*)(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;
}
/*VPWM:0xbfec0020 0x309817b0 single signal period/2 */
/*VPWM:0xbfec0020 0x70a817b0 double signal period/2*/
/*VPWM:0xbfec0020 0x72980ff0 16Khz*/
int v_play(int argc, void *argv[])
{
if(argc != 3)
{
printf("\n usage: v <addr> <num>\n\r");
return 1;
}
unsigned int addr, count;
addr = str2num(argv[1]);
count = str2num(argv[2]);
dma_reset();
printf("VPWM dma ad test started \n");
dma_start(addr, count, 0x1);
printf("VPWM dma ad test end\n");
return 0;
}
// touch show
int touch_reg_show()
{
printf("\nTsensor:\n");
printf("TS_Ctrl = 0x%8x\n", TS_CTRL);
printf("TS_OscTh = 0x%8x\n", TS_OSCTH);
printf("TS_PollTim = 0x%8x\n", TS_POLLTIM);
printf(" ChnAttr CntRes\n");
int i;
for (i=0; i<12; i++)
printf("[%2d] = 0x%8x 0x%8x\n", i, TS_CHNATTR(i), TS_CNTRES(i));
return 0;
}
int touch_value_show()
{
printf("\n 00 01 02 03 04 05 06 07 08 09 10 11\n");
int i;
printf("basval");
for (i=0; i<12 ; i++)
printf(" %4d", TOUCH_GetBaseVal(i));
printf("\ncntval");
for (i=0; i<12; i++)
printf(" %4d", TOUCH_GetCountValue(i));
return 0;
}
int touch_test(int argc, void *argv[])
{
if (!strcmp("init",argv[1]))
{
if (argc != 3)
{
printf("\n touch init <down_th>.");
return 1;
}
printf("\n Touch Init");
INT8U down_th = str2num(argv[2]);
TOUCH_Init(down_th);
}
else if (!strcmp("scan",argv[1]) & argc==2)
{
printf("\n Touch Scan");
TOUCH_EnableSingleScan();
Printf_CountVal();
}
else if (!strcmp("down",argv[1]))
{
printf("\n Touch DownTh");
INT8U down_th = str2num(argv[2]);
INT8U channel;
if(argc == 3) //All Channel
{
for(channel=0; channel<CHANNEL_NUM; channel++)
{
TOUCH_SetDownTh(channel, down_th);
}
}
else if (argc == 4) //Single Channel
{
channel = str2num(argv[3]);
{
TOUCH_SetDownTh(channel, down_th);
}
}
else
{
printf("\n touch down <down_th> <channel>");
return 1;
}
}
else if (!strcmp("poll",argv[1]) & argc==2)
{
printf("\n Touch Poll.");
TOUCH_EnablePollScan();
}
else if (!strcmp("show",argv[1]) & argc==2)
{
touch_reg_show();
touch_value_show();
}
else
{
printf("\n Input Error.");
printf("\nUsage: touch init <down_th> \
\n touch down <down_th> <channel> \
\n touch scan \
\n touch poll \
\n touch show");
return 1;
}
return 0;
}
int hpet(int argc, void *argv[])
{
printf("\r\n hpet timer start....\n");
uint32_t periodic,cmp,stp;
if(argc < 4)
{
TIM_Cmd(0);
TIM_ITConfig(0);
printf("\r\n Usage: hpet <periodic> <start_ms> <sec>");
return 1;
}
periodic = str2num(argv[1]);
cmp = str2num(argv[2]);
stp = str2num(argv[3]);
TIM_InitTypeDef TIM_InitStruct;
TIM_StructInit(&TIM_InitStruct);
TIM_InitStruct.TIME_PERIODIC = periodic << 2;
TIM_InitStruct.TIME_CMP = cmp * 7999;
TIM_InitStruct.TIME_STP = stp * 8000000;
TIM_Init(&TIM_InitStruct);
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 delay(int argc, void *argv[])
{
uint32_t 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;
}
int wakeup(int argc, void *argv[])
{
uint32_t sec;
printf("\r\nTimer Wake Up start....argc:%d\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;
}
uint32_t a_to_n(uint8_t 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;
}
uint32_t rtc0, rtc1;
uint32_t yy, mm, dd, h, m, s;
uint32_t invalid_param;
uint8_t *rtc1_str, *rtc0_str;
tsRtcTime rtc_param;
rtc1_str = (uint8_t*) argv[2];
rtc0_str = (uint8_t*) 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;
}
uint32_t mm, dd, h, m, s;
uint32_t invalid_param;
uint8_t *cfg_str0,*cfg_str1;
tsRtcTime rtc_param;
cfg_str0 = (uint8_t*) argv[2];
cfg_str1 = (uint8_t*) 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
{
uint32_t freq_in = str2num(argv[2]);
if (freq_in <30000 | freq_in > 50000)
{
printf("\r\nshould be close to 32768 Hz\r\n");
return 1;
}
uint32_t 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");
uint32_t 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;
}
}
int watch_dog(int argc, void *argv[])
{
uint32_t 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 i2cp (int argc, void *argv[])
{
I2C_InitTypeDef I2C_InitStruct;
I2C_StructInit(&I2C_InitStruct);
I2C_Init(I2C,&I2C_InitStruct);
}
int i2cw (int argc, void *argv[])
{
if (argc !=4)
{
printf("\n usage: i2cw <chipaddr> <regaddr> <wdata>\n");
return 1;
}
printf ("\r\n");
unsigned char chipaddr, regaddr, wdata;
chipaddr = str2num(argv[1]);
regaddr = str2num(argv[2]);
wdata = str2num(argv[3]);
unsigned short addr = ((chipaddr & 0xff) <<7) | regaddr & 0xff;
printf("wdata=0x%x",wdata);
printf("addr=0x%x",addr);
CAT24_Write(addr,wdata);
return 0;
}
int i2cr (int argc, void *argv[])
{
if (argc !=3)
{
printf("\n usage: i2cr<chipaddr><regaddr>\n");
return 1;
}
unsigned int chipaddr, regaddr, rdata;
chipaddr = str2num(argv[1]);
regaddr = str2num(argv[2]);
uint8_t read_data;
unsigned short addr = ((chipaddr & 0xff) <<7) | regaddr & 0xff;
read_data = CAT24_Read(addr);
printf("\r\n rdata 0x%02x\r\n", read_data);
return 0;
}
int adc(int argc, void* argv[])
{
uint32_t sel = str2num(argv[1]);
uint32_t div = str2num(argv[2]);
uint32_t wrong = ( sel>7 || div>2 || (argc<3 || argc>4) );
volatile uint32_t times = str2num(argv[3]);
uint32_t r;
if (wrong) {
printf("\r\nADC <sel> <div> <times>");
printf("\r\nsel: (0)ADC_I0, (1)ADC_I1, (2)VRCAP, (3)1.0V, (4)VROUT, (5)1.0V(vr1), (6)vref, (7)dacamc");
printf("\r\ndiv: 0: d2, 1: d4");
return 1;
}
PMU_CMDSTS = 0x8000; // IT en
while(times){
PMU_AdcCtrl = (div << 4) + sel; // ADC config
PMU_AdcCtrl |= 0x100; // run
uint32_t res = PMU_AdcDat;
printf("\r\ncalculate%d", (res*3350)>>12); // VDD: 3350 mV
times--;
}
PMU_CMDSTS &= (~0x8000); // IT dis
return 0;
}
int batdet (int argc, void* argv[])
{
if (argc != 2)
{
printf("\n usage: batdet <n> 0 ADC_I0, 1 GPIO0, 2 GPIO1\n");
return 1;
}
uint32_t bat_det_sel = str2num(argv[1]);
if (bat_det_sel ==0)
{
PMU_CHIPCTRL |= 0x20000;
}
if (bat_det_sel < 3)
{
switch (bat_det_sel) {
case 0:
PMU_CHIPCTRL &= 0xFCFFFFFF;
break;
case 1:
PMU_CHIPCTRL &= 0xFCFFFFFF;
PMU_CHIPCTRL |= (2 << 24);
break;
case 2:
PMU_CHIPCTRL &= 0xFCFFFFFF;
PMU_CHIPCTRL |= (3 << 24);
break;
}
}
else
{
printf("\r\nwrong parameter");
return 1;
}
PMU_CMDSTS = 0x800; // IT config
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()
{
FLASH_CAH_REG = 0xffffffff;
FLASH_CAL_REG = 0xffffffff;
int i, j;
FLASH_PET_REG = 0x10;
for (i=0xbf000000;i<0xbf020000;i=i+0x80)
{
FLASH_CMD_REG = ERASE_CMD|(i & 0x3ffff);
WDG_DogFeed();
printf(".");
FLASH_CMD_REG = CLRPL_CMD;
for (j=i;j<i+0x80;j=j+4)
{
*(volatile unsigned int*)(j) = *(volatile unsigned int*)(j-0x1000000);
if (j == 0xbf000000)
{
// printf("0xbf000000: %x\n",*(volatile unsigned int*)(j));
}
}
FLASH_CMD_REG = PAGE_CMD|(i & 0x3ffff);
}
for (i=0xbf000000;i<0xbf020000;i=i+0x80)
{
for (j=i;j<i+0x80;j=j+4)
{
if (*(volatile unsigned int*)(j) != *(volatile unsigned int*)(j-0x1000000))
{
printf("copy error\n");
}
}
}
return 0;
}
int uart_init(int argc, void *argv[])
{
if (argc != 2)
{
printf("\n usage: uinit <1/2> \n");
return 1;
}
uint32_t num = str2num(argv[1]);
if(num == 1)
{
Uart_init(UART1);
}
else if(num == 2)
{
Uart_init(UART2);
}
else
{
printf("\n usage: uinit <1/2> \n");
return 1;
}
return 0;
}
#if 0
int uart_tx(int argc, void *argv[])
{
if (argc != 2)
{
printf("\n usage: uart_tx <1/2> \n");
return 1;
}
uint32_t num = str2num(argv[1]);
if(num == 1)
{
uart1_printf("\r\nThis uart 1 tx test");
}else if(num == 2)
{
uart2_printf("\r\nThis uart 2 tx test");
}
else
{
printf("\n usage: utx <1/2> \n");
return 1;
}
return 0;
}
int uart_rx(int argc, void *argv[])
{
if (argc != 2)
{
printf("\n usage: uart_rx <1/2> \n");
return 1;
}
uint32_t num = str2num(argv[1]);
if(num == 1)
{
while(1)
{
char c1;
c1 = uart1_getchar();
if (c1 == 0x3)
{
printf("\r\nThis uart 1 rx test exit");
break;
}
}
}else if(num == 2)
{
while(1)
{
char c2;
c2 = uart2_getchar();
if (c2 == 0x3)
{
printf("\r\nThis uart 2 rx test exit");
break;
}
}
}
else
{
printf("\n usage: urx <1/2> \n");
return 1;
}
return 0;
}
#endif
void sleep(uint8_t sflags)
{
while(!(PMU_CMDSTS & 0x1));/*wail till can sleep*/
PMU_CMDW = 0x1ff0000;/*clear int*/
/*sflags=1 wakeup immediately,others do not wakeup*/
if(sflags)
{
Wake_Set(5);/*5s*/
}
else
{
#ifdef ATE_RUN
PMU_GPIOA_O = 0xffffffff;
PMU_GPIOB_OE = 0xfc;
PMU_GPIOB_O = PMU_GPIOB_O | 0xffffff03;
#else
PMU_GPIOA_OE = 0x0;
PMU_GPIOB_OE = 0x0;
PMU_GPIOA_OE = 0xffffffff;
PMU_GPIOB_OE = 0xffffffff;
#endif
}
cpu_sleep();
}
int spi_init(int argc, void* argv[])
{
uint16_t flash_id;
SPI->SPCR = 0x52; // enable mstr
SPI->PARAM = 0x20; // ~memory_en
flash_id = Spiflash_Rdid();
printf("\r\nid=0x%x\r\n",flash_id);
// SPI->PARAM = 0x23; // ~memory_en
}
int spi_write(int argc, void* argv[])
{
if (argc != 2)
{
printf("\n usage: swrite <addr> \n");
return 1;
}
uint32_t addr = str2num(argv[1]);
uint32_t i,k,j=0,count;
uint8_t *data;
printf("\n write start\n");
count = 512;
for(k=0;k<count;k++)
{
j=k*0x100;
for(i=0;i<0x100;i++)
{
data[i] = *(volatile uint8_t*)(0xbf000000+j+i);
}
printf(". ");
Spiflash_Page_Program(addr+j,data,0x100);
}
printf("\n");
return 0;
}
int spi_read(int argc, void* argv[])
{
if (argc != 2)
{
printf("\n usage: sread <addr> \n");
return 1;
}
uint32_t addr = str2num(argv[1]);
uint32_t i,j=0,k,count;
uint8_t* data;
printf("\n read start\n");
count = 512;
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*)(0xbf000000+j+i))
{
printf("\ncheck error rdata=%x iaddr=%x\n",data[i],0xbf000000+j+i);
break;
}
}
printf(". ");
}
printf("\n");
return 0;
}
int spi_erase(int argc, void* argv[])
{
if (argc != 2)
{
printf("\n usage: serase <addr> \n");
return 1;
}
uint32_t addr = str2num(argv[1]);
printf("\n erase start\n");
Spiflash_Block64k_Erase(addr);
Spiflash_Block64k_Erase(addr+0x10000);
return 0;
}
int spi_flash(int argc, void* argv[])
{
uint8_t *data;
uint16_t flash_id;
uint32_t addr = 0x0;
uint32_t i,k,j=0,count;
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);
Spiflash_Block64k_Erase(addr+0x10000);
/*Program */
printf("program start\n");
count = 512;
for(k=0;k<count;k++)
{
j=k*0x100;
for(i=0;i<0x100;i++)
{
data[i] = *(volatile uint8_t*)(0xbf000000+j+i);
}
Spiflash_Page_Program(addr+j,data,0x100);
printf(". ");
}
printf("\r\nprogram done\n");
printf("\r\ncheckout start\n");
count = 512;
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*)(0xbf000000+j+i))
{
printf("\ncheck error rdata=%x iaddr=%x\n",data[i],0xbf000000+j+i);
break;
}
}
printf(". ");
}
printf("\r\ncheck done\n");
return 0;
}
int gpio_int_test(void)
{
AFIO_RemapConfig(AFIOA, GPIO_Pin_1, GPIO_FUNC_GPIO);
AFIO_RemapConfig(AFIOC, GPIO_Pin_3, GPIO_FUNC_GPIO);
EXTI_InitTypeDef exti_gpio;
EXTI_StructInit(&exti_gpio);
exti_gpio.EXTI_GPIO = IRQ_GPIO_A1|IRQ_GPIO_C3;/*GPIOA1,GPIOC3*/
exti_gpio.EXTI_Mode = EXTI_Mode_Edge;
exti_gpio.EXTI_Trigger = EXTI_Trigger_Rising_High;
exti_gpio.EXTI_GpioCmd = ENABLE;
EXTI_Init(EXTI, &exti_gpio);
}
int gpio_int (int argc, void *argv[])
{
gpio_int_test();
return 0;
}
int tmp(int argc, void *argv[])
{
uint32_t tmp =0;
return 0;
}
int copy_iram(int argc, void *argv[])
{
unsigned int j;
printf("\r\ncopyiram start\r\n");
for (j = 0x0;j < 0x2000; j=j + 4)
{
*(volatile unsigned int*)(0x80000000+j) = 0x0;
}
for (j = 0x0;j < 0x2000; j=j + 4)
{
*(volatile unsigned int*)(0x80000000+j) = *(volatile unsigned int*)(0xbe010000 + j);
}
for (j = 0x0;j < 0x2000; j=j + 4)
{
if(*(volatile unsigned int*)(0x80000000+j) != *(volatile unsigned int*)(0xbe010000 + j))
{
printf("copy error %x,%x,%x\n",j,*(volatile unsigned int*)(0x80000000+j), *(volatile unsigned int*)(0xbe010000 + j));
}
}
asm volatile (\
"li.w $r12, 0x80000000;\n" \
"jirl $r0, $r12 , 0x0;\n"\
);
return 0;
}