【RA4L1-SENSOR】+ RA4L1-SENSOR开发板之使用ESP8266获取任意城市天气预报

拿到RA4L1板子有10来天了，这段时间写了几篇基础的试用帖子，主要是点灯，按键，开箱，串口打印，LCD显示等等，这些基本的操作没有太大的创意，从本帖开始，我专注于实现需要技术的精华帖子，争取在拿到瑞萨的蓝牙音响！！！！！

手上刚好有个ESP8266的WIFI模块，可以用它来实现AT指令连接WIFI网络，从而获取天气预报信息，通过CJSON提取出城市和天气等有效信息后，通过串口显示出来。

RA4L1开发板和ESP8266连接如下图所示：

1是ESP8266

2是板载对的USB串口，用来打印调试，连接串口助手。

ESP8266和RA4L1的接线图如下：

可以看到，使用串口1的P608和P115。

好了，开始上干货！！！

1。打开瑞萨的smart配置软件

配置好ESP8266的串口

2。配置好打印调试的串口

3。点击生成代码

4。打开KEIL工程

先编译一遍工程，会发觉有1出错误提示！

不用管它，这是没有实现它的串口功能函数，下面来实现即可。

5。void esp8266_wifi (uart_callback_args_t * p_args)
{
if(p_args->event == UART_EVENT_TX_COMPLETE)
{
uart_send_complete_flag = true;
}
if(p_args->event == UART_EVENT_RX_CHAR)
{
if(esp8266_cnt >= sizeof(esp8266_buf)) esp8266_cnt = 0; //防止串口被刷爆
esp8266_buf[esp8266_cnt++] = (uint8_t)p_args->data;

}

}
添加上面函数，就不会报错了

5。实现ESP8266核心功能，获取城市天气预报
#include "esp8266.h"

static volatile bool uart_send_complete_flag = false;

uint8_t esp8266_buf[RXBUFFLENGTH];
uint16_t esp8266_cnt = 0;
uint16_t esp8266_cntPre = 0;

char tx_buffer[150];

void UART1_Init(void)
{
fsp_err_t err = FSP_SUCCESS;

err = R_SCI_UART_Open(&g_uart1_ctrl,&g_uart1_cfg);

assert(err == FSP_SUCCESS);

}

void WIFI_Send_Byte(uint8_t ch)
{
/* 发送一个字节数据到UART */
R_SCI_UART_Write(g_uart1.p_ctrl, (uint8_t *)&ch, 1);

/* 等待发送完毕 */
while(uart_send_complete_flag == false);
uart_send_complete_flag = false;

}

void WIFI_Send_Bytes(uint8_t data, uint32_t len)
{
/ 发送一个字节数据到UART */
R_SCI_UART_Write(g_uart1.p_ctrl, data, len);

/* 等待发送完毕 */
while(uart_send_complete_flag == false);
uart_send_complete_flag = false;

}

void WIFI_Send_String_Length(uint8_t str,uint32_t strlen)
{
unsigned int k=0;
do
{
WIFI_Send_Byte ((str + k));
k++;
} while(k < strlen);
}

void WIFI_Send_String(uint8_t str)
{
unsigned int k=0;
do
{
WIFI_Send_Byte ((str + k));
k++;
} while(*(str + k)!='\0');
}

void ESP8266_Send(char command)
{
//return HAL_UART_Transmit_DMA(ESP8266_huart, (uint8_t)command, strlen(command));
WIFI_Send_Bytes((uint8_t*)command, strlen(command));
}

void ESP8266_Send_cmd(uint8_t *data)
{
uint16_t length = 0u;

/* Calculate the length. */
while ('\0' != data[length])
{
  length++;
}

R_SCI_UART_Write(g_uart1.p_ctrl, data, length);

/* 等待发送完毕 */
while(uart_send_complete_flag == false);
uart_send_complete_flag = false;

}

void ESP8266_Clear(void)
{

memset(esp8266_buf, 0, sizeof(esp8266_buf));
esp8266_cnt = 0;

}

uint8_t ESP8266_WaitRecive(void)
{

if(esp8266_cnt == 0) 							//如果接收计数为0 则说明没有处于接收数据中，所以直接跳出，结束函数
	return REV_WAIT;
	
if(esp8266_cnt == esp8266_cntPre)				//如果上一次的值和这次相同，则说明接收完毕
{
	esp8266_cnt = 0;							//清0接收计数
		
	return REV_OK;								//返回接收完成标志
}
	
esp8266_cntPre = esp8266_cnt;					//置为相同

return REV_WAIT;								//返回接收未完成标志

}

//==========================================================
// 函数名称： ESP8266_SendCmd
//
// 函数功能： 发送命令
//
// 入口参数： cmd：命令
// res：需要检查的返回指令
//
// 返回参数： 0-成功 1-失败
//
// 说明：
//==========================================================
_Bool ESP8266_SendCmd(char *cmd, char *res)
{

unsigned char timeOut = 200;

WIFI_Send_Bytes((uint8_t *)cmd, strlen((uint8_t *)cmd));

while(timeOut--)
{
	if(ESP8266_WaitRecive() == REV_OK)							//如果收到数据
	{
		if(strstr((const char *)esp8266_buf, res) != NULL)		//如果检索到关键词
		{
		    printf("%s\r\n",esp8266_buf);
			ESP8266_Clear();									//清空缓存
			return 0;
		}
	}
	
	delay_ms(10);
}

return 1;

}

