int wlan_init_card(WlanCard *cardinfo)
{
WlanCard *card = cardinfo;
card->ScanMode = HostCmd_BSS_TYPE_ANY;
card->ScanProbes = 0;
cardinfo->State11D.Enable11D = DISABLE_11D;
memset(&(card->parsed_region_chan), 0, sizeof(parsed_region_chan_11d_t));
/* scan time */
card->SpecificScanTime = MRVDRV_SPECIFIC_SCAN_CHAN_TIME;
card->ActiveScanTime = MRVDRV_ACTIVE_SCAN_CHAN_TIME;
card->PassiveScanTime = MRVDRV_PASSIVE_SCAN_CHAN_TIME;
card->InfrastructureMode = Wlan802_11Infrastructure;
card->AdhocAESEnabled = FALSE;
card->ScanPurpose = ScanIdle;
card->ListenInterval = MRVDRV_DEFAULT_LISTEN_INTERVAL;
card->CurrentPacketFilter = HostCmd_ACT_MAC_RX_ON | HostCmd_ACT_MAC_TX_ON;
card->DataRate = 0; // Initially indicate the rate as auto
card->Is_DataRate_Auto = TRUE;
card->PktTxCtrl = 0;
card->MediaConnectStatus = WlanMediaStateDisconnected;
cardinfo->SeqNum = 1;
card->RxQueueCount = 0;
/* initialize Rx list of card */
card->RxList.next = card->RxList.pre = &card->RxList;
card->ScanTable = (BSSDescriptor_t *) rt_calloc(1, sizeof(BSSDescriptor_t));
card->CmdResBuf = rt_calloc(1, WLAN_UPLD_SIZE);
card->ScanResultInfo = NULL;
card->ScanResultcount = 0;
return 0;
}
/*
* head_name[] -- 最后一个元素必须是NULL
* rows -- 包含表头在内
*/
rtgui_form_t *rtgui_form_create(const char *head_name[], int rows, int cols, rtgui_rect_t *rect)
{
int i, len;
struct rtgui_form *form;
if (NULL==head_name || NULL==rect)
return NULL;
form = (struct rtgui_form *)rtgui_widget_create(RTGUI_FORM_TYPE);
if (NULL == form)
return NULL;
i = 0;
while (NULL != head_name[i])
++i;
if (i != cols) {
form_debug(("%s(), head items (%d) not same as cols(%d)!\n", __FUNCTION__, i, cols));
goto err_entry;
}
form_debug(("%s(), line:%d: rows:%d, cols:%d!\n", __FUNCTION__, __LINE__, rows, cols));
len = 0;
for (i=0; i<cols; ++i) {
len += rt_strlen(head_name[i]);
}
len += cols * GAG_BETWEEN_COL;
form->fbody = rt_calloc(len*(rows-1), 1); /* 不包含表格头部占用的存储空间 */
if (NULL == form->fbody) {
form_debug(("fun:%s(), line:%d:%d malloc fail!\n", __FUNCTION__, __LINE__, len*(rows-1)));
goto err_entry;
}
form->head_name = rt_calloc(cols, sizeof(head_name[0]));
if (NULL == form->head_name) {
form_debug(("fun:%s(), line:%d:%d malloc fail!\n", __FUNCTION__, __LINE__, cols * sizeof(head_name[0])));
rt_free(form->fbody);
goto err_entry;
}
form_debug(("%s(), line:%d: fbody-len:%d, head-name-len:%d!\n", __FUNCTION__, __LINE__,
len*(rows-1), cols * sizeof(head_name[0])));
for (i=0; i<cols; ++i) {
form->head_name[i] = head_name[i];
}
form->head_item_cnt = cols;
form->row_cnt_of_fbody = rows - 1;
form->bytes_of_row = len;
rtgui_widget_set_rect(RTGUI_WIDGET(form), rect);
return form;
err_entry:
rtgui_widget_destroy(RTGUI_WIDGET(form));
return NULL;
}
void correct_gryo()
{
rt_uint32_t e;
rt_uint16_t i;
rt_int16_t * mpu1, *mpu2, *mpu3;
rt_int16_t m1, m2, m3;
rt_kprintf("start sensors correct\n");
mpu1 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));
mpu2 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));
mpu3 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));
for (i = 0;i < 255;i++)
{
if (rt_event_recv(&ahrs_event, AHRS_EVENT_Update,
RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
RT_WAITING_FOREVER, &e) == RT_EOK)
{
m1 = MoveAve_SMA(mpu_gryo_pitch, mpu1, 255);
m2 = MoveAve_SMA(mpu_gryo_roll, mpu2, 255);
m3 = MoveAve_SMA(mpu_gryo_yaw, mpu3, 255);
}
}
MPU6050_Diff[0] -= m1;
MPU6050_Diff[1] -= m2;
MPU6050_Diff[2] -= m3;
rt_free(mpu1);
rt_free(mpu2);
rt_free(mpu3);
rt_kprintf("sensor correct finish.\n");
}
void correct_thread_entry(void* parameter)
{
rt_uint32_t e;
rt_uint16_t i;
rt_int16_t * mpu1, *mpu2, *mpu3;
rt_int16_t m1, m2, m3;
rt_sem_init(&angle_fix_sem, "angle_fix", 0, RT_IPC_FLAG_FIFO);
while (1)
{
rt_sem_take(&angle_fix_sem, RT_WAITING_FOREVER);
rt_kprintf("start angle fix\n");
settings.angle_diff_pitch = 0;
settings.angle_diff_roll = 0;
settings.angle_diff_yaw = 0;
mpu1 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));
mpu2 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));
mpu3 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));
for (i = 0;i < 255;i++)
{
if (rt_event_recv(&ahrs_event, AHRS_EVENT_Update,
RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
RT_WAITING_FOREVER, &e) == RT_EOK)
{
m1 = MoveAve_SMA(ahrs.degree_pitch*1000.0f, mpu1, 255);
m2 = MoveAve_SMA(ahrs.degree_roll *1000.0f, mpu2, 255);
m3 = MoveAve_SMA(ahrs.degree_yaw *1000.0f, mpu3, 255);
}
}
settings.angle_diff_pitch = -m1 / 1000.0f;
settings.angle_diff_roll = -m2 / 1000.0f;
settings.angle_diff_yaw = -m3 / 1000.0f;
rt_free(mpu1);
rt_free(mpu2);
rt_free(mpu3);
rt_kprintf("pitch:%d roll:%d yaw:%d\n",
(s16)(settings.angle_diff_pitch),
(s16)(settings.angle_diff_roll),
(s16)(settings.angle_diff_yaw));
rt_kprintf("degree fix finish.\n");
save_settings(&settings, "/setting");
}
}
/*
* 该函数用于在没有系统数据表格时, 建立数据表格
*/
int init_syscfgdata_tbl(void)
{
int i;
struct syscfgdata_tbl *p;
rt_uint32_t ver_temp1, ver_temp2;
if (SYSCFGDATA_TBL_SIZE_OF_FLASH > (PAGE_NUM_USED_BY_SYSCFGDATA_TBL * SIZE_PER_FLASH_PAGE)) {
rt_kprintf("error:sys table(%u) too large(shoule small than %u)", SYSCFGDATA_TBL_SIZE_OF_FLASH,
PAGE_NUM_USED_BY_SYSCFGDATA_TBL * SIZE_PER_FLASH_PAGE);
while(1);
}
syscfgdata_tbl_cache = rt_calloc(sizeof(*syscfgdata_tbl_cache), 1);
if (NULL == syscfgdata_tbl_cache) {
rt_kprintf("func:%s, out of mem\n", __FUNCTION__);
while(1);
}
if (RT_EOK != rt_sem_init(&write_syscfgdata_sem, "sysdata", 1, RT_IPC_FLAG_PRIO)) {
rt_kprintf("func:%s, sem init fail\n", __FUNCTION__);
while(1);
}
p = &syscfgdata_tbl_cache->syscfg_data;
SYSCFG_DATA_LOG(("on-chip flash page num:%d, sys tbl flash-addr:0x:%x, cache-addr:0x%x, "
"db-tbl-size:%d, prev db-tbl-size:%d\n",
PAGE_NUM_OF_ONCHIP_FLASH, SYSCFGDATA_TBL_BASE_OF_FLASH, p,
SYSCFGDATA_TBL_SIZE_OF_FLASH, SYSCFGDATA_TBL_PREV_SIZE_OF_FLASH));
if (IS_SYSCFG_TBL_OF_FLASH_VALID) {
read_whole_syscfgdata_tbl(p, SYSCFGDATA_TBL_SIZE_OF_FLASH);
update_db_if_need(p);
ver_temp1 = (RT_APP_VERSION<<16) | (RT_APP_SUBVERSION<<8) | (RT_APP_REVISION);
ver_temp2 = (M3_DB_VERSION<<16) | (M3_DB_SUBVERSION<<8) | (M3_DB_REVISION);
if (ver_temp1!=p->m3_sys_info.sw_ver || ver_temp2!=p->m3_sys_info.db_ver) {
p->m3_sys_info.sw_ver = ver_temp1;
p->m3_sys_info.db_ver = ver_temp2;
set_syscfgdata_tbl_dirty(syscfgdata_tbl_cache->systbl_flag_set);
}
return RT_EOK;
}
/* 数据库为空, 需要创建数据库 */
/* systbl_head */
p->systbl_head.magic_num = SYSCFGDATA_TBL_MAGIC_NUM;
set_systbl_to_default_value(p);
i = write_whole_syscfgdata_tbl(p);
SYSCFG_DATA_PRINT(("sys tbl size:%d, offset:%d\n", SYSCFGDATA_TBL_SIZE_OF_FLASH,
offsetof(struct syscfgdata_tbl, misc_byteinfo)));
return i;
}
int si_init_wl_data_proc(void)
{
sink_wl_collect_data = rt_calloc(SINKINFO_WL_DATA_ITEM_MAX_NO * sizeof(*sink_wl_collect_data), 1);
if (NULL == sink_wl_collect_data) {
printf_syn("alloc sink_wl_collect_data mem fail\n");
return FAIL;
}
rt_sem_init(&sink_wl_data_sem, "wl-data", 1, RT_IPC_FLAG_PRIO);
return SUCC;
}
void syscfgdata_syn_proc(void)
{
struct syscfgdata_tbl *p;
rt_err_t ret_sem;
if (is_syscfgdata_tbl_dirty(syscfgdata_tbl_cache->systbl_flag_set)
|| is_syscfgdata_tbl_wthrough(syscfgdata_tbl_cache->systbl_flag_set)) {
p = rt_calloc(RT_ALIGN(SYSCFGDATA_TBL_SIZE_OF_FLASH, 4), 1);
if (NULL == p) {
printf_syn("func:%s(), line:%d:mem alloc fail\n", __FUNCTION__, __LINE__);
return;
}
ret_sem = rt_sem_take(&write_syscfgdata_sem, RT_WAITING_FOREVER);
if (RT_EOK != ret_sem) {
SYSCFG_DATA_LOG(("func:%s, line:%d, error(%d)", __FUNCTION__, __LINE__, ret_sem));
goto free_entry;
}
if (0 != read_whole_syscfgdata_tbl(p, SYSCFGDATA_TBL_SIZE_OF_FLASH))
goto release_sem;
if (0==rt_memcmp(&syscfgdata_tbl_cache->syscfg_data, p, sizeof(syscfgdata_tbl_cache->syscfg_data)))
goto release_sem;
write_whole_syscfgdata_tbl(&syscfgdata_tbl_cache->syscfg_data);
clr_syscfgdata_tbl_dirty(syscfgdata_tbl_cache->systbl_flag_set);
clr_syscfgdata_tbl_wthrough(syscfgdata_tbl_cache->systbl_flag_set);
release_sem:
rt_sem_release(&write_syscfgdata_sem);
free_entry:
rt_free(p);
}
return;
}
static void do_update_db(struct syscfgdata_tbl *p)
{
#if 0
/* 仅用于测试数据库升级 */
struct syscfgdata_tbl_prev *prev;
rt_ubase_t len, len_diff, len_diff_prev;
char *ps, *pd;
SYSCFG_DATA_DEBUG(("%s(), line:%d\n", __func__, __LINE__));
prev = rt_calloc(sizeof(*prev), 1);
if (NULL == prev) {
rt_kprintf("func:%s, out of mem\n", __FUNCTION__);
while(1);
}
SYSCFG_DATA_DEBUG(("%s(), line:%d\n", __func__, __LINE__));
read_whole_syscfgdata_tbl(prev, SYSCFGDATA_TBL_PREV_SIZE_OF_FLASH);
/*
* 将prev中的相应值拷贝到p
* 从起始位置到第一个改动变量之前的内容都可以不必在这里拷贝
* */
/* copy same part */
len = offsetof(struct syscfgdata_tbl_prev, wl_master_info);
ps = (char *)prev;
pd = (char *)p;
rt_memcpy(pd, ps, len);
ps += len;
pd += len;
SYSCFG_DATA_DEBUG(("%s(), line:%d, len:%u\n", __func__, __LINE__, len));
/* diff part */
/* ...... */
/* next same part */
len_diff = sizeof(struct wl_master_485_slave_info_tbl);
len_diff_prev = sizeof(struct wl_master_485_slave_info_tbl_prev);
if (len&0x3 || len_diff&0x3 || len_diff_prev&0x3) {
rt_kprintf("NOTE:%s(), data len(%x, %x, %x) not alignment to 4 bytes\n",
__func__, len, len_diff, len_diff_prev);
}
ps += len_diff_prev;
pd += len_diff;
len = SYSCFGDATA_TBL_PREV_SIZE_OF_FLASH - len - len_diff_prev;
SYSCFG_DATA_DEBUG(("%s(), line:%d, %u, %u, %u\n", __func__, __LINE__, len_diff, len_diff_prev, len));
rt_memcpy(pd, ps, len);
SYSCFG_DATA_DEBUG(("%s(), line:%d, %d\n", __func__, __LINE__, SYSCFGDATA_TBL_PREV_SIZE_OF_FLASH-len-len_diff_prev));
rt_free(prev);
SYSCFG_DATA_DEBUG(("%s(), line:%d\n", __func__, __LINE__));
#endif
return;
}
/**************************************************************
* void chargen_thread(void *arg)
*
* chargen task. This server will wait for connections on well
* known TCP port number: 19. For every connection, the server will
* write as much data as possible to the tcp port.
**************************************************************/
static void chargen_thread(void *arg)
{
int listenfd;
struct sockaddr_in chargen_saddr;
fd_set readset;
fd_set writeset;
int i, maxfdp1;
struct charcb *p_charcb;
/* First acquire our socket for listening for connections */
listenfd = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
LWIP_ASSERT("chargen_thread(): Socket create failed.", listenfd >= 0);
memset(&chargen_saddr, 0, sizeof(chargen_saddr));
chargen_saddr.sin_family = AF_INET;
chargen_saddr.sin_addr.s_addr = htonl(INADDR_ANY);
chargen_saddr.sin_port = htons(19); // Chargen server port
if (lwip_bind(listenfd, (struct sockaddr *) &chargen_saddr, sizeof(chargen_saddr)) == -1)
LWIP_ASSERT("chargen_thread(): Socket bind failed.", 0);
/* Put socket into listening mode */
if (lwip_listen(listenfd, MAX_SERV) == -1)
LWIP_ASSERT("chargen_thread(): Listen failed.", 0);
/* Wait forever for network input: This could be connections or data */
for (;;) {
maxfdp1 = listenfd+1;
/* Determine what sockets need to be in readset */
FD_ZERO(&readset);
FD_ZERO(&writeset);
FD_SET(listenfd, &readset);
for (p_charcb = charcb_list; p_charcb; p_charcb = p_charcb->next) {
if (maxfdp1 < p_charcb->socket + 1)
maxfdp1 = p_charcb->socket + 1;
FD_SET(p_charcb->socket, &readset);
FD_SET(p_charcb->socket, &writeset);
}
/* Wait for data or a new connection */
i = lwip_select(maxfdp1, &readset, &writeset, 0, 0);
if (i == 0) continue;
/* At least one descriptor is ready */
if (FD_ISSET(listenfd, &readset)) {
/* We have a new connection request!!! */
/* Lets create a new control block */
p_charcb = (struct charcb *)rt_calloc(1, sizeof(struct charcb));
if (p_charcb) {
p_charcb->socket = lwip_accept(listenfd,
(struct sockaddr *) &p_charcb->cliaddr,
&p_charcb->clilen);
if (p_charcb->socket < 0)
rt_free(p_charcb);
else {
/* Keep this tecb in our list */
p_charcb->next = charcb_list;
charcb_list = p_charcb;
p_charcb->nextchar = 0x21;
}
} else {
/* No memory to accept connection. Just accept and then close */
int sock;
struct sockaddr cliaddr;
socklen_t clilen;
sock = lwip_accept(listenfd, &cliaddr, &clilen);
if (sock >= 0)
lwip_close(sock);
}
}
/* Go through list of connected clients and process data */
for (p_charcb = charcb_list; p_charcb; p_charcb = p_charcb->next) {
if (FD_ISSET(p_charcb->socket, &readset)) {
/* This socket is ready for reading. This could be because someone typed
* some characters or it could be because the socket is now closed. Try reading
* some data to see. */
if (do_read(p_charcb) < 0)
break;
}
if (FD_ISSET(p_charcb->socket, &writeset)) {
char line[80];
char setchar = p_charcb->nextchar;
for( i = 0; i < 59; i++) {
line[i] = setchar;
if (++setchar == 0x7f)
setchar = 0x21;
}
line[i] = 0;
strcat(line, "\n\r");
if (lwip_write(p_charcb->socket, line, strlen(line)) < 0) {
close_chargen(p_charcb);
break;
}
if (++p_charcb->nextchar == 0x7f)
p_charcb->nextchar = 0x21;
}
}
}
}
void *calloc(size_t nelem, size_t elsize)
{
return rt_calloc(nelem, elsize);
}
static rt_err_t mrvl_wlan_associate(struct rt_wlan_device* device)
{
WlanCard *card;
rt_err_t result = RT_EOK;
WlanConfig *config;
RT_ASSERT(device != RT_NULL);
card = WLAN_CARD(device);
if (device->ssid[0] == '\0') return -RT_ERROR;
/* set mode */
if (device->mode == WLAN_MODE_INFRA)
card->InfrastructureMode = Wlan802_11Infrastructure;
else
card->InfrastructureMode = Wlan802_11IBSS;
wlan_set_infrastructure(card);
config = (WlanConfig*) rt_calloc(1, sizeof(WlanConfig));
if (config == RT_NULL) return -RT_ENOMEM;
config->channel = device->channel;
/* copy SSID and base station address */
rt_strncpy(config->SSID, device->ssid, SSID_NAME_MAX);
memcpy(config->MacAddr, device->bs_addr, MAC_LENGTH_MAX);
if (device->password[0] == '\0') config->security = NoSecurity;
else
{
switch (device->security)
{
case WLAN_SECURITY_WEP:
config->security = WEP;
break;
case WLAN_SECURITY_WPA:
config->security = WPA_PSK;
break;
case WLAN_SECURITY_WPA2:
config->security = WPA2_PSK;
break;
default:
config->security = 0;
break;
}
rt_strncpy(config->password, device->password, PASSWORD_LENGTH_MAX);
}
if (device->channel == 0xff)
{
/* try to scan AP */
mrvl_scan_card(device, config);
}
if (config->channel == 0xff)
{
rt_kprintf("not found AP\n");
return -RT_ERROR;
}
/* set wlan status */
device->status = WLAN_STATUS_CONNECTING;
result = wlan_cmd_802_11_associate_cfg(card, config);
if (result != WLAN_STATUS_SUCCESS)
{
/* try to scan AP */
mrvl_scan_card(device, config);
/* associate again */
result = wlan_cmd_802_11_associate_cfg(card, config);
}
if (card->MediaConnectStatus == WlanMediaStateConnected)
device->status = WLAN_STATUS_CONNECTED;
else
device->status = WLAN_STATUS_IDLE;
/* save information on the wlan device */
device->channel = config->channel;
device->security = config->security;
memcpy(device->bs_addr, config->MacAddr, sizeof(device->bs_addr));
rt_free(config);
if (device->status == WLAN_STATUS_CONNECTED)
{
eth_device_linkchange(&device->parent, RT_TRUE);
return RT_EOK;
}
return -RT_ERROR;
}
static rt_err_t mrvl_scan_card(struct rt_wlan_device* device, WlanConfig *config)
{
rt_err_t result = RT_EOK;
WlanCard *card;
ScanResultItem * item;
int ret, i;
rt_uint8_t *scan_buf;
RT_ASSERT(device != RT_NULL);
card = WLAN_CARD(device);
scan_buf = (rt_uint8_t*)rt_calloc(1, SCAN_BUFSZ);
if (scan_buf == NULL)
{
WlanDebug(WlanErr,"WlanScan:alloc memory failed\r\n");
return -RT_ERROR;
}
ret = SendSpecificScanConfig(card, config, scan_buf, SCAN_BUFSZ);
if (ret != 0)
{
WlanDebug(WlanErr,"Filter channels scan failed\r\n");
return -RT_ERROR;
}
if (card->ScanResultcount == 0)
{
ret = SendScanToGetAPInfo(card, scan_buf, SCAN_BUFSZ);
if (ret != 0)
{
WlanDebug(WlanErr,"All channels scan failed\r\n");
return -RT_ERROR;
}
}
WlanDebug(WlanErr,"AP totaly %d\r\n",card->ScanResultcount);
for (i = 0; i < card->ScanResultcount; i++)
{
item = card->ScanResultInfo + i;
rt_kprintf("AP[%d]: %s ", i + 1, item->Ssid.Ssid);
rt_kprintf("BSSID:%x-%x-%x-%x-%x-%x ", item->MacAddress[0],
item->MacAddress[1], item->MacAddress[2],
item->MacAddress[3], item->MacAddress[4],
item->MacAddress[5]);
rt_kprintf("Channel:%d ", item->Channel);
rt_kprintf("RSSI:0x%x ", item->Rssi);
rt_kprintf("Privacy:0x%x ", item->Privacy);
switch (item->Security)
{
case WEP:
rt_kprintf("[WEP ]");
break;
case WPA_PSK:
rt_kprintf("[WPA ]");
break;
case WPA2_PSK:
rt_kprintf("[WPA2]");
break;
case NoSecurity:
rt_kprintf("[NONE]");
default:
break;
}
rt_kprintf("\r\n");
if (rt_strcmp(item->Ssid.Ssid, config->SSID) == 0)
{
/* set bs address and channel */
config->channel = item->Channel;
config->security = item->Security;
if(item->Privacy == 0)
{
if(item->Security == WEP)
{
config->security = NoSecurity;
}
else
{
WlanDebug(WlanErr, "Privacy = 0 but Security != WEP\r\n");
}
}
rt_memcpy(config->MacAddr, item->MacAddress, sizeof(item->MacAddress));
break;
}
}
/* release scan buffer */
rt_free(scan_buf);
card->ScanResulMuxsize=0;
card->ScanResultInfo = RT_NULL;
card->ScanResultcount=0;
}
