bool mfg_test_for_app (void)
{
mico_uart_config_t uart_config;
volatile ring_buffer_t rx_buffer;
volatile uint8_t * rx_data;
rx_data = malloc (50);
require (rx_data, exit);
/* Initialize UART interface */
uart_config.baud_rate = 115200;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ((ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, 50);
MicoUartInitialize (MFG_TEST, &uart_config, (ring_buffer_t *)&rx_buffer);
if (MicoUartRecv (MFG_TEST, cmd_str, 3, 100) == kNoErr) {
if (cmd_str[0]=='#' && cmd_str[1]=='#' && cmd_str[2]=='#') {
test_for_app = 1;
return true;
} else
return false;
}
exit:
return false;
}
//uart.setup(1,9600,'n','8','1')
//baud:all supported
//parity:
// n,NO_PARITY;
// o,ODD_PARITY;
// e,EVEN_PARITY
//databits:
// 5:DATA_WIDTH_5BIT,
// 6:DATA_WIDTH_6BIT,
// 7:DATA_WIDTH_7BIT,
// 8:DATA_WIDTH_8BIT,
// 9:DATA_WIDTH_9BIT
//stopbits:
// 1,STOP_BITS_1
// 2,STOP_BITS_2
static int uart_setup( lua_State* L )
{
uint16_t id, databits=DATA_WIDTH_8BIT, parity=NO_PARITY, stopbits=STOP_BITS_1;
uint32_t baud=9600;
id = luaL_checkinteger( L, 1 );
MOD_CHECK_ID( uart, id );
baud = luaL_checkinteger( L, 2 );
size_t sl=0;
char const *str = luaL_checklstring( L, 3, &sl );
if(sl == 1 && strcmp(str, "n") == 0)
parity = NO_PARITY;
else if(sl == 1 && strcmp(str, "o") == 0)
parity = ODD_PARITY;
else if(sl == 1 && strcmp(str, "e") == 0)
parity = EVEN_PARITY;
else
return luaL_error( L, "arg parity should be 'n' or 'o' or 'e' " );
str = luaL_checklstring( L, 4, &sl );
if(sl == 1 && strcmp(str, "5") == 0)
databits = DATA_WIDTH_5BIT;
else if(sl == 1 && strcmp(str, "6") == 0)
databits = DATA_WIDTH_6BIT;
else if(sl == 1 && strcmp(str, "7") == 0)
databits = DATA_WIDTH_7BIT;
else if(sl == 1 && strcmp(str, "8") == 0)
databits = DATA_WIDTH_8BIT;
else if(sl == 1 && strcmp(str, "9") == 0)
databits = DATA_WIDTH_9BIT;
else
return luaL_error( L, "arg databits should be '5'~'9' " );
str = luaL_checklstring( L, 5, &sl );
if(sl == 1 && strcmp(str, "1") == 0)
stopbits = STOP_BITS_1;
else if(sl == 1 && strcmp(str, "2") == 0)
stopbits = STOP_BITS_2;
else
return luaL_error( L, "arg stopbits should be '1' or '2' " );
lua_usr_uart_config.baud_rate = baud;
lua_usr_uart_config.parity=(platform_uart_parity_t)parity;
lua_usr_uart_config.data_width =(platform_uart_data_width_t)databits;
lua_usr_uart_config.stop_bits =(platform_uart_stop_bits_t)stopbits;
if(lua_usr_rx_data !=NULL) free(lua_usr_rx_data);
lua_usr_rx_data = (uint8_t*)malloc(USR_INBUF_SIZE);
if(pinbuf !=NULL) free(pinbuf);
pinbuf = (uint8_t*)malloc(USR_UART_LENGTH);
ring_buffer_init( (ring_buffer_t*)&lua_usr_rx_buffer, (uint8_t*)lua_usr_rx_data, USR_INBUF_SIZE );
//MicoUartFinalize(LUA_USR_UART);
MicoUartInitialize( LUA_USR_UART, &lua_usr_uart_config, (ring_buffer_t*)&lua_usr_rx_buffer );
gL = L;
usr_uart_cb_ref = LUA_NOREF;
if(plua_usr_usart_thread !=NULL) mico_rtos_delete_thread(plua_usr_usart_thread);
mico_rtos_create_thread(plua_usr_usart_thread, MICO_DEFAULT_WORKER_PRIORITY, "lua_usr_usart_thread", lua_usr_usart_thread, 0x300, 0);
return 0;
}
int application_start(void)
{
app_log_trace();
OSStatus err = kNoErr;
mico_uart_config_t uart_config;
app_context_t* app_context;
mico_Context_t* mico_context;
/* Create application context */
app_context = ( app_context_t *)calloc(1, sizeof(app_context_t) );
require_action( app_context, exit, err = kNoMemoryErr );
/* Create mico system context and read application's config data from flash */
mico_context = mico_system_context_init( sizeof( application_config_t) );
app_context->appConfig = mico_system_context_get_user_data( mico_context );
/* mico system initialize */
err = mico_system_init( mico_context );
require_noerr( err, exit );
/* Bonjour for service searching */
MICOStartBonjourService( Station, app_context );
/* Protocol initialize */
sppProtocolInit( app_context );
/*UART receive thread*/
uart_config.baud_rate = app_context->appConfig->USART_BaudRate;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
if(mico_context->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable == true)
uart_config.flags = UART_WAKEUP_ENABLE;
else
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, UART_BUFFER_LENGTH );
MicoUartInitialize( UART_FOR_APP, &uart_config, (ring_buffer_t *)&rx_buffer );
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "UART Recv", uartRecv_thread, STACK_SIZE_UART_RECV_THREAD, (void*)app_context );
require_noerr_action( err, exit, app_log("ERROR: Unable to start the uart recv thread.") );
/* Local TCP server thread */
if(app_context->appConfig->localServerEnable == true)
{
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "Local Server", localTcpServer_thread, STACK_SIZE_LOCAL_TCP_SERVER_THREAD, (void*)app_context );
require_noerr_action( err, exit, app_log("ERROR: Unable to start the local server thread.") );
}
/* Remote TCP client thread */
if(app_context->appConfig->remoteServerEnable == true)
{
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "Remote Client", remoteTcpClient_thread, STACK_SIZE_REMOTE_TCP_CLIENT_THREAD, (void*)app_context );
require_noerr_action( err, exit, app_log("ERROR: Unable to start the remote client thread.") );
}
exit:
mico_rtos_delete_thread(NULL);
return err;
}
OSStatus MVDDevInterfaceInit(mico_Context_t* const inContext)
{
OSStatus err = kUnknownErr;
mico_uart_config_t uart_config;
//USART init
uart_config.baud_rate = inContext->flashContentInRam.appConfig.virtualDevConfig.USART_BaudRate;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
if(inContext->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable == true)
uart_config.flags = UART_WAKEUP_ENABLE;
else
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, UART_BUFFER_LENGTH );
MicoUartInitialize( UART_FOR_MCU, &uart_config, (ring_buffer_t *)&rx_buffer );
//USART receive thread
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "UART Recv",
uartRecv_thread, STACK_SIZE_USART_RECV_THREAD,
(void*)inContext );
require_noerr_action( err, exit, dev_if_log("ERROR: Unable to start the USART recv thread.") );
return kNoErr;
exit:
return err;
}
int application_start( void )
{
//start
// lua_printf( "\r\n\r\nMiCO starting...(Free memory %d bytes)\r\n",MicoGetMemoryInfo()->free_memory);
MicoInit();
//watch dog
MicoWdgInitialize( DEFAULT_WATCHDOG_TIMEOUT);
mico_init_timer(&_watchdog_reload_timer,DEFAULT_WATCHDOG_TIMEOUT/2, _watchdog_reload_timer_handler, NULL);
mico_start_timer(&_watchdog_reload_timer);
//usrinterface
//MicoCliInit();
#if 1
// lua_printf("Free memory %d bytes\r\n", MicoGetMemoryInfo()->free_memory);
lua_rx_data = (uint8_t*)malloc(INBUF_SIZE);
ring_buffer_init ( (ring_buffer_t*)&lua_rx_buffer, (uint8_t*)lua_rx_data, INBUF_SIZE );
MicoUartInitialize( LUA_UART, &lua_uart_config, (ring_buffer_t*)&lua_rx_buffer );
mico_rtos_create_thread(NULL, MICO_DEFAULT_WORKER_PRIORITY, "lua_main_thread", lua_main_thread, 20*1024, 0);
#endif
// while(1) {;}
mico_rtos_delete_thread(NULL);
lua_printf("application_start exit\r\n");
return 0;
}
OSStatus user_uartInit(void)
{
OSStatus err = kUnknownErr;
mico_uart_config_t uart_config;
//USART init
uart_config.baud_rate = 115200;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, USER_UART_BUFFER_LENGTH );
MicoUartInitialize( USER_UART, &uart_config, (ring_buffer_t *)&rx_buffer );
//USART receive thread 启动uart接收线程
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "UART Recv",
uartRecv_thread, STACK_SIZE_USART_RECV_THREAD,
NULL );
require_noerr_action( err, exit, user_uart_log("ERROR: Unable to start the USART recv thread.") );
//ZCB Msg Handle Thread 启动 ZCB Msg 处理线程
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "ZCB Msg Handle",
ZCB_MessageHandle_thread, STACK_SIZE_ZCBMSG_HANDLE_THREAD,
NULL );
require_noerr_action( err, exit, user_uart_log("ERROR: Unable to start the zcbMsg hdl thread.") );
return kNoErr;
exit:
return err;
}
void ConfigSoftApWillStart(mico_Context_t * const inContext )
{
OSStatus err;
mico_uart_config_t uart_config;
mico_stop_timer(&_Led_EL_timer);
mico_deinit_timer( &_Led_EL_timer );
mico_init_timer(&_Led_EL_timer, SYS_LED_TRIGGER_INTERVAL_AFTER_EASYLINK, _led_EL_Timeout_handler, NULL);
mico_start_timer(&_Led_EL_timer);
sppProtocolInit(inContext);
/*UART receive thread*/
uart_config.baud_rate = inContext->flashContentInRam.appConfig.USART_BaudRate;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, UART_BUFFER_LENGTH );
MicoUartInitialize( UART_FOR_APP, &uart_config, (ring_buffer_t *)&rx_buffer );
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "UART Recv", uartRecv_thread, STACK_SIZE_UART_RECV_THREAD, (void*)inContext );
require_noerr_action( err, exit, config_delegate_log("ERROR: Unable to start the uart recv thread.") );
if(inContext->flashContentInRam.appConfig.localServerEnable == true){
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "Local Server", localTcpServer_thread, STACK_SIZE_LOCAL_TCP_SERVER_THREAD, (void*)inContext );
require_noerr_action( err, exit, config_delegate_log("ERROR: Unable to start the local server thread.") );
}
exit:
return;
}
/* mxchip library manufacture test. */
void mxchip_mfg_test(void)
{
char str[64];
char mac[6];
char *ssid;
mico_uart_config_t uart_config;
volatile ring_buffer_t rx_buffer;
volatile uint8_t * rx_data;
rx_data = malloc(50);
require(rx_data, exit);
/* Initialize UART interface */
uart_config.baud_rate = 115200;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, 50 );
MicoUartInitialize( MFG_TEST, &uart_config, (ring_buffer_t *)&rx_buffer );
mf_printf("==== MXCHIP Manufacture Test ====\r\n");
mf_printf("Bootloader Version: ");
mf_printf(mico_get_bootloader_ver());
mf_printf("\r\n");
sprintf(str, "Library Version: %s\r\n", system_lib_version());
mf_printf(str);
mf_printf("APP Version: ");
memset(str, 0, sizeof(str));
system_version(str, sizeof(str));
mf_printf(str);
mf_printf("\r\n");
memset(str, 0, sizeof(str));
MicoGetRfVer(str, sizeof(str));
mf_printf("Driver: ");
mf_printf(str);
mf_printf("\r\n");
wlan_get_mac_address(mac);
sprintf(str, "MAC: %02X-%02X-%02X-%02X-%02X-%02X\r\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
mf_printf(str);
mfg_scan();
ssid = ssid_get();
mfg_connect(ssid);
exit:
mico_thread_sleep(MICO_NEVER_TIMEOUT);
}
OSStatus user_uartInit(void)
{
// OSStatus err = kUnknownErr;
mico_uart_config_t uart_config;
//USART init
uart_config.baud_rate = 115200;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, USER_UART_BUFFER_LENGTH );
MicoUartInitialize( USER_UART, &uart_config, (ring_buffer_t *)&rx_buffer );
return kNoErr;
}
OSStatus MICOStartUart( mico_Context_t * const inContext )
{
OSStatus err = kNoErr;
mico_uart_config_t uart_config;
/*UART receive thread*/
uart_config.baud_rate = 115200;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
if(inContext->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable == true)
uart_config.flags = UART_WAKEUP_ENABLE;
else
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, UART_BUFFER_LENGTH );
MicoUartInitialize( UART_FOR_APP, &uart_config, (ring_buffer_t *)&rx_buffer );
return err;
}
OSStatus MICOStartApplication( mico_Context_t * const inContext )
{
app_log_trace();
OSStatus err = kNoErr;
mico_uart_config_t uart_config;
require_action(inContext, exit, err = kParamErr);
haProtocolInit(inContext);
/*Bonjour for service searching*/
if(inContext->flashContentInRam.micoSystemConfig.bonjourEnable == true)
MICOStartBonjourService( Station, inContext );
/*UART receive thread*/
uart_config.baud_rate = inContext->flashContentInRam.appConfig.USART_BaudRate;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
if(inContext->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable == true)
uart_config.flags = UART_WAKEUP_ENABLE;
else
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, UART_BUFFER_LENGTH );
MicoUartInitialize( UART_FOR_APP, &uart_config, (ring_buffer_t *)&rx_buffer );
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "UART Recv", uartRecv_thread, 0x200, (void*)inContext );
require_noerr_action( err, exit, app_log("ERROR: Unable to start the uart recv thread.") );
if(inContext->flashContentInRam.appConfig.localServerEnable == true){
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "Local Server", localTcpServer_thread, 0x350, (void*)inContext );
require_noerr_action( err, exit, app_log("ERROR: Unable to start the local server thread.") );
}
if(inContext->flashContentInRam.appConfig.remoteServerEnable == true){
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "Remote Client", remoteTcpClient_thread, 0x300, (void*)inContext );
require_noerr_action( err, exit, app_log("ERROR: Unable to start the remote client thread.") );
}
exit:
return err;
}
int application_start( void )
{
//start
// lua_printf( "\r\n\r\nMiCO starting...(Free memory %d bytes)\r\n",MicoGetMemoryInfo()->free_memory);
MicoInit();
//watch dog
MicoWdgInitialize( DEFAULT_WATCHDOG_TIMEOUT);
mico_init_timer(&_watchdog_reload_timer,DEFAULT_WATCHDOG_TIMEOUT/2, _watchdog_reload_timer_handler, NULL);
mico_start_timer(&_watchdog_reload_timer);
#if 0
#include "tm_stm32f4_usb_vcp.h"
lua_printf("\r\n\r\n TM_USB_VCP_Init:%d",TM_USB_VCP_Init());
uint8_t c;
//NVIC_SetVectorTable(NVIC_VectTab_FLASH, new_addr);
while(1)
{
if (TM_USB_VCP_GetStatus() == TM_USB_VCP_CONNECTED)
{
if (TM_USB_VCP_Getc(&c) == TM_USB_VCP_DATA_OK)
{
TM_USB_VCP_Putc(c);/* Return data back */
}
}
}
#endif
//usrinterface
//MicoCliInit();
#if 1
// lua_printf("Free memory %d bytes\r\n", MicoGetMemoryInfo()->free_memory);
lua_rx_data = (uint8_t*)malloc(INBUF_SIZE);
ring_buffer_init( (ring_buffer_t*)&lua_rx_buffer, (uint8_t*)lua_rx_data, INBUF_SIZE );
MicoUartInitialize( LUA_UART, &lua_uart_config, (ring_buffer_t*)&lua_rx_buffer );
mico_rtos_create_thread(NULL, MICO_DEFAULT_WORKER_PRIORITY, "lua_main_thread", lua_main_thread, 20*1024, 0);
#endif
// while(1) {;}
mico_rtos_delete_thread(NULL);
lua_printf("application_start exit\r\n");
return 0;
}
void mico_mfg_test(mico_Context_t *inContext)
{
network_InitTypeDef_adv_st wNetConfig;
int testCommandFd, scanFd;
uint8_t *buf = NULL;
int recvLength = -1;
fd_set readfds;
struct timeval_t t;
struct sockaddr_t addr;
socklen_t addrLen;
mico_uart_config_t uart_config;
volatile ring_buffer_t rx_buffer;
volatile uint8_t * rx_data;
OSStatus err;
buf = malloc(1500);
require_action(buf, exit, err = kNoMemoryErr);
rx_data = malloc(2048);
require_action(rx_data, exit, err = kNoMemoryErr);
/* Connect to a predefined Wlan */
memset( &wNetConfig, 0x0, sizeof(network_InitTypeDef_adv_st) );
strncpy( (char*)wNetConfig.ap_info.ssid, "William Xu", maxSsidLen );
wNetConfig.ap_info.security = SECURITY_TYPE_AUTO;
memcpy( wNetConfig.key, "mx099555", maxKeyLen );
wNetConfig.key_len = strlen( "mx099555" );
wNetConfig.dhcpMode = DHCP_Client;
wNetConfig.wifi_retry_interval = 100;
micoWlanStartAdv(&wNetConfig);
/* Initialize UART interface */
uart_config.baud_rate = 115200;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, 2048 );
MicoUartInitialize( UART_FOR_APP, &uart_config, (ring_buffer_t *)&rx_buffer );
err = mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "MFG UART Recv", uartRecvMfg_thread, 0x300, (void*)inContext );
/* Initialize UDP interface */
t.tv_sec = 5;
t.tv_usec = 0;
scanFd = socket(AF_INET, SOCK_DGRM, IPPROTO_UDP);
require_action(IsValidSocket( scanFd ), exit, err = kNoResourcesErr );
addr.s_port = 23230;
addr.s_ip = INADDR_ANY;
err = bind(scanFd, &addr, sizeof(addr));
require_noerr(err, exit);
testCommandFd = socket(AF_INET, SOCK_DGRM, IPPROTO_UDP);
require_action(IsValidSocket( testCommandFd ), exit, err = kNoResourcesErr );
addr.s_port = 23231;
addr.s_ip = INADDR_ANY;
err = bind(testCommandFd, &addr, sizeof(addr));
require_noerr(err, exit);
while(1) {
/*Check status on erery sockets on bonjour query */
FD_ZERO( &readfds );
FD_SET( testCommandFd, &readfds );
FD_SET( scanFd, &readfds );
select( 1, &readfds, NULL, NULL, &t );
/* Scan and return MAC address */
if (FD_ISSET(scanFd, &readfds)) {
recvLength = recvfrom(scanFd, buf, 1500, 0, &addr, &addrLen);
sendto(scanFd, inContext->micoStatus.mac, sizeof(inContext->micoStatus.mac), 0, &addr, addrLen);
}
/* Recv UDP data and send to COM */
if (FD_ISSET(testCommandFd, &readfds)) {
recvLength = recvfrom(testCommandFd, buf, 1500, 0, &addr, &addrLen);
MicoUartSend(UART_FOR_APP, buf, recvLength);
}
}
exit:
if(buf) free(buf);
}
/* mxchip library manufacture test. */
void mxchip_mfg_test(void)
{
char str[128];
char mac[6];
char *ssid;
mico_uart_config_t uart_config;
volatile ring_buffer_t rx_buffer;
volatile uint8_t * rx_data;
mico_debug_enabled = 0;
rx_data = malloc(50);
require(rx_data, exit);
/* Initialize UART interface */
uart_config.baud_rate = 115200;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ((ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, 50);
MicoUartInitialize (MFG_TEST, &uart_config, (ring_buffer_t *)&rx_buffer);
mf_printf ("==== MXCHIP Manufacture Test ====\r\n");
mf_printf ("Serial Number: ");
mf_printf (SERIAL_NUMBER);
mf_printf ("\r\n");
mf_printf ("App CRC: ");
memset (str, 0, sizeof (str));
app_crc (str, sizeof (str));
mf_printf (str);
mf_printf ("\r\n");
mf_printf ("Bootloader Version: ");
mf_printf (mico_get_bootloader_ver());
mf_printf ("\r\n");
sprintf (str, "Library Version: %s\r\n", system_lib_version());
mf_printf (str);
mf_printf ("APP Version: ");
memset (str, 0, sizeof (str));
system_version (str, sizeof (str));
mf_printf (str);
mf_printf ("\r\n");
memset (str, 0, sizeof (str));
wlan_driver_version (str, sizeof (str));
mf_printf ("Driver: ");
mf_printf (str);
mf_printf ("\r\n");
#ifdef MICO_BLUETOOTH_ENABLE
/* Initialise MICO SmartBridge */
mico_bt_init( MICO_BT_HCI_MODE, "SmartBridge Device", 0, 0 ); //Client + server connections
mico_bt_smartbridge_init( 0 );
mico_bt_dev_read_local_addr( (uint8_t *)mac );
sprintf( str, "Local Bluetooth Address: %02X-%02X-%02X-%02X-%02X-%02X\r\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5] );
mf_printf (str);
ble_scan();
#endif
wlan_get_mac_address (mac);
sprintf (str, "MAC: %02X-%02X-%02X-%02X-%02X-%02X\r\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
mf_printf(str);
mfg_scan();
if (test_for_app==0) {
ssid = ssid_get();
mfg_connect (ssid);
}
exit:
mico_thread_sleep(MICO_NEVER_TIMEOUT);
}
void mxchip_mfg_test(mico_Context_t *inContex)
{
char str[80];
char mac[6];
char *ssid;
UNUSED_PARAMETER(inContex);
mico_uart_config_t uart_config;
volatile ring_buffer_t rx_buffer;
volatile uint8_t * rx_data;
rx_data = malloc(100);
require(rx_data, exit);
/* Initialize UART interface */
uart_config.baud_rate = 115200;
uart_config.data_width = DATA_WIDTH_8BIT;
uart_config.parity = NO_PARITY;
uart_config.stop_bits = STOP_BITS_1;
uart_config.flow_control = FLOW_CONTROL_DISABLED;
uart_config.flags = UART_WAKEUP_DISABLE;
ring_buffer_init ( (ring_buffer_t *)&rx_buffer, (uint8_t *)rx_data, 100 );
MicoUartInitialize( MFG_TEST, &uart_config, (ring_buffer_t *)&rx_buffer );
sprintf(str, "Library Version: %s\r\n", system_lib_version());
mf_printf(str);
mf_printf("APP Version: ");
//memset(str, 0, sizeof(str));
//system_version(str, sizeof(str));
sprintf(str, "%s, build at %s %s, ", APP_INFO, __TIME__, __DATE__);
mf_printf(str);
sprintf(str, "%d.%d.%d",(u8)(ZC_MODULE_VERSION >> 16),(u8)(ZC_MODULE_VERSION >> 8),(u8)(ZC_MODULE_VERSION));
mf_printf(str);
mf_printf("\r\n");
mf_printf("Uart Info: ");
//memset(str, 0, sizeof(str));
//system_version(str, sizeof(str));
mf_printf(UART_INFO);
mf_printf("\r\n");
mf_printf("Server Info: ");
//memset(str, 0, sizeof(str));
//system_version(str, sizeof(str));
mf_printf(ADDR_INFO);
mf_printf("\r\n");
memset(str, 0, sizeof(str));
wlan_driver_version(str, sizeof(str));
mf_printf("Driver: ");
mf_printf(str);
mf_printf("\r\n");
wlan_get_mac_address(mac);
sprintf(str, "MAC: %02X-%02X-%02X-%02X-%02X-%02X\r\n",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
mf_printf(str);
mfg_scan();
ssid = ssid_get();
mfg_connect(ssid);
exit:
mico_thread_sleep(MICO_NEVER_TIMEOUT);
}