//==========================================================
// 函数名称： ESP8266_SendData
//
// 函数功能： 发送数据
//
// 入口参数： data：数据
// len：长度
//
// 返回参数： 无
//
// 说明：
//==========================================================
void ESP8266_SendData(uint8_t*data, uint32_t len)
{

char cmdBuf[32];

ESP8266_Clear();								//清空接收缓存
sprintf(cmdBuf, "AT+CIPSEND=%d\r\n", len);		//发送命令
if(!ESP8266_SendCmd(cmdBuf, ">"))				//收到‘>’时可以发送数据
{
	WIFI_Send_Bytes(data, len);		//发送设备连接请求数据
}

}

//==========================================================
// 函数名称： ESP8266_GetIPD
//
// 函数功能： 获取平台返回的数据
//
// 入口参数： 等待的时间(乘以10ms)
//
// 返回参数： 平台返回的原始数据
//
// 说明： 不同网络设备返回的格式不同，需要去调试
// 如ESP8266的返回格式为 "+IPD,x:yyy" x代表数据长度，yyy是数据内容
//==========================================================
uint8_t *ESP8266_GetIPD(uint16_t timeOut)
{

char *ptrIPD = NULL;

do
{
	if(ESP8266_WaitRecive() == REV_OK)								//如果接收完成
	{
		ptrIPD = strstr((char *)esp8266_buf, "IPD,");				//搜索“IPD”头
		if(ptrIPD == NULL)											//如果没找到，可能是IPD头的延迟，还是需要等待一会，但不会超过设定的时间
		{
			//printf("\"IPD\" not found\r\n");
		}
		else
		{
			ptrIPD = strchr(ptrIPD, ':');							//找到':'
			if(ptrIPD != NULL)
			{
				ptrIPD++;
				return (unsigned char *)(ptrIPD);
			}
			else
				return NULL;
			
		}
	}
	
	delay_ms(5);													//延时等待
} while(timeOut--);

return NULL;														//超时还未找到，返回空指针

}

//==========================================================
// 函数名称： ESP8266_Init
//
// 函数功能： 初始化ESP8266
//
// 入口参数： 无
//
// 返回参数： 无
//
// 说明：
//==========================================================
void ESP8266_Init(void)
{
#define WIFI_SSID "WIFI名称" // WIFI的名称 必须用2.4G的wifi不能用5G的，且不能用中文、空格
#define WIFI_PSWD "WIFI密码" // WIFI密码

#define SERVER_HOST "broker.emqx.io" // MQTT服务器域名或IP
#define SERVER_PORT "1883" // MQTT服务器端口（一般为1883不用改）

#define ESP8266_WIFI_INFO "AT+CWJAP="" WIFI_SSID "","" WIFI_PSWD ""\r\n"
#define ESP8266_ONENET_INFO "AT+CIPSTART="TCP","" SERVER_HOST ""," SERVER_PORT "\r\n"

//GPIO_WriteBit(GPIOC, GPIO_Pin_14, Bit_RESET);
//DelayXms(250);
//GPIO_WriteBit(GPIOC, GPIO_Pin_14, Bit_SET);
//DelayXms(500);

ESP8266_Clear();

ESP8266_SendCmd("AT+RST\r\n", "");
	delay_ms(1200);

while(ESP8266_SendCmd("AT\r\n", "OK"))
	delay_ms(500);

/*
ESP8266_SendCmd("AT+CIPCLOSE\r\n", "");
delay_ms(500);
*/

while(ESP8266_SendCmd("AT+CWMODE=1\r\n", "OK"))
	delay_ms(500);

while(ESP8266_SendCmd("AT+CWDHCP=1,1\r\n", "OK"))
	delay_ms(500);

while(ESP8266_SendCmd(ESP8266_WIFI_INFO, "GOT IP"))
	delay_ms(500);

while(ESP8266_SendCmd(ESP8266_ONENET_INFO, "CONNECT"))
	delay_ms(500);

printf("ESP8266 Initialization			[OK]\r\n");

}

void Wifi_connect(char *SSID, char *Password)
{
uint8_t err = 0;
ESP8266_SendCmd("AT+CWQAP\r\n", "OK");
delay_ms(1500);

sprintf(tx_buffer, "AT+CWJAP=\"%s\",\"%s\"\r\n", SSID, Password); /*HAL_UART_Transmit(&huart1,(uint8_t *)tx_buffer,sprintf(tx_buffer,"AT+CWJAP=\"%s\",\"%s\"\r\n",SSID,Password),1000);*/
ESP8266_SendCmd(tx_buffer,"OK");

}

void MQTT_Connect(char *ip,char *port)
{
sprintf(tx_buffer,"AT+MQTTUSERCFG=0,1,"1","1","1",0,0,""\r\n");
ESP8266_SendCmd(tx_buffer,"OK");

sprintf(tx_buffer,"AT+MQTTCONN=0,\"%s\",%s,0\r\n",ip,port); /*HAL_UART_Transmit(&huart1,(uint8_t *)tx_buffer,sprintf(tx_buffer,"AT+CWJAP=\"%s\",\"%s\"\r\n",SSID,Password),1000);*/
ESP8266_SendCmd(tx_buffer,"OK");

}

/*******************************************************
函数名:void MQTT_Subscribe(char *tipname)
功能:订阅MQTT主题
参数:
@tipname:主题字
*******************************************************/
void MQTT_Subscribe(char *tipname)
{
sprintf(tx_buffer,"AT+MQTTSUB=0,"%s",0\r\n",tipname);
ESP8266_SendCmd(tx_buffer,"OK");
}

