/**
* @brief Initialize the middleware libraries and stacks
* @param None
* @retval None
*/
void MOD_LibInit(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
MOD_GetParam(GLOBAL_SETTINGS_MEM , &Global_Config.d32);
/* Force settings change to apply them */
Global_Config.b.Configuration_Changed = 1;
/* Starting USB Init. Process */
GL_State_Message((uint8_t *)"USB Host Starting. ");
/*Init USB Host */
USBH_Init(&USB_OTG_Core,
USB_OTG_FS_CORE_ID,
&USB_Host,
&USBH_MSC_cb,
&USBH_USR_cb);
GL_State_Message((uint8_t *)"USB Host Started.");
GL_State_Message((uint8_t *)"RTC and backup Starting. ");
/* Init RTC and Backup */
if ( RTC_Configuration() == 0)
{
GL_State_Message((uint8_t *)"RTC and backup Started.");
CONSOLE_LOG((uint8_t *)"[SYSTEM] RTC and backup Started.");
}
else
{
GL_State_Message((uint8_t *)"ERR : RTC could not be started.");
CONSOLE_LOG((uint8_t *)"[ERR] RTC start-up FAILED .");
}
NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
SD_Init();
if ( f_mount( 1, &MSD_fatfs ) != FR_OK )
{
/* fatfs initialisation fails*/
CONSOLE_LOG((uint8_t *)"[FS] Cannot initialize FS on drive 1.");
}
else
{
CONSOLE_LOG((uint8_t *)"[FS] FS on drive 1 initialized.");
}
}
static int start_update_download(struct update_context *ctx, const char *url) {
CONSOLE_LOG(LL_INFO, ("Updating FW"));
if (do_http_connect(ctx, url) < 0) {
ctx->status_msg = "Failed to connect update server";
return -1;
}
return 1;
}
MySQLp::MySQLp(const DataBaseHost &host)
:is_good_connection_(false), host_(host)
{
reconnect_flag_ = 1;//1表示自动重连 0表示不自动重连
mysql_init(&mysql_);
mysql_options(&mysql_,MYSQL_OPT_RECONNECT, &reconnect_flag_);
if (mysql_real_connect(&mysql_, host_.ip_.c_str(), host_.usr_.c_str(), host_.pwd_.c_str(), host_.dbname_.c_str(), host_.port_, 0, 0))
{
is_good_connection_ = true;
//INDEX_EVENT("MySQLp::Conect() Connect Succeed ");
//INDEX_EVENT("MySQLp::Conect() IP = " << host_.ip_);
}
else
{
CONSOLE_LOG("MySQLp::Conect() Connect Failed");
CONSOLE_LOG("MySQLp::Conect() IP = " << host_.ip_ << "\tport = " << host_.port_);
}
}
/**
* @brief Inititialize the target hardware.
* @param None
* @retval None
*/
uint32_t BSP_Init (void)
{
/* Initialize the LEDs */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
CONSOLE_LOG((uint8_t *)"[SYSTEM] Data RAM Init : OK.");
/* Initialize the LCD */
GL_LCD_Init();
CONSOLE_LOG((uint8_t *)"[SYSTEM] LCD Init : OK.");
/* Initialize the TSC */
GL_TSC_Init();
CONSOLE_LOG((uint8_t *)"[SYSTEM] Touchscreen Init : OK.");
/* Initialize the Joystick */
GL_JOY_Init();
CONSOLE_LOG((uint8_t *)"[SYSTEM] Joystick Init : OK.");
/* Initialize the PSRAM */
SRAM_Init();
CONSOLE_LOG((uint8_t *)"[SYSTEM] SRAM Init: OK.");
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_BKPSRAM, ENABLE);
CONSOLE_LOG((uint8_t *)"[SYSTEM] BKPSRAM Init : OK.");
SYSCFG_CompensationCellCmd(ENABLE);
/* Enable RNG clock source */
RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_RNG, ENABLE);
/* RNG Peripheral enable */
RNG_Cmd(ENABLE);
return 0;
}
/**
* @brief Add a module in the module's list
* @param module: module structure pointer
* @param group: group that the module belong to
* @retval Status
*/
uint8_t MOD_AddModule(MOD_InitTypeDef *module, uint8_t group)
{
uint8_t idx = 0;
char temp[40];
/* check for id unicity */
for ( ; idx < MOD_table[group].counter ; idx ++)
{
if (MOD_table[group].module[idx]->id == module->id)
{
sprintf(temp, "ERROR : %s module cannot be loaded", MOD_table[group].module[idx]->name);
CONSOLE_LOG((uint8_t *)temp);
return 1;
}
}
MOD_table[group].module[MOD_table[group].counter] = module;
MOD_table[group].counter ++;
sprintf(temp, "[SYSTEM] %s module v%d.%d.%d loaded.",
MOD_table[group].module[idx]->name,
HIBYTE(MOD_table[group].module[idx]->rev) , LOBYTE(MOD_table[group].module[idx]->rev) >> 4, MOD_table[group].module[idx]->rev & 0xF );
CONSOLE_LOG((uint8_t *)temp);
return 0;
}
void ContentQuotaScheduler::ReloadConfig(ContentManagerCfg *m_inconfig, bool is_started)
{
max_daily_rid_num = m_inconfig->CONTENT_RIDS_DAILY_NUM;
max_minute_rid_num = m_inconfig->CONTENT_RIDS_MINUTE_NUM;
pause_time_start = m_inconfig->CONTENT_PAUSE_START_TIME;
pause_time_end = m_inconfig->CONTENT_PAUSE_END_TIME;
if (true == is_started) {
LOG4CPLUS_INFO(g_logger, "Scheduler: config reloaded, daily_cap "<< max_daily_rid_num
<< " minute_cap " << max_minute_rid_num << " pause_start " << pause_time_start << " end " << pause_time_end);
}else{
CONSOLE_LOG("Scheduler: config loaded, daily_cap "<< max_daily_rid_num
<< " minute_cap " << max_minute_rid_num << " pause_start " << pause_time_start << " end " << pause_time_end);
}
}
/**
* @brief Initialize the target hardware and the console
* @param None
* @retval None
*/
void MOD_PreInit(void)
{
memset(MOD_table, 0, sizeof(GROUP_InitTypeDef));
/* Init Console to save events log*/
CONSOLE_Init();
CONSOLE_LOG((uint8_t *)"[SYSTEM] Module Manager running....");
/* Init Board specific hardware */
BSP_Init();
/*Init heap memory (located in SRAM)*/
mem_pool_init();
}
static int do_http_connect(struct update_context *ctx, const char *url) {
LOG(LL_DEBUG, ("Connecting to: %s", url));
struct mg_connect_opts opts;
memset(&opts, 0, sizeof(opts));
#ifdef MG_ENABLE_SSL
if (strlen(url) > 8 && strncmp(url, "https://", 8) == 0) {
opts.ssl_server_name = get_cfg()->update.ssl_server_name;
opts.ssl_ca_cert = get_cfg()->update.ssl_ca_file;
#ifndef cc3200
if (opts.ssl_ca_cert == NULL) {
/* Use global CA file if updater specific one is not set */
opts.ssl_ca_cert = get_cfg()->tls.ca_file;
}
#else
/*
* SimpleLink only accepts one cert in DER format as a CA file so we can't
* use a pre-packaged bundle and expect it to work, sadly.
*/
#endif
opts.ssl_cert = get_cfg()->update.ssl_client_cert_file;
}
#endif
struct mg_connection *c = mg_connect_http_opt(&sj_mgr, fw_download_ev_handler,
opts, url, NULL, NULL);
if (c == NULL) {
CONSOLE_LOG(LL_ERROR, ("Failed to connect to %s", url));
return -1;
}
c->user_data = ctx;
return 1;
}
/**
* @brief USBD_USR_DeviceDisonnected
* Displays the message on LCD on device disconnection Event
* @param None
* @retval Staus
*/
void USBD_USR_DeviceDisconnected (void)
{
CONSOLE_LOG ((uint8_t *)"[USBD] USB Device Disconnected..");
USBD_SetStateMsg ((uint8_t *)"STATE: USB Device Disconnected..");
}
/**
* @brief Displays the message on LCD on device suspend event
* @param None
* @retval None
*/
void USBD_USR_DeviceSuspended(void)
{
CONSOLE_LOG ((uint8_t *)"[USBD] Device In suspend mode.");
USBD_SetStateMsg ((uint8_t *)"STATE: Device In Suspend mode.");
}
/**
* @brief Displays the message on LCD on device config event
* @param None
* @retval Staus
*/
void USBD_USR_DeviceConfigured (void)
{
CONSOLE_LOG ((uint8_t *)"[USBD] Device Interface started.");
USBD_SetStateMsg ((uint8_t *)"STATE: Device running.");
}
/**
* @brief Displays the message on LCD on device lib initialization
* @param None
* @retval None
*/
void USBD_USR_Init(void)
{
CONSOLE_LOG ((uint8_t *)"[USBD] USB device library started.");
}
void StunServerListConfig::LoadFile(const TCHAR *file_name)
//¶ÁÈ¡StunServerListÎļþ
{
tstring moduleName = file_name;
framework::mswin::Module module;
framework::io::Path config_path;
module.BuildLocalFilePath(config_path, moduleName.c_str());
framework::io::StdFileReader config_reader;
config_reader.OpenText(config_path);
if (config_reader.IsOpen())
{
string config_line;
stun_info_.clear();
while(config_reader.ReadLine(config_line))
{
boost::algorithm::trim(config_line);
if ( config_line.empty() == true || config_line[0] == '#' )
{
continue;
}
else
{
STUN_SERVER_INFO ds;
bool is_succed = false;
try
{
vector<string> tracker_s;
char split_char_s[] = " \t\r\n";
char ip_split_char_s[] = ".";
boost::algorithm::split(tracker_s, config_line, boost::algorithm::is_any_of(split_char_s));
int pos = 0;
for(vector<string>::iterator iter = tracker_s.begin();
iter != tracker_s.end(); iter ++)
{
if( boost::algorithm::trim_copy(*iter).empty() == true )
{
continue;
}
else if( pos == 0 )
{
if(boost::algorithm::to_lower_copy(*iter) == "udp")
{
ds.Type = 1;
}
else
{
//?
ds.Type = 0;
}
pos ++;
}
else if( pos == 1 )
{
boost::asio::ip::address_v4 addr = boost::asio::ip::address_v4::from_string(*iter);
ds.IP = addr.to_ulong();
pos ++;
}
else if( pos == 2 )
{
ds.Port = boost::lexical_cast<u_short>(*iter);
is_succed = true;
break;
}
} // end for
}
catch (boost::bad_lexical_cast&)
{
assert(0);
}
if( is_succed == true )
{
stun_info_.push_back(ds);
}
else
{
CONSOLE_LOG("There\'s an error line in the stun server list file!");
}
} // end if-else
} // end while
}
else
{
CONSOLE_LOG("StunServerListConfig::LoadFile() Failed to Open the stun server List File");
}
}
static void fw_download_ev_handler(struct mg_connection *c, int ev, void *p) {
struct mbuf *io = &c->recv_mbuf;
struct update_context *ctx = (struct update_context *) c->user_data;
(void) p;
switch (ev) {
case MG_EV_RECV: {
if (ctx->archive_size == 0) {
LOG(LL_DEBUG, ("Looking for HTTP header"));
struct http_message hm;
int parsed = mg_parse_http(io->buf, io->len, &hm, 0);
if (parsed <= 0) {
return;
}
if (hm.body.len != 0) {
LOG(LL_DEBUG, ("HTTP header: file size: %d", (int) hm.body.len));
if (hm.body.len == (size_t) ~0) {
CONSOLE_LOG(LL_ERROR,
("Invalid content-length, perhaps chunked-encoding"));
ctx->status_msg =
"Invalid content-length, perhaps chunked-encoding";
c->flags |= MG_F_CLOSE_IMMEDIATELY;
break;
} else {
ctx->archive_size = hm.body.len;
}
mbuf_remove(io, parsed);
}
}
if (io->len != 0) {
int res = updater_process(ctx, io->buf, io->len);
LOG(LL_DEBUG, ("Processed %d bytes, result: %d", (int) io->len, res));
mbuf_remove(io, io->len);
if (res == 0) {
/* Need more data, everything is OK */
break;
}
if (res > 0) {
if (!is_update_finished(ctx)) {
/* Update terminated, but not because of error */
notify_js(UJS_NOTHING_TODO, NULL);
sj_clubby_send_status_resp(s_clubby_reply, 0, ctx->status_msg);
} else {
/* update ok */
int len;
char *upd_data = sj_clubby_repl_to_bytes(s_clubby_reply, &len);
FILE *tmp_file = fopen(UPDATER_TEMP_FILE_NAME, "w");
if (tmp_file == NULL || upd_data == NULL) {
/* There is nothing we can do */
free(upd_data);
if (tmp_file) fclose(tmp_file);
CONSOLE_LOG(LL_ERROR, ("Cannot save update status"));
} else {
fwrite(upd_data, 1, len, tmp_file);
fclose(tmp_file);
CONSOLE_LOG(LL_INFO, ("Update completed successfully"));
}
updater_finish(ctx);
}
} else if (res < 0) {
/* Error */
CONSOLE_LOG(LL_ERROR,
("Update error: %d %s", ctx->result, ctx->status_msg));
notify_js(UJS_ERROR, NULL);
sj_clubby_send_status_resp(s_clubby_reply, 1, ctx->status_msg);
}
c->flags |= MG_F_CLOSE_IMMEDIATELY;
}
break;
}
case MG_EV_CLOSE: {
if (ctx != NULL) {
if (!is_update_finished(ctx)) {
/* Connection was terminated by server */
notify_js(UJS_ERROR, NULL);
sj_clubby_send_status_resp(s_clubby_reply, 1, "Update failed");
} else if (is_reboot_required(ctx) && !notify_js(UJS_COMPLETED, NULL)) {
/*
* Conection is closed by updater, rebooting if required
* and allowed (by JS)
*/
CONSOLE_LOG(LL_INFO, ("Rebooting device"));
updater_schedule_reboot(100);
}
if (s_clubby_reply) {
sj_clubby_free_reply(s_clubby_reply);
s_clubby_reply = NULL;
}
updater_finish(ctx);
updater_context_free(ctx);
c->user_data = NULL;
}
break;
}
}
}
static void handle_update_req(struct clubby_event *evt, void *user_data) {
char *zip_url;
struct json_token section = JSON_INVALID_TOKEN;
struct json_token blob_url = JSON_INVALID_TOKEN;
struct json_token args = evt->request.args;
(void) user_data;
LOG(LL_DEBUG, ("Update request received: %.*s", evt->request.args.len,
evt->request.args.ptr));
const char *reply = "Malformed request";
if (evt->request.args.type != JSON_TYPE_OBJECT) {
goto bad_request;
}
json_scanf(args.ptr, args.len, "{section: %T, blob_url: %T}", §ion,
&blob_url);
/*
* TODO(alashkin): enable update for another files, not
* firmware only
*/
if (section.len == 0 || section.type != JSON_TYPE_STRING ||
strncmp(section.ptr, "firmware", section.len) != 0 || blob_url.len == 0 ||
blob_url.type != JSON_TYPE_STRING) {
goto bad_request;
}
LOG(LL_DEBUG, ("zip url: %.*s", blob_url.len, blob_url.ptr));
sj_clubby_free_reply(s_clubby_reply);
s_clubby_reply = sj_clubby_create_reply(evt);
/*
* If user setup callback for updater, just call it.
* User can start update with Sys.updater.start()
*/
zip_url = calloc(1, blob_url.len + 1);
if (zip_url == NULL) {
CONSOLE_LOG(LL_ERROR, ("Out of memory"));
return;
}
memcpy(zip_url, blob_url.ptr, blob_url.len);
if (!notify_js(UJS_GOT_REQUEST, zip_url)) {
struct update_context *ctx = updater_context_create();
if (ctx == NULL) {
reply = "Failed to init updater";
} else if (start_update_download(ctx, zip_url) < 0) {
reply = ctx->status_msg;
}
}
free(zip_url);
return;
bad_request:
CONSOLE_LOG(LL_ERROR, ("Failed to start update: %s", reply));
sj_clubby_send_status_resp(evt, 1, reply);
}
/**
* @brief Background task
* @param pvParameters not used
* @retval None
*/
static void Background_Task(void * pvParameters)
{
static uint32_t ticks = 0;
/* Init Modules manager */
MOD_PreInit();
/*Add modules here */
MOD_AddModule(&mod_system, UTILITIES_GROUP);
MOD_AddModule(&mod_audio, MULTIMEDIA_GROUP);
MOD_AddModule(&mod_image, MULTIMEDIA_GROUP);
MOD_AddModule(&mod_ethernet, CONNECTIVITY_GROUP);
MOD_AddModule(&mod_camera, MULTIMEDIA_GROUP);
MOD_AddModule(&mod_usbd, CONNECTIVITY_GROUP);
MOD_AddModule(&mod_recorder, MULTIMEDIA_GROUP);
MOD_AddModule(&mod_serial, CONNECTIVITY_GROUP);
MOD_AddModule(&mod_calendar, UTILITIES_GROUP);
MOD_AddModule(&mod_filemgr, UTILITIES_GROUP);
MOD_AddModule(&mod_console, UTILITIES_GROUP);
MOD_AddModule(&mod_credits, UTILITIES_GROUP);
CONSOLE_LOG((uint8_t *)"[SYSTEM] System modules added.");
/* Show startup Page */
GL_Startup();
/* Init Libraries and stack here */
MOD_LibInit();
/* Show the main menu and start*/
GL_Init();
while (1)
{
if ( ticks++ > 10 )
{
ticks = 0;
/* toggle LED1..4 each 100ms */
STM_EVAL_LEDToggle(LED1);
STM_EVAL_LEDToggle(LED2);
STM_EVAL_LEDToggle(LED3);
STM_EVAL_LEDToggle(LED4);
/* Wait for HMI events */
GL_Handle_Inputs();
/*Update GUI processes */
GL_Background_Handler();
/* power saving mode */
GL_LowPower();
/* Apply new settings if they were changed */
GL_HandleSystemSettingsChange();
/* Display processes running in background */
GL_UpdateBackgroundProcessStatus();
}
/* Handle modules background tasks */
MOD_HandleModulesBackground();
/* This task is handled periodically, each 10 mS */
vTaskDelay(10);
}
}
