void INTTB0_IRQHandler(void)
{
static uint32_t cnt = 0U;
if (cnt++ >= 1000U) {
UART_Print(UART0, "Once timer interrupt has happend\n\r");
cnt = 0U;
}
}
void FC_Basic(void)
{
FunctionalState tmp_value_sec0, tmp_value_sec1, tmp_value_block;
UART_Configuration(UART);
UART_Print(UART, "This is an example for FC\n\r");
/* Set security function "ENABLE" */
FC_SetSecurityBit(ENABLE);
UART_Print(UART, "Enable the Security Function\n\r");
/* Get security register value */
tmp_value_sec0 = FC_GetSecurityBit();
if (tmp_value_sec0 != ENABLE) {
UART_Print(UART, "Security register value is disable\n\r");
}else{
UART_Print(UART, "Security register value is enable\n\r");
}
/* Set security function "DISABLE" */
FC_SetSecurityBit(DISABLE);
UART_Print(UART, "Disable the Security Function\n\r");
/* Get security register value */
tmp_value_sec1 = FC_GetSecurityBit();
if (tmp_value_sec1 != DISABLE) {
UART_Print(UART, "Security register value is enable\n\r");
}else{
UART_Print(UART, "Security register value is diable\n\r");
}
/* Get Block 0 Protection status */
tmp_value_block = FC_GetBlockProtectState(FC_BLOCK_0);
UART_Print(UART, "Getting Block 0 Protection status\n\r");
if (tmp_value_block != DISABLE) {
UART_Print(UART, "The status is enable\n\r");
}else{
UART_Print(UART, "The status is diable\n\r");
}
/* Wait for Ready */
while (FC_GetBusyState() != DONE) {
/* Do nothing */
};
}
void Command_Dir(){
File dir = SD.open(cwd);
dir.rewindDirectory(); // this line cures headaches
char uart_str[32];
while(true){
File entry = dir.openNextFile();
if(!entry) break;
UART_Print(entry.name());
if(!entry.isDirectory()){
UART_Print("\t\t");
sprintf(uart_str, "%lu", entry.size());
UART_Print(uart_str);
}
UART_Print("\n\r");
entry.close();
}
dir.close();
}
void Command_Flash(){
char path[12];
uint8 pathlen = Command_GetArg(0, path, sizeof(path));
if(pathlen>12) pathlen = 12; // only 8.3 filenames are supported
if(pathlen == 0){
UART_Print("Usage: flash <firmware file>\n\r");
}else{
char pathtmp[sizeof(cwd)];
if(cwdlen+pathlen>sizeof(pathtmp)){
UART_Print("Resultant path is too long!\n\r");
return;
}
for(uint8 i=0;i<cwdlen;i++){
pathtmp[i] = cwd[i];
}
for(uint8 i=0;i<cwdlen;i++){
pathtmp[i] = cwd[i];
}
if(cwdlen>1){
pathtmp[cwdlen] = '/';
cwdlen++;
}
for(uint8 i=0;i<pathlen;i++){
pathtmp[cwdlen+i] = path[i];
}
if(cwdlen>1){
cwdlen--;
}
pathtmp[cwdlen+pathlen] = 0; // ensure string is null-terminated
if(SD.exists(pathtmp)){
BL_Flash(pathtmp);
}else{
UART_Print("File not found!\n\r");
}
}
}
void uart_print(void)
{
TSB_WD_MOD_WDTE = 0U;
TSB_WD->CR = 0x000000B1;
SIO_Configuration(UART0);
myUART.BaudRate = 115200U;
myUART.DataBits = UART_DATA_BITS_8;
myUART.StopBits = UART_STOP_BITS_1;
myUART.Parity = UART_NO_PARITY;
myUART.Mode = UART_ENABLE_TX;
myUART.FlowCtrl = UART_NONE_FLOW_CTRL;
UART_Enable(UART0);
UART_Init(UART0, &myUART);
UART_Print("Hello World!\n");
}
void TB0_print(void)
{
TMRB_InitTypeDef myTMRB;
WDT_Disable();
UART_Configuration(UART0);
UART_Print(UART0, "This is a TIMER example!\n\r\n\r");
myTMRB.Mode = TMRB_INTERVAL_TIMER;
myTMRB.ClkDiv = TMRB_CLK_DIV_8;
myTMRB.Cycle = TMRB_1ms; /* Specific value depends on system clock */
myTMRB.UpCntCtrl = TMRB_AUTO_CLEAR;
myTMRB.Duty = TMRB_1ms / 2U; /* Specific value depends on system clock */
TMRB_Enable(TSB_TB0);
TMRB_Init(TSB_TB0, &myTMRB);
TMRB_SetRunState(TSB_TB0, TMRB_RUN);
NVIC_EnableIRQ(INTTB0_IRQn);
while (1) {
/* Do nothing */
}
}
uint8 Settings_LoadFromCard() {
if (SD_IsCardReady()) {
if (SD.exists(CONFIG_FILENAME)) {
UART_Print("Loading config.txt from card...\n\r");
configFile = SD.open("config.txt", FILE_READ);
uint8 buf[32];
uint8 nread = configFile.read(buf, sizeof(buf));
while (nread > 0) {
Settings_ProcessBuffer(buf, nread);
nread = configFile.read(buf, sizeof(buf));
}
buf[0] = '\n';
Settings_ProcessBuffer(buf, 1);
configFile.close();
UART_Flush();
DelayMs(50); // Allow UART to clear
Settings_Save();
return 1;
}
}
return 0;
}
void process_char(uint8 c){
static char uart_str[50];
if(c=='\n' || c == '\r'){
if(keylen>0){
uint8 ret = process_keyvalue();
if(ret == 0){
UART_Print("Read ");
for(uint8 i=0;i<keylen;i++){
UART_Print(key[i]);
}
UART_Print(" ");
for(uint8 i=0;i<valuelen;i++){
UART_Print(value[i]);
}
UART_Print("\n\r");
}else if(ret==1){
UART_Print("Unrecognised key: \"");
for(uint8 i=0;i<keylen;i++){
UART_Print(key[i]);
}
UART_Print("\"\n\r");
}else if(ret==2){
UART_Print("Expected value after key: \"");
for(uint8 i=0;i<keylen;i++){
UART_Print(key[i]);
}
UART_Print("\"\n\r");
}
}
keylen = valuelen = 0;
state = STATE_WAITING_KEY;
}else{
if(state == STATE_WAITING_KEY){
if(c=='#'){
state = STATE_IN_COMMENT;
}else if(is_alpha(c)){
key[keylen++] = c;
state = STATE_IN_KEY;
}
}else if(state == STATE_IN_KEY){
if(is_alpha(c)){
if(keylen<sizeof(key)) key[keylen++] = c;
}else{
state = STATE_WAITING_VALUE;
valuelen = 0;
}
}else if(state == STATE_WAITING_VALUE){
if(is_alpha(c)){
value[valuelen++] = c;
state = STATE_IN_VALUE;
}
}else if(state == STATE_IN_VALUE){
if(valuelen<sizeof(value)) value[valuelen++] = c;
}
}
}
void RMC_DEMO(void)
{
TSB_RMC_TypeDef *RMCx;
RMC_InitTypeDef myRMC;
RMCx = TSB_RMC0;
RMC_Command = 0U;
SystemInit();
RMC_Configuration(RMCx); /*RMC IO initial */
__disable_irq();
TSB_CG->IMCGE = 0x00300000U;
TSB_CG->ICRCG = 0x00000012U;
TSB_CG->IMCGE = 0x00310000U;
#ifdef TOSHIBA_FORMAT_RMC
/*RMC register set for TOSHIBA format */
myRMC.LeaderPara.MaxCycle = RMC_MAX_CYCLE;
myRMC.LeaderPara.MinCycle = RMC_MIN_CYCLE;
myRMC.LeaderPara.MaxLowWidth = RMC_MAX_LOW_WIDTH;
myRMC.LeaderPara.MinLowWidth = RMC_MIN_LOW_WIDTH;
myRMC.LeaderPara.LeaderDetectionState = ENABLE;
myRMC.LeaderPara.LeaderINTState = DISABLE;
myRMC.FallingEdgeINTState = DISABLE;
myRMC.SignalRxMethod = RMC_RX_IN_CYCLE_METHOD;
myRMC.LowWidth = RMC_TRG_LOW_WIDTH;
myRMC.MaxDataBitCycle = RMC_TRG_MAX_DATA_BIT_CYCLE;
myRMC.LargerThreshold = RMC_LARGER_THRESHOLD;
myRMC.SmallerThreshold = RMC_SMALLER_THRESHOLD;
myRMC.InputSignalReversedState = DISABLE;
myRMC.NoiseCancellationTime = RMC_NOISE_CANCELLATION_TIME;
#endif
#ifdef RC5_FORMAT_RMC
/*RMC register set for RC5 format */
myRMC.LeaderPara.MaxCycle = RMC_MAX_CYCLE;
myRMC.LeaderPara.MinCycle = RMC_MIN_CYCLE;
myRMC.LeaderPara.MaxLowWidth = RMC_MAX_LOW_WIDTH;
myRMC.LeaderPara.MinLowWidth = RMC_MIN_LOW_WIDTH;
myRMC.LeaderPara.LeaderDetectionState = DISABLE;
myRMC.LeaderPara.LeaderINTState = DISABLE;
myRMC.FallingEdgeINTState = DISABLE;
myRMC.SignalRxMethod = RMC_RX_IN_PHASE_METHOD;
myRMC.LowWidth = RMC_TRG_LOW_WIDTH;
myRMC.MaxDataBitCycle = RMC_TRG_MAX_DATA_BIT_CYCLE;
myRMC.LargerThreshold = RMC_LARGER_THRESHOLD;
myRMC.SmallerThreshold = RMC_SMALLER_THRESHOLD;
myRMC.InputSignalReversedState = ENABLE;
myRMC.NoiseCancellationTime = RMC_NOISE_CANCELLATION_TIME;
#endif
/* Enable and config the function for RMC channel */
RMC_Enable(RMCx);
RMC_Init(RMCx, &myRMC);
/* RMC Reception enable */
RMC_SetRxCtrl(RMCx, ENABLE);
/* Enable the Receive interrupt for RMC channel */
/* RMC0 should to enable INTRMCRX0_IRQn, RMC1 should to enable INTRMCRX1_IRQn. */
NVIC_EnableIRQ(INTRMCRX0_IRQn);
__enable_irq();
do {
if (fRMCRx) {
sprintf(message, "RMC DATA: 0x%x\n", RMC_Command );
UART_Print(UART, message); /*printf RMC read data */
fRMCRx = None;
}
} while (1);
}
/* SSP_LoopBack function */
void SSP_LoopBack(void)
{
SSP_InitTypeDef initSSP;
SSP_FIFOState fifoState;
uint16_t datTx = 0U; /* must use 16bit type */
uint32_t cntTx = 0U;
uint32_t cntRx = 0U;
uint16_t receive = 0U;
uint16_t Rx_Buf[MAX_BUFSIZE] = { 0U };
uint16_t Tx_Buf[MAX_BUFSIZE] = { 0U };
SystemInit();
/* enable the LED on board to display some info */
UART_Configuration(UART);
UART_Print(UART, "This is an example for SSP module!\n\r");
/* configure the SSP module */
initSSP.FrameFormat = SSP_FORMAT_SPI;
/* default is to run at maximum bit rate */
initSSP.PreScale = 2U;
initSSP.ClkRate = 1U;
/* define BITRATE_MIN to run at minimum bit rate */
/* BitRate = fSYS / (PreScale x (1 + ClkRate)) */
#ifdef BITRATE_MIN
initSSP.PreScale = 254U;
initSSP.ClkRate = 255U;
#endif
initSSP.ClkPolarity = SSP_POLARITY_LOW;
initSSP.ClkPhase = SSP_PHASE_FIRST_EDGE;
initSSP.DataSize = 16U;
initSSP.Mode = SSP_MASTER;
SSP_Init(&initSSP);
/* enable loop back mode for self test */
SSP_SetLoopBackMode(ENABLE);
/* enable and run SSP module */
SSP_Enable();
while (1) {
datTx++;
/* send data if Tx FIFO is available */
fifoState = SSP_GetFIFOState(SSP_TX);
if ((fifoState == SSP_FIFO_EMPTY) || (fifoState == SSP_FIFO_NORMAL)) {
SSP_SetTxData(datTx);
if (cntTx < MAX_BUFSIZE) {
Tx_Buf[cntTx] = datTx;
cntTx++;
} else {
/* do nothing */
}
} else {
/* do nothing */
}
/* check if there is data arrived */
fifoState = SSP_GetFIFOState(SSP_RX);
if ((fifoState == SSP_FIFO_FULL) || (fifoState == SSP_FIFO_NORMAL)) {
receive = SSP_GetRxData();
if (cntRx < MAX_BUFSIZE) {
Rx_Buf[cntRx] = receive;
cntRx++;
} else {
/* Place a break point here to check if receive data is right. */
/* Success Criteria: */
/* Every data transmited from Tx_Buf is received in Rx_Buf. */
/* When the line "#define BITRATE_MIN" is commented, the SSP is run in maxium */
/* bit rate, so we can find there is enough time to transmit date from 1 to */
/* MAX_BUFSIZE one by one. but if we uncomment that line, SSP is run in */
/* minimum bit rate, we will find that receive data can't catch "datTx++", */
/* in this so slow bit rate, when the Tx FIFO is available, the cntTx has */
/* been increased so much. */
__NOP();
}
} else {
/* do nothing */
}
sprintf(message, "Received data is %d\n\r" + (uint8_t)(receive / 8000));
UART_Print(UART, message);
}
}
void task1(void * pdata )
{
INT8U ch;
INT8U err;
static INT8U print_out_buf[60] = {0};
static INT8U scan_buf[90]= {0};
static UART_AT_STATE_TypeDef g_uart_at_state = UART_AT_STATE_AT;
//U10开机信号
static bool flag_start_u10_sig = true;
flag_start_u10_sig = true;
GPIO_WriteHigh(GPIOD,GPIO_PIN_2);//高
OSTimeDlyHMSM(0,0,4,0 );
GPIO_WriteLow(GPIOD,GPIO_PIN_2);
//cszdata=cszdata;
//UART_Print("AT\r\n");
//UART_Print("AT12345abcdefghijklmnopqrest\r\n");
//g_uart_at_state = UART_AT_STATE_AT;
g_uart_at_state = UART_AT_STATE_INIT2_REP;
//注意！在最高优先级任务循环前打开定时器中断，以满足在OSStart()前不产生中断的要求。
//在系统调用OSInit（）时会自动创建一个优先级最低的系统任务，创建过程中会调用OS_EXIT_CRITICAL（）打开EA。
//若在InitTimer0()里打开T0中断，则违反了在OSStart()前不产生中断的要求。
//切记将ET0=1;放在最高优先级任务里，OSStart()将调用OSStartHighRdy()第一个运行最高优先级任务，这样ET0=1总能被第一个执行。
//ET0=1;
for (;;)
{
#if 0
if(flag_start_u10_sig)//只执行一次 //U10开机信号
{
GPIO_WriteHigh(GPIOD,GPIO_PIN_2);//高
flag_start_u10_sig = false;
OSTimeDlyHMSM(0,0,4,0 );
// GPIO_WriteLow(GPIOD,GPIO_PIN_2);
// Delay(0x3ffff);
GPIO_WriteLow(GPIOD,GPIO_PIN_2);
}
#endif
#if ONE_FRAME_EN
//INT8U scan_buf[20]={0};
//printf("task1 \r\n");
//UART_Print("AT\r\n");
//OSTimeDlyHMSM(0,0,0,20);
// CommPutChar('9', OS_TICKS_PER_SEC);
// CommPutChar('\r', OS_TICKS_PER_SEC);
// CommPutChar('\n', OS_TICKS_PER_SEC);
UART_Scan(scan_buf);
#if DEBUG_EN
if(scan_buf[0] != '\0')
{
sprintf(print_out_buf,"YOU SEND: %s\r\n",scan_buf);
UART_Print(print_out_buf);
memset(scan_buf,0,60);
}
#endif
#if 0
if(strstr((char const *)scan_buf, "abcdef"))
{
UART_Print("YOU SEND: abcdef\r\n");
}
#endif
#if 1
switch(g_uart_at_state)
{
case UART_AT_STATE_INIT2_REP:
if(strstr((char const *)scan_buf, "+INIT: 2"))
{
UART_Print("AT\r\n");
g_uart_at_state = UART_AT_STATE_AT;
}
break;
case UART_AT_STATE_AT:
if(strstr((char const *)scan_buf, "OK"))
{
UART_Print("ATI\r\n");
g_uart_at_state = UART_AT_STATE_ATI;
}
break;
case UART_AT_STATE_ATI:
if(strstr((char const *)scan_buf, "OK"))
{
UART_Print("AT+CREG?\r\n");
g_uart_at_state = UART_AT_STATE_OK;
}
break;
case UART_AT_STATE_OK:
if(strstr((char const *)scan_buf, "+CREG:"))
{
UART_Print("AT+qflst=\"*\"\r\n");
//g_uart_at_state = UART_AT_STATE_AT;
g_uart_at_state = UART_AT_STATE_INIT2_REP;
}
//g_uart_at_state = UART_AT_STATE_AT;
break;
default:
break;
}
#endif
//OSTimeDlyHMSM(0,0,0,20);
#else
ch = CommGetChar(0, &err);
if(ch!=NUL)
{
CommPutChar(ch, 0);
}
OSTimeDly(2);
#endif
}
#if 0
while(1)
{
#if 0
printf("task1 ");
if(g_flag__rx_frame_complete)//串口收到消息，字符串
{
g_flag__rx_frame_complete=false;
//pBuf=UART2_GetData(&len);
Uart_GetStr( (char *)g_uart_rx_content);
if(strstr((char const *)g_uart_rx_content,"halt") )
{
printf("you send the message is :halt \r\n");
asm("halt\n");
}
}
#endif
OSTimeDlyHMSM(0,0,0,TIME_DELAY );
}
#endif
}
void CEC_STANDBY(void)
{
uint32_t Index = 0U;
uint32_t temp = 0U;
SystemInit();
/*initial cec port */
TSB_PI->CR = 0x01U;
TSB_PI->FR1 = 0x01U;
TSB_PI->IE = 0x01U;
/*initial cec frame data buffer */
CEC_RxFrame.Initiator = CEC_UNKNOWN;
CEC_RxFrame.Destination = CEC_UNKNOWN;
CEC_RxFrame.Opcode = 0xFFU;
CEC_RxFrame.current_num = 0x0U;
CEC_RxFrame.Max_num = 0x0U;
CEC_RxFrame.current_state = DATA_INIT;
for (Index = 0U; Index < 17U; Index++) {
CEC_RxFrame.CEC_Data[Index] = 0xFFU;
}
CEC_RxFrameTmp = CEC_RxFrame;
CEC_TxFrame = CEC_RxFrame;
/*initial cec register */
CEC_Enable();
CEC_SWReset();
while (CEC_GetRxState() == ENABLE);
while (CEC_GetTxState() == BUSY);
CEC_DefaultConfig();
/*initial cec interupt */
__disable_irq();
TSB_CG->IMCGE = 0x00003030U;
TSB_CG->IMCGE = 0x00003131U;
TSB_CG->ICRCG = 0x10U;
NVIC_EnableIRQ(INTCECRX_IRQn);
NVIC_EnableIRQ(INTCECTX_IRQn);
__enable_irq();
/*set logical address TV */
CEC_SetLogicalAddr(CEC_TV);
/*Enable CEC reception */
CEC_SetRxCtrl(ENABLE);
while (1) {
/*Recieve new frame or not */
if (CEC_RxFrameTmp.current_state == DATA_END) {
CEC_RxFrame = CEC_RxFrameTmp;
CEC_RxFrameTmp.current_num = 0U;
CEC_RxFrameTmp.current_state = DATA_INIT;
temp = CEC_RxFrame.current_num;
if (temp > 0U) {
UART_Print(UART, "CEC Message: ");
for (Index = 0U; Index < temp; Index++) {
UART_Print(UART, "0x%2x " + CEC_RxFrame.CEC_Data[Index]);
}
UART_Print(UART, "\n");
}
for (Index = 0U; Index < 17U; Index++) {
CEC_RxFrameTmp.CEC_Data[Index] = 0xFFU;
}
/*CEC message is "Active Source" */
if (CEC_RxFrame.CEC_Data[1] == 0x82U) {
CEC_Send_Frame(CEC_TV, CEC_BROADCAST, 0x36U, 0U, CEC_RxFrame.CEC_Data);
}
}
}
}
void uartPutuint8(uint8 val) {
UART_Print(val);
}
void uartPutArray(uint8 val[], uint32 len) {
uint8 i = 0;
for(i=0; i<len; i++) {
UART_Print((char)val[i]);
}
}
/* The demo is for external 16-bit SRAM, separate bus mode */
void SRAM(void)
{
uint8_t chip = 0xFFU;
SMC_IFConfigTypeDef config = { 0U };
uint8_t bus_w = 0xFFU;
uint8_t bus_r = 0xFFU;
SMC_CyclesTypeDef cycles_w = { 0U };
SMC_CyclesTypeDef cycles_r = { 0U };
SMC_OpModeTypeDef opmode_w = { 0U };
SMC_OpModeTypeDef opmode_r = { 0U };
SMC_DirectCMDTypeDef cmd = { 0U };
uint8_t retval = 0U;
UART_Configuration(UART);
UART_Print(UART, "This is an example for SMC\n\r");
UART_Print(UART, "Initializing the SRAM...\n\r");
/* Initial process demo */
/* Herein describe SRAM model number and basic infomation */
/* CS0: 0x60000000 ~ 0x60FFFFFF(16MB) */
/* CS1: 0x61000000 ~ 0x61FFFFFF(16MB) */
/* CS2: 0x62000000 ~ 0x62FFFFFF(16MB) */
/* CS3: 0x63000000 ~ 0x63FFFFFF(16MB) */
chip = SMC_CS2;
bus_w = SMC_BUS_MULTIPLEX; /* Address bus and data bus are multiplexed */
SMC_SetBusMode(bus_w);
bus_r = SMC_GetBusMode();
if (bus_w != bus_r) {
retval |= 0x01U;
}
SMC_GetIFConfig(&config);
if (config.MemoryType != SMC_MULTIPLEX_SRAM) {
/* If multiplex bus mode, MemoryType is SMC_MULTIPLEX_SRAM */
retval = 0x02U;
}
if (config.MemoryWidth != SMC_DATA_BUS_16BIT) {
/* SMC_DATA_BUS_16BIT can not be read out if no external memory, */
/* and default value of "0x02" will be read out. */
retval |= 0x04U;
}
if ((config.MemoryChips) != SMC_MEMORY_CHIPS_4) {
retval |= 0x08U;
}
/* Set cycles time according to AC timing of SRAM datasheet,base clock: SMCCLK(fsys*1/2) */
/* Separate bus mode:tCEOE + SMCCLK*1clk <= tRC */
/* Multiplex bus mode:tCEOE + SMCCLK*2clk <= tRC */
cycles_w.RC_Time = SMC_READ_CYCLE_TIME_5;
/* Separate bus mode:tWP + SMCCLK*2clk <= tWC */
/* Multiplex bus mode:tWP + SMCCLK*3clk <= tWC */
cycles_w.WC_Time = SMC_WRITE_CYCLE_TIME_5;
cycles_w.CEOE_Time = SMC_CEOE_DELAY_CYCLE_TIME_1;
cycles_w.WP_Time = SMC_WE_PULSE_CYCLE_TIME_1;
/* PC_Time is only effective for separate bus mode */
/* It's necessary to also set to pass parameter check in multiplex bus mode */
cycles_w.PC_Time = SMC_PAGE_CYCLE_TIME_5;
cycles_w.TR_Time = SMC_TURN_AROUND_CYCLE_TIME_1;
SMC_SetCycles(&cycles_w);
opmode_w.BusWidth = SMC_DATA_BUS_16BIT;
opmode_w.ReadBurstLen = SMC_READ_BURST_4BEAT;
opmode_w.ALE = ENABLE; /* ALE must be enabled in multiplex bus mode */
SMC_SetOpMode(&opmode_w);
/* Make sure SMC_SetCycles and SMC_SetOpMode are performed before SMC_SendDirectCMD */
cmd.CmdType = SMC_CMD_UPDATEREGS;
cmd.ChipSelect = chip;
SMC_SendDirectCMD(&cmd);
/* Read cycles and opmode for verify */
SMC_GetCycles(chip, &cycles_r);
if (memcmp(&cycles_r, &cycles_w, sizeof(SMC_CyclesTypeDef)) != 0) {
retval |= 0x10U;
}
SMC_GetOpMode(chip, &opmode_r);
opmode_w.StartAddr = SMC_START_ADDR_CHIP0 | (uint8_t) chip; /* For compare with read out opmode */
if (memcmp(&opmode_r, &opmode_w, sizeof(SMC_OpModeTypeDef)) != 0) {
retval |= 0x20U;
}
/* check retval to see if SRAM initialization is sucessful or not */
if (retval == 0U) {
UART_Print(UART, "SRAM initialization is sucessful!\n\r");/* Sucessful */
} else {
UART_Print(UART, "SRAM initialization is failed!\n\r");/* Failed */
}
}
/* Send RTC Date value to hyperterminal */
void demo0(void)
{
/* Get RTC Date value */
Year = RTC_GetYear();
Month = RTC_GetMonth();
Date = RTC_GetDate(RTC_CLOCK_MODE);
Day = RTC_GetDay(RTC_CLOCK_MODE);
/* Set UART0 display */
/* Dispaly year */
RTC_Disp_YMD[0] = ' ';
RTC_Disp_YMD[1] = (Year / 10U) + 0x30U;
RTC_Disp_YMD[2] = (Year % 10U) + 0x30U;
RTC_Disp_YMD[3] = '-';
/* Display month */
RTC_Disp_YMD[4] = (Month / 10U) + 0x30U;
RTC_Disp_YMD[5] = (Month % 10U) + 0x30U;
RTC_Disp_YMD[6] = '-';
/* Display date */
RTC_Disp_YMD[7] = (Date / 10U) + 0x30U;
RTC_Disp_YMD[8] = (Date % 10U) + 0x30U;
RTC_Disp_YMD[9] = ' ';
RTC_Disp_YMD[10] = ' ';
RTC_Disp_YMD[11] = ' ';
/* Display day */
switch (Day) {
case RTC_SUN:
RTC_Disp_YMD[12] = 'S';
RTC_Disp_YMD[13] = 'U';
RTC_Disp_YMD[14] = 'N';
break;
case RTC_MON:
RTC_Disp_YMD[12] = 'M';
RTC_Disp_YMD[13] = 'O';
RTC_Disp_YMD[14] = 'N';
break;
case RTC_TUE:
RTC_Disp_YMD[12] = 'T';
RTC_Disp_YMD[13] = 'U';
RTC_Disp_YMD[14] = 'E';
break;
case RTC_WED:
RTC_Disp_YMD[12] = 'W';
RTC_Disp_YMD[13] = 'E';
RTC_Disp_YMD[14] = 'D';
break;
case RTC_THU:
RTC_Disp_YMD[12] = 'T';
RTC_Disp_YMD[13] = 'H';
RTC_Disp_YMD[14] = 'U';
break;
case RTC_FRI:
RTC_Disp_YMD[12] = 'F';
RTC_Disp_YMD[13] = 'R';
RTC_Disp_YMD[14] = 'I';
break;
case RTC_SAT:
RTC_Disp_YMD[12] = 'S';
RTC_Disp_YMD[13] = 'A';
RTC_Disp_YMD[14] = 'T';
break;
default:
/* Do nothing */
break;
}
RTC_Disp_YMD[15] = '\0';
UART_Print(UART, RTC_Disp_YMD);
}