void MQTT_Publish(char *topicName,char *message)
{
sprintf(tx_buffer,"AT+MQTTPUB=0,"%s","%s",0,0\r\n",topicName,message);
ESP8266_SendCmd(tx_buffer,"OK");
}

void Read_Message(char message)
{
char buff = esp8266_buf;
/----------- 处理数据 ---------------/
if(strstr(buff,"+MQTTSUBRECV:0") == NULL) return ;
buff = strstr(buff,"",")+2;
buff = strstr(buff,",")+1;
strcpy(message,buff);
printf("收到的数据是: %s\r\n",message);
}

void esp8266_wifi (uart_callback_args_t * p_args)
{
if(p_args->event == UART_EVENT_TX_COMPLETE)
{
uart_send_complete_flag = true;
}
if(p_args->event == UART_EVENT_RX_CHAR)
{
if(esp8266_cnt >= sizeof(esp8266_buf)) esp8266_cnt = 0; //防止串口被刷爆
esp8266_buf[esp8266_cnt++] = (uint8_t)p_args->data;

}

}

#if 0
/* 重定向 printf 输出 */
#if defined GNUC && !defined clang
int _write(int fd, char *pBuffer, int size); //防止编译警告
int _write(int fd, char *pBuffer, int size)
{
(void)fd;
R_SCI_UART_Write(&g_uart0_ctrl, (uint8_t *)pBuffer, (uint32_t)size);
while(uart_send_complete_flag == false);
uart_send_complete_flag = false;
return size;
}
#else
int fputc(int ch, FILE *f)
{
(void)f;
R_SCI_UART_Write(&g_uart0_ctrl, (uint8_t *)&ch, 1);
while(uart_send_complete_flag == false);
uart_send_complete_flag = false;
return ch;
}
#endif
#endif

int esp8266_module_reset(void)
{
HAL_Delay(500);
return ESP8266_SendCmd("AT+RST\r\n", "OK");
}

int send_atcmd_check_ok(char *atcmd, unsigned int timeout)
{
if( NULL == atcmd )
{
printf("%s--->Invalid input arguments\r\n",FUNCTION);
return -1;
}

return ESP8266_SendCmd(atcmd,"OK");

}

int set_atcmd_echo(int status)
{
int mode = status ? 1 : 0;
char atcmd[64];

snprintf(atcmd, sizeof(atcmd), "ATE%d\r\n", mode);

if( !send_atcmd_check_ok(atcmd, 1000) )
{
	printf("INFO: Send 'ATE%d' to ESP8266 module and got reply ok\r\n", mode);
	return 0;
}

return -1;

}

int send_atcmd_check_module(void)
{
int rv = -3;

rv = send_atcmd_check_ok("AT\r", 500);
	if(-1 == rv)
	{
		printf("%s--->Invalid input arguments\r\n",__FUNCTION__);
		return -1;
	}

	if( !rv )
	{
		printf("INFO: Send 'AT' to ESP8266 module and got reply ok\r\n");
		return 0;
	}

	HAL_Delay(100);

return -1;

}

int esp8266_module_init(void)
{
int i;
printf("INFO:The module start to reset now ...\r\n");

esp8266_module_reset();

for(i=0; i<6; i++)
{
	if( send_atcmd_check_module() )
	{
		printf("INFO:Send At to module and got reply ok\r\n");
		break;
	}

	HAL_Delay(100);

}

if(i>=6)
{
	printf("ERROR:Send At to module and got reply fail\r\n");
	return -2;
}

#if 1
if( set_atcmd_echo(1))
{
printf("INFO:Set module to close echo and got reply fail\r\n");
return -3;
}

printf("Set module to close echo and got reply successfully\r\n");

#endif

if(send_atcmd_check_ok("AT+CWMODE=1\r\n", 500))
{
	printf("%s--->ERROR:Set the working mode to station and got reply fail\r\n",__FUNCTION__);
	return -4;

}

printf("INFO:Set the working mode to station and got reply successfully\r\n");

if(send_atcmd_check_ok("AT+CWDHCP=1,1\r\n", 500))
{
	printf("%s--->ERROR:Enable ESP8266 Station mode DHCP failure\r\n",__FUNCTION__);
	return -5;
}

printf("INFO:Enable ESP8266 Station mode DHCP successfully\r\n");
HAL_Delay(500);
return 0;

}

char WIFI_Start[]="AT+CWJAP="CMCC-42A3","u2Kn7bm3"\r\n";

void esp8266_init(void)
{
ESP8266_Clear();

//while(ESP8266_SendCmd("AT+RST\r\n", "OK"))
//HAL_Delay(500);


while(ESP8266_SendCmd("AT\r\n", "OK"));
//HAL_Delay(500);

while(ESP8266_SendCmd("ATE1\r\n", "OK"));
//HAL_Delay(500);

while(ESP8266_SendCmd("AT+CWMODE=1\r\n", "OK"));
//HAL_Delay(500);


while(ESP8266_SendCmd(WIFI_Start, "OK"));
//HAL_Delay(500);


while(ESP8266_SendCmd("AT+CIPMUX=0\r\n", "OK"));
//HAL_Delay(500);

//while(ESP8266_SendCmd("AT+CIPSTART=\"TCP\",\"api.seniverse.com\",80\r\n", "OK"));
//HAL_Delay(500);

//while(ESP8266_SendCmd("AT+CIPMODE=1\r\n", "OK"));
//HAL_Delay(500);

//while(ESP8266_SendCmd("AT+CIPSEND\r\n", ">"))
//HAL_Delay(500);

}

#ifndef __ESP8266_H
#define __ESP8266_H

#include "hal_data.h"
#include <stdio.h>
#include "usart9.h"
#include <string.h>

extern uint8_t esp8266_buf[RXBUFFLENGTH];
extern uint16_t esp8266_cnt;
extern uint16_t esp8266_cntPre;

void ESP8266_Clear(void);
uint8_t ESP8266_WaitRecive(void);
_Bool ESP8266_SendCmd(char *cmd, char res);
void ESP8266_SendData(uint8_tdata, uint32_t len);
uint8_t *ESP8266_GetIPD(uint16_t timeOut);
void ESP8266_Init(void);
void Wifi_connect(char *SSID, char *Password) ;
void MQTT_Connect(char *ip,char *port) ;
void MQTT_Subscribe(char *tipname);
void MQTT_Publish(char *topicName,char *message);
void Read_Message(char *message);

void UART1_Init(void);
void WIFI_Send_Byte(uint8_t ch);
void WIFI_Send_Bytes(uint8_t *data, uint32_t len);
void WIFI_Send_String_Length(uint8_t *str,uint32_t strlen);
void WIFI_Send_String(uint8_t *str);

void ESP8266_Send_cmd(uint8_t *data);
int esp8266_module_reset(void);
int send_atcmd_check_module(void);
int send_atcmd_check_ok(char *atcmd, unsigned int timeout);
int set_atcmd_echo(int status);

int esp8266_module_init(void);
void esp8266_init(void);
void ESP8266_Send(char *command);

#endif

6。在主函数中添加核心代码
#include "hal_data.h"
#include <stdio.h>
#include <stdlib.h>
#include "usart9.h"
#include "esp8266.h"
#include "cJSON.h"
#include "led.h"
#include "ebtn_app.h"

FSP_CPP_HEADER
void R_BSP_WarmStart(bsp_warm_start_event_t event);
FSP_CPP_FOOTER

void coremark_main(void);

volatile uint8_t button_count = 0;

volatile uint8_t time_count = 0;

//RTC变量
/* rtc_time_t is an alias for the C Standard time.h struct 'tm' /
rtc_time_t set_time =
{
.tm_sec = 00, / 秒，范围从 0 到 59 /
.tm_min = 16, / 分，范围从 0 到 59 /
.tm_hour = 17, / 小时，范围从 0 到 23*/
.tm_mday = 10, /* 一月中的第几天，范围从 1 到 31*/
.tm_mon = 6, /* 月份，范围从 0 到 11*/
.tm_year = 125, /* 自 1900 起的年数，2025为125*/
.tm_wday = 2, /* 一周中的第几天，范围从 0 到 6*/
// .tm_yday=0, /* 一年中的第几天，范围从 0 到 365*/
// .tm_isdst=0; /* 夏令时*/
};

//RTC闹钟变量
rtc_alarm_time_t set_alarm_time=
{
.time.tm_sec = 10, /* 秒，范围从 0 到 59 /
.time.tm_min = 20, / 分，范围从 0 到 59 /
.time.tm_hour = 17, / 小时，范围从 0 到 23*/
.time.tm_mday = 10, /* 一月中的第几天，范围从 1 到 31*/
.time.tm_mon = 6, /* 月份，范围从 0 到 11*/
.time.tm_year = 125, /* 自 1900 起的年数，2025为125*/
.time.tm_wday = 2, /* 一周中的第几天，范围从 0 到 6*/

.sec_match        =  1,
 .min_match        =  0,
 .hour_match       =  0,
 .mday_match       =  0,
 .mon_match        =  0,
 .year_match       =  0,
 .dayofweek_match  =  0,
};

//RTC回调函数
volatile bool rtc_flag = 0;//RTC延时1s标志位
volatile bool rtc_alarm_flag = 0;//RTC闹钟
/* Callback function */
void rtc_callback(rtc_callback_args_t p_args)
{
/ TODO: add your own code here */
if(p_args->event == RTC_EVENT_PERIODIC_IRQ)
rtc_flag=1;
else if(p_args->event == RTC_EVENT_ALARM_IRQ)
rtc_alarm_flag=1;
}

void disp_0(void);
void disp_1(void);
void disp_2(void);
void disp_3(void);
void disp_4(void);
void disp_5(void);
void disp_6(void);
void disp_7(void);
void disp_8(void);
void disp_9(void);
void disp_num(uint8_t channel, uint8_t num);
void disp_num1(uint8_t channel, uint8_t num);

void disp_COL1(void);
void disp_DOT1(void);

char TX_Data[]="GET https://api.seniverse.com/v3/weather/now.json?key=SfobYEEioM5L6dRce&location=shenzhen&language=zh-Hans&unit=c\r\n";
char Data[]="AT+CIPSEND\r\n";

/*******************************************************************************************************************//**

• main() is generated by the RA Configuration editor and is used to generate threads if an RTOS is used. This function

• is called by main() when no RTOS is used.
  **********************************************************************************************************************/
  void hal_entry(void)
  {
  char *dataPtr = NULL;
  unsigned char wifi_flag = 0;
  char ipaddr[16];
  char gateway[16];
  uint32_t latest_time = 0;
  int rv = -1;

  /* TODO: add your own code here /
  fsp_err_t err;
  / Open SLCDC driver /
  err = R_SLCDC_Open(&g_slcdc0_ctrl, &g_slcdc0_cfg);
  / Handle any errors. This function should be defined by the user. /
  assert(FSP_SUCCESS == err);
  / When using internal boost mode this delay is required to allow the boost circuit to charge. See RA4M1 User's

  • Manual (R01UH0887EJ0100) 8.2.18 "Segment LCD Source Clock Control Register (SLCDSCKCR)" for details. /
    R_BSP_SoftwareDelay(5, BSP_DELAY_UNITS_MILLISECONDS);
    / Start SLCDC output */
    err = R_SLCDC_Start(&g_slcdc0_ctrl);
    assert(FSP_SUCCESS == err);

  /* Set Display Area of SLCDC driver.*/
  // err = R_SLCDC_SetDisplayArea(&g_slcdc0_ctrl, SLCDC_DISP_A);
  // assert(FSP_SUCCESS == err);
  //准备并写入段显示数据,第一个数码管显示1
  uint8_t segment_data_num1[] = {
  0x00,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,
  0x00,0x6
  };
  R_SLCDC_Write(&g_slcdc0_ctrl, 0, segment_data_num1, sizeof(segment_data_num1));
  //R_BSP_SoftwareDelay (100, BSP_DELAY_UNITS_MILLISECONDS);

  //准备并写入段显示数据,第二个数码管显示2
  uint8_t segment_data_num2[] = {
  0xE,0x3};
  R_SLCDC_Write(&g_slcdc0_ctrl, 15, segment_data_num2, sizeof(segment_data_num2));
  //R_BSP_SoftwareDelay (100, BSP_DELAY_UNITS_MILLISECONDS);

  //准备并写入段显示数据,第三个数码管显示3
  R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xA, 0xF);
  R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);
  ///R_BSP_SoftwareDelay (100, BSP_DELAY_UNITS_MILLISECONDS);

  //准备并写入段显示数据,第四个数码管显示4
  R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0x3, 0xF);
  R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x6, 0xF);
  //R_BSP_SoftwareDelay (100, BSP_DELAY_UNITS_MILLISECONDS);

  //准备并写入段显示数据,第五个数码管显示5
  R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xB, 0xF);
  R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x5, 0xF);
  //R_BSP_SoftwareDelay (100, BSP_DELAY_UNITS_MILLISECONDS);

  //准备并写入段显示数据,第六个数码管显示6
  R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xF, 0xF);
  R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x5, 0xF);
  R_BSP_SoftwareDelay (100, BSP_DELAY_UNITS_MILLISECONDS);

  UART9_Init();UART1_Init();
  hal_systick_init();
  ebtn_APP_Key_INIT();
  /RTC开启*****************/
  /* Initialize the RTC module*/
  err = R_RTC_Open(&g_rtc0_ctrl, &g_rtc0_cfg);

  /* Handle any errors. This function should be defined by the user. */
  assert(FSP_SUCCESS == err);

  /* Set the RTC clock source. Can be skipped if "Set Source Clock in Open" property is enabled. /
  R_RTC_ClockSourceSet(&g_rtc0_ctrl);
  / R_RTC_CalendarTimeSet must be called at least once to start the RTC /
  R_RTC_CalendarTimeSet(&g_rtc0_ctrl, &set_time);
  / Set the periodic interrupt rate to 1 second */
  R_RTC_PeriodicIrqRateSet(&g_rtc0_ctrl, RTC_PERIODIC_IRQ_SELECT_1_SECOND);

  R_RTC_CalendarAlarmSet(&g_rtc0_ctrl, &set_alarm_time);
  uint8_t rtc_second = 0; //秒
  uint8_t rtc_minute = 0; //分
  uint8_t rtc_hour = 0; //时
  uint8_t rtc_day = 0; //日
  uint8_t rtc_month = 0; //月
  uint16_t rtc_year = 0; //年
  uint8_t rtc_week = 0; //周
  rtc_time_t get_time;
  uint16_t year = 0;

  printf("\r\n欢迎来到瑞萨电子\r\n");
  printf("很高兴试用RA4L1开发板********\r\n");
  printf("串口输出打印 波特率115200\r\n\r\n");
  /*
  //清空0-41段
  uint8_t segment_data_num_off[41+1] ;
  for(int i=0;i<=41;i++)
  segment_data_num_off[i]=0;
  R_SLCDC_Write(&g_slcdc0_ctrl, 0, segment_data_num_off, sizeof(segment_data_num_off));
  R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);
  esp8266_module_init();
  */

  esp8266_module_init();

  printf("\r\nESP8266城市天气预报 \r\n\r\n");

  esp8266_init();
  while(ESP8266_SendCmd("AT+CIPSTART="TCP","api.seniverse.com",80\r\n", "OK"));

  //while(ESP8266_SendCmd("AT+CIPSTART="TCP","api.openweathermap.org",80\r\n", "OK"));

  while(ESP8266_SendCmd("AT+CIPMODE=1\r\n", "OK"));

  ESP8266_SendData(TX_Data,strlen(TX_Data));

  HAL_Delay(500);

  printf("%d\r\n",esp8266_cnt);
  printf("%d\r\n",strlen(esp8266_buf));

  printf("原始天气数据\r\n");
  printf("\r\n");
  printf("%s\r\n",esp8266_buf);
  printf("\r\n");

  //***********************************JSON解析数据
  cJSON *json;
  cJSON *Array_obj1;
  cJSON *Array_obj2;
  cJSON *Array_obj3;
  cJSON *Array_obj4;
  cJSON *Array_obj5;
  cJSON *Array_obj6;
  cJSON *Array_obj7;
  cJSON *Array_obj8;
  cJSON *Array;

  json = cJSON_Parse((const char *) esp8266_buf );
  Array_obj1=cJSON_GetObjectItem(json,"results");

  int size=cJSON_GetArraySize(Array_obj1);
  //printf("\n%d",size);

  printf("\r\nCJSON解析后的数据\r\n");
  printf("=============================================================================\r\n");
  if(json == NULL)
  printf("\njson fmt error:%s\n.", cJSON_GetErrorPtr());
  else
  {
  Array=cJSON_GetArrayItem(Array_obj1,0);
  Array_obj2=cJSON_GetObjectItem(Array,"now");
  Array_obj3=cJSON_GetObjectItem(Array_obj2,"code");
  Array_obj4=cJSON_GetObjectItem(Array_obj2,"temperature");
  Array_obj5=cJSON_GetObjectItem(Array_obj2,"text");
  Array_obj6=cJSON_GetObjectItem(Array,"location");
  Array_obj7=cJSON_GetObjectItem(Array_obj6,"name");
  Array_obj8=cJSON_GetObjectItem(Array,"last_update");
  printf("城市: %s ",Array_obj7->valuestring);
  printf("天气: %s ",Array_obj5->valuestring);
  //printf("\r\n%s\r\n",Array_obj3->valuestring); //天气代码
  printf("气温: %s度 ",Array_obj4->valuestring); //气温
  printf("时间: %s\r\n",Array_obj8->valuestring);
  printf("=============================================================================\r\n");
  }

  cJSON_Delete(json);//释放json

  ESP8266_Send("+++");

#if 0
while (1)
{
if(rtc_flag)
{
R_RTC_CalendarTimeGet(&g_rtc0_ctrl, &get_time);//获取RTC计数时间
rtc_flag=0;
rtc_second = get_time.tm_sec; //秒
rtc_minute = get_time.tm_min; //分
rtc_hour = get_time.tm_hour; //时
rtc_day = get_time.tm_mday; //日
rtc_month = get_time.tm_mon; //月
rtc_year = get_time.tm_year; //年
rtc_week = get_time.tm_wday; //周
printf("现在时间 %d 年 %d 月 %d 日 %d 时 %d 分 %d 秒 第 %d 周\n",rtc_year+1900,rtc_month,rtc_day,rtc_hour,rtc_minute,rtc_second,rtc_week);

year = rtc_year+1900;
		year %= 100;
		if((time_count %2) == 0)//年月日
		{
			disp_num(1, year/10);disp_num(2, year%10);
			disp_num(3, rtc_month/10);disp_num(4, rtc_month%10);
			disp_num(5, rtc_day/10);disp_num(6, rtc_day%10);
		}
		if((time_count %2) == 1)//时分秒
		{
			disp_num(1, rtc_hour/10);disp_num(2, rtc_hour%10);
			disp_num(3, rtc_minute/10);disp_num(4, rtc_minute%10);
			disp_num(5, rtc_second/10);disp_num(6, rtc_second%10);
		}
			
	
		

        }
    if(rtc_alarm_flag)
    {
        rtc_alarm_flag=0;
        printf("/************************Alarm Clock********************************/\n");
    }
    //R_BSP_SoftwareDelay(10U, BSP_DELAY_UNITS_MILLISECONDS);

}
#endif
#if BSP_TZ_SECURE_BUILD
/* Enter non-secure code */
R_BSP_NonSecureEnter();
#endif
}

void disp_0(void)
{
//准备并写入段显示数据,第一个数码管显示1
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xD, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

//准备并写入段显示数据,第二个数码管显示2
R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xD, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7, 0xF);

//准备并写入段显示数据,第三个数码管显示3
R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xD, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

//准备并写入段显示数据,第四个数码管显示4
R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xD, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7, 0xF);

//准备并写入段显示数据,第五个数码管显示5
R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xD, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

//准备并写入段显示数据,第六个数码管显示6
R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xD, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);
R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);

}

void disp_1(void)
{
//准备并写入段显示数据,第一个数码管显示1
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x6, 0xF);

//准备并写入段显示数据,第二个数码管显示2
R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x6, 0xF);

//准备并写入段显示数据,第三个数码管显示3
R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x6, 0xF);

//准备并写入段显示数据,第四个数码管显示4
R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x6, 0xF);

//准备并写入段显示数据,第五个数码管显示5
R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x6, 0xF);

//准备并写入段显示数据,第六个数码管显示6
R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x6, 0xF);
R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);

}

void disp_2(void)
{
//准备并写入段显示数据,第一个数码管显示1
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xE, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x3, 0xF);

//准备并写入段显示数据,第二个数码管显示2
R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xE, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x3, 0xF);

//准备并写入段显示数据,第三个数码管显示3
R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xE, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x3, 0xF);

//准备并写入段显示数据,第四个数码管显示4
R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xE, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x3, 0xF);

//准备并写入段显示数据,第五个数码管显示5
R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xE, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x3, 0xF);

//准备并写入段显示数据,第六个数码管显示6
R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xE, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x3, 0xF);
R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);

}

void disp_3(void)
{
//准备并写入段显示数据,第一个数码管显示1
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xA, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

//准备并写入段显示数据,第二个数码管显示2
R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xA, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7, 0xF);

//准备并写入段显示数据,第三个数码管显示3
R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xA, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

//准备并写入段显示数据,第四个数码管显示4
R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xA, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7, 0xF);

//准备并写入段显示数据,第五个数码管显示5
R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xA, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

//准备并写入段显示数据,第六个数码管显示6
R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xA, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);
R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);

}

void disp_4(void)
{
//准备并写入段显示数据,第一个数码管显示1
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0x3, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x6, 0xF);

//准备并写入段显示数据,第二个数码管显示2
R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0x3, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x6, 0xF);

//准备并写入段显示数据,第三个数码管显示3
R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0x3, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x6, 0xF);

//准备并写入段显示数据,第四个数码管显示4
R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0x3, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x6, 0xF);

//准备并写入段显示数据,第五个数码管显示5
R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0x3, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x6, 0xF);

//准备并写入段显示数据,第六个数码管显示6
R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0x3, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x6, 0xF);
R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);

}

void disp_5(void)
{
//准备并写入段显示数据,第一个数码管显示1
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x5, 0xF);

//准备并写入段显示数据,第二个数码管显示2
R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x5, 0xF);

//准备并写入段显示数据,第三个数码管显示3
R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x5, 0xF);

//准备并写入段显示数据,第四个数码管显示4
R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x5, 0xF);

//准备并写入段显示数据,第五个数码管显示5
R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x5, 0xF);

//准备并写入段显示数据,第六个数码管显示6
R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x5, 0xF);
R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);

}

void disp_6(void)
{
//准备并写入段显示数据,第一个数码管显示1
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x5, 0xF);

//准备并写入段显示数据,第二个数码管显示2
R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x5, 0xF);

//准备并写入段显示数据,第三个数码管显示3
R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x5, 0xF);

//准备并写入段显示数据,第四个数码管显示4
R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x5, 0xF);

//准备并写入段显示数据,第五个数码管显示5
R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x5, 0xF);

//准备并写入段显示数据,第六个数码管显示6
R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x5, 0xF);
R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);

}

void disp_7(void)
{
//准备并写入段显示数据,第一个数码管显示1
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

//准备并写入段显示数据,第二个数码管显示2
R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7, 0xF);

//准备并写入段显示数据,第三个数码管显示3
R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

//准备并写入段显示数据,第四个数码管显示4
R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7, 0xF);

//准备并写入段显示数据,第五个数码管显示5
R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

//准备并写入段显示数据,第六个数码管显示6
R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);
R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);

}

void disp_8(void)
{
//准备并写入段显示数据,第一个数码管显示1
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

//准备并写入段显示数据,第二个数码管显示2
R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7, 0xF);

//准备并写入段显示数据,第三个数码管显示3
R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

//准备并写入段显示数据,第四个数码管显示4
R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7, 0xF);

//准备并写入段显示数据,第五个数码管显示5
R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

//准备并写入段显示数据,第六个数码管显示6
R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xF, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);
R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);

}

void disp_9(void)
{
//准备并写入段显示数据,第一个数码管显示1
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

//准备并写入段显示数据,第二个数码管显示2
R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7, 0xF);

//准备并写入段显示数据,第三个数码管显示3
R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

//准备并写入段显示数据,第四个数码管显示4
R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7, 0xF);

//准备并写入段显示数据,第五个数码管显示5
R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

//准备并写入段显示数据,第六个数码管显示6
R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xB, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);
R_BSP_SoftwareDelay (1000, BSP_DELAY_UNITS_MILLISECONDS);

}

void disp_COL1(void)
{
R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 1<<3, 0xF);
}

void disp_DOT1(void)
{
R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 1<<3, 0xF);
}

void disp_num(uint8_t channel, uint8_t num)
{
switch (channel)
{
case 1:
switch(num)
{
case 0:
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xD, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);
break;
case 1:
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x6, 0xF);
break;
case 2:
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xE, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x3, 0xF);

break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x6, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x5, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x5, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

				break;	
		}

		break;
	case 2:
		switch(num)
		{
			case 0:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xD, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7|1<<3, 0xF);

				break;
			case 1:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x6|1<<3, 0xF);

				break;
			case 2:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xE, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x3|1<<3, 0xF);

				break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7|1<<3, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x6|1<<3, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x5|1<<3, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x5|1<<3, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7|1<<3, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7|1<<3, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7|1<<3, 0xF);

				break;	
		}

		break;
	case 3:
		switch(num)
		{
			case 0:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xD, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

				break;
			case 1:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x6, 0xF);

				break;
			case 2:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xE, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x3, 0xF);

				break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x6, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x5, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x5, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

				break;	

		}

		break;
	case 4:
		switch(num)
		{
			case 0:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xD, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7|1<<3, 0xF);
				break;
			case 1:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0x0, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x6|1<<3, 0xF);
				break;
			case 2:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xE, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x3|1<<3, 0xF);

				break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7|1<<3, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x6|1<<3, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x5|1<<3, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x5|1<<3, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7|1<<3, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7|1<<3, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7|1<<3, 0xF);

				break;	
		}

		break;
	case 5:
		switch(num)
		{
			case 0:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xD, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);
				break;
			case 1:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0x0, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x6, 0xF);
				break;
			case 2:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xE, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x3, 0xF);

				break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x6, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x5, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x5, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

				break;	
		}

		break;
	case 6:
		switch(num)
		{
			case 0:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xD, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);
				break;
			case 1:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0x0, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x6, 0xF);
				break;
			case 2:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xE, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x3, 0xF);

				break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x6, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x5, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x5, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);

				break;	

		}

		break;

}

}

void disp_num1(uint8_t channel, uint8_t num)
{
switch (channel)
{
case 1:
switch(num)
{
case 0:
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xD, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);
break;
case 1:
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0x0, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x6, 0xF);
break;
case 2:
R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xE, 0xF);
R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x3, 0xF);

break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x6, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x5, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x5, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 3, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 11, 0x7, 0xF);

				break;	
		}

		break;
	case 2:
		switch(num)
		{
			case 0:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xD, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7, 0xF);

				break;
			case 1:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x6, 0xF);

				break;
			case 2:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xE, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x3, 0xF);

				break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x6, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x5, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x5, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 15, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 16, 0x7, 0xF);

				break;	
		}

		break;
	case 3:
		switch(num)
		{
			case 0:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xD, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

				break;
			case 1:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x6, 0xF);

				break;
			case 2:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xE, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x3, 0xF);

				break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x6, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x5, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x5, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 22, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 23, 0x7, 0xF);

				break;	

		}

		break;
	case 4:
		switch(num)
		{
			case 0:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xD, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7, 0xF);
				break;
			case 1:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0x0, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x6, 0xF);
				break;
			case 2:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xE, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x3, 0xF);

				break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x6, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x5, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x5, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 24, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 29, 0x7, 0xF);

				break;	
		}

		break;
	case 5:
		switch(num)
		{
			case 0:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xD, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);
				break;
			case 1:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0x0, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x6, 0xF);
				break;
			case 2:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xE, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x3, 0xF);

				break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x6, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x5, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x5, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 30, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 39, 0x7, 0xF);

				break;	
		}

		break;
	case 6:
		switch(num)
		{
			case 0:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xD, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);
				break;
			case 1:
		        R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0x0, 0xF);
                R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x6, 0xF);
				break;
			case 2:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xE, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x3, 0xF);

				break;
			case 3:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xA, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);

				break;
			case 4:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0x3, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x6, 0xF);

				break;
			case 5:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x5, 0xF);

				break;
			case 6:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x5, 0xF);

				break;
			case 7:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0x0, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);

				break;	
			case 8:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xF, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);

				break;	
			case 9:
				R_SLCDC_Modify(&g_slcdc0_ctrl, 40, 0xB, 0xF);
				R_SLCDC_Modify(&g_slcdc0_ctrl, 41, 0x7, 0xF);

				break;	

		}

		break;

}

}

/*******************************************************************************************************************//**

• This function is called at various points during the startup process. This implementation uses the event that is

• called right before main() to set up the pins.

• @param[in] event Where at in the start up process the code is currently at
  **********************************************************************************************************************/
  void R_BSP_WarmStart (bsp_warm_start_event_t event)
  {
  if (BSP_WARM_START_RESET == event)
  {
  #if BSP_FEATURE_FLASH_LP_VERSION != 0

  /* Enable reading from data flash. */
   R_FACI_LP->DFLCTL = 1U;
  
   /* Would normally have to wait tDSTOP(6us) for data flash recovery. Placing the enable here, before clock and
    * C runtime initialization, should negate the need for a delay since the initialization will typically take more than 6us. */
  

#endif
}

if (BSP_WARM_START_POST_C == event)
{
    /* C runtime environment and system clocks are setup. */

    /* Configure pins. */
    R_IOPORT_Open(&IOPORT_CFG_CTRL, &IOPORT_CFG_NAME);

#if BSP_CFG_SDRAM_ENABLED

/* Setup SDRAM and initialize it. Must configure pins first. */
    R_BSP_SdramInit(true);

#endif
}
}

#if BSP_TZ_SECURE_BUILD

FSP_CPP_HEADER
BSP_CMSE_NONSECURE_ENTRY void template_nonsecure_callable ();

/* Trustzone Secure Projects require at least one nonsecure callable function in order to build (Remove this if it is not required to build). */
BSP_CMSE_NONSECURE_ENTRY void template_nonsecure_callable ()
{

}
FSP_CPP_FOOTER

#endif
这里 api.seniverse.com 指的是心知天气预报官网

烧录到板子，打开串口助手，查看效果

可以看到深圳天气预报

打开手机天气预报，查看深圳

温度很准

下面红色部分是CJSON解析后的信息

对应代码
int size=cJSON_GetArraySize(Array_obj1);
//printf("\n%d",size);

printf("\r\nCJSON解析后的数据\r\n");
printf("=============================================================================\r\n");
if(json == NULL)
printf("\njson fmt error:%s\n.", cJSON_GetErrorPtr());
else
{
	Array=cJSON_GetArrayItem(Array_obj1,0);
	Array_obj2=cJSON_GetObjectItem(Array,"now");
	Array_obj3=cJSON_GetObjectItem(Array_obj2,"code");
	Array_obj4=cJSON_GetObjectItem(Array_obj2,"temperature");
	Array_obj5=cJSON_GetObjectItem(Array_obj2,"text");
	Array_obj6=cJSON_GetObjectItem(Array,"location");
	Array_obj7=cJSON_GetObjectItem(Array_obj6,"name");
	Array_obj8=cJSON_GetObjectItem(Array,"last_update");
	printf("城市: %s	 ",Array_obj7->valuestring);  
	printf("天气: %s	 ",Array_obj5->valuestring);
	//printf("\r\n%s\r\n",Array_obj3->valuestring); 				//天气代码
	printf("气温: %s度	  ",Array_obj4->valuestring);				//气温
	printf("时间: %s\r\n",Array_obj8->valuestring); 
printf("=============================================================================\r\n");
}

cJSON_Delete(json);//释放json

ESP8266_Send("+++");

改成成都后，查看成都天气预报

手机天气预报

对的很准。
到此，使用瑞萨RA4L1和ESP8266获取城市天气预报就完结了！！！