| | |
| | | #include "dw_app.h" |
| | | #include "ADC.h" |
| | | //#define TDFILTER |
| | | enum enumtagstate |
| | | { |
| | | DISCPOLL, |
| | | GETNEARMSG, |
| | | NEARPOLL, |
| | | }tag_state=GETNEARMSG; |
| | | }tag_state=NEARPOLL; |
| | | static dwt_config_t config = { |
| | | 2, /* Channel number. */ |
| | | DWT_PRF_64M, /* Pulse repetition frequency. */ |
| | |
| | | DWT_PAC8, /* Preamble acquisition chunk size. Used in RX only. */ |
| | | 9, /* TX preamble code. Used in TX only. */ |
| | | 9, /* RX preamble code. Used in RX only. */ |
| | | 0, /* Use non-standard SFD (Boolean) */ |
| | | 1, /* Use non-standard SFD (Boolean) */ |
| | | DWT_BR_6M8, /* Data rate. */ |
| | | DWT_PHRMODE_STD, /* PHY header mode. */ |
| | | (129 + 8 - 8) /* SFD timeout (preamble length + 1 + SFD length - PAC size). Used in RX only. */ |
| | |
| | | |
| | | static uint8_t tx_near_msg[80] = {0}; |
| | | |
| | | static uint32_t frame_seq_nb = 0; |
| | | uint32_t frame_seq_nb = 0, frame_seq_nb2 = 0; |
| | | static uint32_t status_reg = 0; |
| | | static uint8_t rx_buffer[100]; |
| | | static uint64_t poll_tx_ts; |
| | |
| | | } |
| | | } |
| | | } |
| | | void SetNLOSNTMSettings(void) |
| | | { |
| | | uint8_t temp; |
| | | temp = 7; |
| | | dwt_writetodevice(LDE_IF_ID,LDE_CFG1_OFFSET,1,&temp); |
| | | dwt_write16bitoffsetreg(LDE_IF_ID,LDE_CFG2_OFFSET,3); |
| | | // NTM = dwt_read32bitoffsetreg(LDE_IF_ID,LDE_CFG1_OFFSET) & LDE_CFG1_NSTDEV_MASK; |
| | | } |
| | | void Dw1000_Init(void) |
| | | { |
| | | /* Reset and initialise DW1000. |
| | |
| | | /* Configure DW1000. See NOTE 6 below. */ |
| | | dwt_configure(&config);//é
ç½®DW1000 |
| | | |
| | | |
| | | // SetNLOSNTMSettings(); |
| | | |
| | | /* Apply default antenna delay value. See NOTE 1 below. */ |
| | | dwt_setrxantennadelay(RX_ANT_DLY); //è®¾ç½®æ¥æ¶å¤©çº¿å»¶è¿ |
| | |
| | | } |
| | | return max_slotpos-1; |
| | | } |
| | | void OutputUserData(u16 devid,u8* addr,u8 len) |
| | | { |
| | | len++; |
| | | usart_send[2] = 0x11;//æ£å¸¸æ¨¡å¼ |
| | | usart_send[3] = len+4;//æ°æ®æ®µé¿åº¦ |
| | | memcpy(&usart_send[4],&devid,2); |
| | | memcpy(&usart_send[6],addr,len); |
| | | checksum = Checksum_u16(&usart_send[2],len+4); |
| | | memcpy(&usart_send[len+6],&checksum,2); |
| | | UART_PushFrame(usart_send,len+8); |
| | | } |
| | | u8 test=0; |
| | | u8 anclost_times=0; |
| | | u8 exsistbase_list[MAX_NEARBASE_NUM],report_num,get_newbase=0; |
| | | u16 temp_sync_timer1,temp_sync_timer2; |
| | | |
| | | u8 exsistbase_list[MAX_NEARBASE_NUM],report_num,get_newbase=0,temp_sendlen; |
| | | u16 temp_sync_timer1,temp_sync_timer2,rec_userdata_targetid; |
| | | extern u8 userdata[50]; |
| | | u8 tagrec_userdata[20],tagrec_datalen; |
| | | extern u32 getuserdata_tick; |
| | | void NearPoll(void) |
| | | { |
| | | static u8 mainbase_lost_count=0,flag_finalsend,flag_rxon; |
| | |
| | | memcpy(&tx_nearpoll_msg[NEARBASEID_INDEX],&nearbaseid_list,nearbase_num*2); |
| | | tx_nearpoll_msg[MESSAGE_TYPE_IDX] = NEAR_POLL; |
| | | memcpy(&tx_nearpoll_msg[ANCHOR_ID_IDX],&mainbase_id,2); |
| | | dwt_writetxdata(13+2*nearbase_num, tx_nearpoll_msg, 0);//å°Pollå
æ°æ®ä¼ ç»DW1000ï¼å°å¨å¼å¯åéæ¶ä¼ åºå» |
| | | dwt_writetxfctrl(13+2*nearbase_num, 0);//设置è¶
宽带åéæ°æ®é¿åº¦ |
| | | temp_sendlen = 0; |
| | | if(time32_incr-getuserdata_tick<500) |
| | | { |
| | | temp_sendlen +=7; |
| | | memcpy(&tx_nearpoll_msg[NEARBASEID_INDEX+nearbase_num*2],userdata,USERDATA_LEN+3); |
| | | }else{ |
| | | tx_nearpoll_msg[NEARBASEID_INDEX+nearbase_num*2] = 0; |
| | | } |
| | | |
| | | dwt_writetxdata(13+temp_sendlen+2*nearbase_num, tx_nearpoll_msg, 0);//å°Pollå
æ°æ®ä¼ ç»DW1000ï¼å°å¨å¼å¯åéæ¶ä¼ åºå» |
| | | dwt_writetxfctrl(13+temp_sendlen+2*nearbase_num, 0);//设置è¶
宽带åéæ°æ®é¿åº¦ |
| | | dwt_starttx(DWT_START_TX_IMMEDIATE | DWT_RESPONSE_EXPECTED);//å¼å¯åéï¼åé宿åçå¾
䏿®µæ¶é´å¼å¯æ¥æ¶ï¼çå¾
æ¶é´å¨dwt_setrxaftertxdelayä¸è®¾ç½® |
| | | |
| | | flag_finalsend=0; |
| | | flag_rxon=1; |
| | | neartimout_timer=0; |
| | | get_newbase=0; |
| | | timeout=ceil((float)nearbase_num*0.4)+3; |
| | | timeout=ceil((float)nearbase_num*SLOT_SCALE)+3; |
| | | //timeout=5; |
| | | mainbase_dist=100000; |
| | | mainbase_lost_count++; |
| | |
| | | temp_sync_timer2=sync_timer; |
| | | memcpy(&temp_sync_timer1,&rx_buffer[ANCTIMEMS],2); |
| | | memcpy(&tmp_time,&rx_buffer[ANCTIMEUS],2); |
| | | exsistbase_list[0]=KEEP_TIMES; |
| | | |
| | | |
| | | if(g_com_map[DEV_ROLE]!=0) |
| | | { |
| | |
| | | // tyncpoll_time=(tagslotpos-1)*slottime; |
| | | //////////////////////////// |
| | | rec_nearbasepos=0; |
| | | exsistbase_list[rec_nearbasepos]=KEEP_TIMES; |
| | | memcpy(&temp_dist,&rx_buffer[DIST_IDX],4); |
| | | nearbase_distlist[rec_nearbasepos]=temp_dist; |
| | | |
| | | memcpy(&temp_dist,&rx_buffer[DIST_IDX],4); |
| | | tagrec_datalen = rx_buffer[RT_USERDATA_INDEX+2]; |
| | | memcpy(&rec_userdata_targetid,&rx_buffer[RT_USERDATA_INDEX],2); |
| | | if(tagrec_datalen==USERDATA_LEN) |
| | | { |
| | | if(rec_userdata_targetid==dev_id||rec_userdata_targetid==0xffff) |
| | | { |
| | | memcpy(tagrec_userdata,&rx_buffer[RT_USERDATA_INDEX+2],tagrec_datalen+1); |
| | | OutputUserData(rec_nearbaseid,tagrec_userdata,tagrec_datalen); |
| | | } |
| | | } |
| | | nearbase_distlist[rec_nearbasepos]=temp_dist; |
| | | if(temp_dist!=0x1ffff) |
| | | exsistbase_list[rec_nearbasepos]=KEEP_TIMES; |
| | | |
| | | mainbase_lost_count=0; |
| | | flag_finalsend=1; |
| | | final_tx_time = (resp_rx_ts + ((RESP_RX_TO_FINAL_TX_DLY_UUS+DELAY_BETWEEN_TWO_FRAME_UUS*nearbase_num+500) * UUS_TO_DWT_TIME)) >> 8; |
| | |
| | | dwt_writetxdata(28+nearbase_num*4, tx_nearfinal_msg, 0);//å°åéæ°æ®åå
¥DW1000 |
| | | dwt_writetxfctrl(28+nearbase_num*4, 0);//设å®åéæ°æ®é¿åº¦ |
| | | memcpy(&rec_tagpos_binary,&rx_buffer[NEARMSG_EMPTYSLOTPOS_INDEX],4); |
| | | |
| | | if(temp_dist!=0x1ffff) |
| | | { |
| | | g_Resttimer=0; |
| | | #ifndef USART_INTEGRATE_OUTPUT |
| | | usart_send[2] = 1;//æ£å¸¸æ¨¡å¼ |
| | | usart_send[3] = 17;//æ°æ®æ®µé¿åº¦ |
| | | usart_send[4] = frame_seq_nb;//æ°æ®æ®µé¿åº¦ |
| | | if(g_com_map[DEV_ROLE]) |
| | | { |
| | | memcpy(&usart_send[5],&dev_id,2); |
| | | memcpy(&usart_send[7],&rec_nearbaseid,2); |
| | | }else{ |
| | | memcpy(&usart_send[5],&rec_nearbaseid,2); |
| | | memcpy(&usart_send[7],&dev_id,2); |
| | | } |
| | | memcpy(&usart_send[9],&rx_buffer[DIST_IDX],4); |
| | | usart_send[13] = battary; |
| | | usart_send[14] = button; |
| | | checksum = Checksum_u16(&usart_send[2],17); |
| | | memcpy(&usart_send[19],&checksum,2); |
| | | UART_PushFrame(usart_send,21); |
| | | #endif |
| | | |
| | | //dwt_setdelayedtrxtime(final_tx_time);//设置finalå
åéæ¶é´T5 |
| | | // result=dwt_starttx(DWT_START_TX_DELAYED);//设å®ä¸ºå»¶è¿åé |
| | | //dwt_writetxdata(4,&tx_near_msg[FINAL_MSG_RESP_RX_NEARBASE_IDX+(rec_nearbasepos+1)*4], FINAL_MSG_RESP_RX_NEARBASE_IDX+(rec_nearbasepos+1)*4);//å°åéæ°æ®åå
¥DW1000 |
| | | } |
| | | |
| | | |
| | | }else{ |
| | |
| | | memcpy(&tx_nearfinal_msg[ANCHOR_ID_IDX],&rec_nearbaseid,2); |
| | | } |
| | | |
| | | exsistbase_list[rec_nearbasepos]=KEEP_TIMES; |
| | | memcpy(&temp_dist,&rx_buffer[DIST_IDX],4); |
| | | tagrec_datalen = rx_buffer[RT_USERDATA_INDEX+2]; |
| | | memcpy(&rec_userdata_targetid,&rx_buffer[RT_USERDATA_INDEX],2); |
| | | if(tagrec_datalen==USERDATA_LEN) |
| | | { |
| | | if(rec_userdata_targetid==dev_id||rec_userdata_targetid==0xffff) |
| | | { |
| | | memcpy(tagrec_userdata,&rx_buffer[RT_USERDATA_INDEX+2],tagrec_datalen+1); |
| | | OutputUserData(rec_nearbaseid,tagrec_userdata,tagrec_datalen); |
| | | } |
| | | } |
| | | nearbase_distlist[rec_nearbasepos]=temp_dist; |
| | | |
| | | if(temp_dist!=0x1ffff) |
| | | exsistbase_list[rec_nearbasepos]=KEEP_TIMES; |
| | | |
| | | final_msg_set_ts(&tx_nearfinal_msg[FINAL_MSG_RESP_RX_NEARBASE_IDX+(rec_nearbasepos)*4], resp_rx_ts); |
| | | dwt_writetxdata(28+nearbase_num*4, tx_nearfinal_msg, 0);//å°åéæ°æ®åå
¥DW1000 |
| | |
| | | usart_send[2] = 1;//æ£å¸¸æ¨¡å¼ |
| | | usart_send[3] = 17;//æ°æ®æ®µé¿åº¦ |
| | | usart_send[4] = frame_seq_nb;//æ°æ®æ®µé¿åº¦ |
| | | if(g_com_map[DEV_ROLE]) |
| | | { |
| | | memcpy(&usart_send[5],&dev_id,2); |
| | | memcpy(&usart_send[7],&rec_nearbaseid,2); |
| | | memcpy(&usart_send[7],&rec_nearbaseid,2); |
| | | }else{ |
| | | memcpy(&usart_send[5],&rec_nearbaseid,2); |
| | | memcpy(&usart_send[7],&dev_id,2); |
| | | } |
| | | memcpy(&usart_send[9],&rx_buffer[DIST_IDX],4); |
| | | usart_send[13] = battary; |
| | | usart_send[14] = button; |
| | |
| | | // } |
| | | tagslotpos=GetRandomSlotPos(rec_tagpos_binary|tagpos_binary); |
| | | tyncpoll_time = (tagslotpos--%max_slotpos)*slottime; |
| | | tag_state=GETNEARMSG; |
| | | tag_state=NEARPOLL; |
| | | } |
| | | // tyncpoll_time=0; |
| | | next_nearbase_num=0; |
| | |
| | | tyncpoll_time = (tagslotpos--%max_slotpos)*slottime; |
| | | } |
| | | |
| | | #ifdef USART_INTEGRATE_OUTPUT |
| | | usart_send[2] = 4;//æ£å¸¸æ¨¡å¼ |
| | | usart_send[3] = report_num*6+2;//æ£å¸¸æ¨¡å¼ |
| | | checksum = Checksum_u16(&usart_send[2],report_num*6+2); |
| | | memcpy(&usart_send[4+report_num*6],&checksum,2); |
| | | UART_PushFrame(usart_send,6+report_num*6); |
| | | #endif |
| | | } |
| | | double firstpath_power, rx_power,rec_firstpath_power; |
| | | double f1, f2, r1, r2; |
| | | uint16_t F1,F2,F3,N,C; |
| | | double B = 131072; |
| | | double A = 121.74; |
| | | double min_power; |
| | | dwt_rxdiag_t d1; |
| | | double LOS(dwt_rxdiag_t *dia) { |
| | | F1 = dia->firstPathAmp1; |
| | | F2 = dia->firstPathAmp2; |
| | | F3 = dia->firstPathAmp3; |
| | | N = dia->rxPreamCount; |
| | | C = dia->maxGrowthCIR; |
| | | |
| | | firstpath_power=10* log10((F1*F1+F2*F2+F3*F3)/(N*N))-A; |
| | | rx_power=10*log10(C*B/(N*N))-A; |
| | | |
| | | // min_power = - 10 * log10((F1 *F1 + F2 * F2 + F3 * F3) / (C *B)); |
| | | return min_power; |
| | | } |
| | | void Tag_App(void)//å鿍¡å¼(TAGæ ç¾) |
| | | { |
| | | //LED0_ON; |
| | | dwt_forcetrxoff(); |
| | | g_Resttimer=0; |
| | | GPIO_WriteBit(GPIOA, GPIO_Pin_10, Bit_SET); |
| | | switch(tag_state) |
| | | { |
| | |
| | | |
| | | battary = rx_buffer[BATTARY_IDX]; |
| | | button = rx_buffer[BUTTON_IDX]; |
| | | frame_seq_nb = rx_buffer[SEQUENCE_IDX]; |
| | | frame_seq_nb2 = rx_buffer[SEQUENCE_IDX]; |
| | | if(result==0) |
| | | { |
| | | while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))///䏿æ¥è¯¢è¯çç¶æç´å°æ¥æ¶æåæè
åºç°é误 |
| | |
| | | dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR); |
| | | } |
| | | } |
| | | u8 misdist_num[TAG_NUM_IN_SYS],seize_anchor; |
| | | u8 misdist_num[TAG_NUM_IN_SYS],seize_anchor,getrange_success=0; |
| | | u8 Anchor_RecNearPoll(u8 ancrec_nearbasepos) //0 mainbase 1 first near_base |
| | | { |
| | | u8 motorstate; |
| | |
| | | |
| | | if(tagdist_list[taglist_pos]<g_com_map[ALARM_DISTANCE1]) |
| | | { |
| | | motorstate =3; |
| | | motorstate =0; |
| | | }else if(tagdist_list[taglist_pos]<g_com_map[ALARM_DISTANCE2]) |
| | | { |
| | | motorstate =2; |
| | |
| | | tx_nearresp_msg[MAINBASE_INDEX]=flag_syncbase; |
| | | tx_nearresp_msg[MESSAGE_TYPE_IDX]=NEAR_RESPONSE; |
| | | tx_nearresp_msg[MOTORSTATE_INDEX]=(remotesend_state<<4)|motorstate; |
| | | |
| | | if(remotesend_state) |
| | | { |
| | | memcpy(&tx_nearresp_msg[REMOTEPARA_INDEX],remotetag_para,REMOTEPARA_LEN); |
| | | dwt_writetxdata(22+REMOTEPARA_LEN, tx_nearresp_msg, 0);//åå
¥åéæ°æ® |
| | | dwt_writetxfctrl(22+REMOTEPARA_LEN, 0);//设å®åéé¿åº¦ |
| | | }else{ |
| | | dwt_writetxdata(22, tx_nearresp_msg, 0);//åå
¥åéæ°æ® |
| | | dwt_writetxfctrl(22, 0);//设å®åéé¿åº¦ |
| | | temp_sendlen = 0; |
| | | if(time32_incr-getuserdata_tick<500) |
| | | { |
| | | temp_sendlen+=7; |
| | | memcpy(&tx_nearresp_msg[RT_USERDATA_INDEX],userdata,USERDATA_LEN+3); |
| | | }else{ |
| | | tx_nearresp_msg[RT_USERDATA_INDEX] = 0; |
| | | |
| | | } |
| | | dwt_writetxdata(22+temp_sendlen, tx_nearresp_msg, 0);//åå
¥åéæ°æ® |
| | | dwt_writetxfctrl(22+temp_sendlen, 0);//设å®åéé¿åº¦ |
| | | } |
| | | result = dwt_starttx(DWT_START_TX_DELAYED | DWT_RESPONSE_EXPECTED);//å»¶è¿åéï¼çå¾
æ¥æ¶ |
| | | |
| | | battary = rx_buffer[BATTARY_IDX]; |
| | | button = rx_buffer[BUTTON_IDX]; |
| | | frame_seq_nb = rx_buffer[SEQUENCE_IDX]; |
| | | frame_seq_nb2 = rx_buffer[SEQUENCE_IDX]; |
| | | if(result==0) |
| | | { |
| | | while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR))&&!g_start_sync_flag)///䏿æ¥è¯¢è¯çç¶æç´å°æ¥æ¶æåæè
åºç°é误 |
| | |
| | | tof = tof_dtu * DWT_TIME_UNITS; |
| | | distance = tof * SPEED_OF_LIGHT;//è·ç¦»=å
é*é£è¡æ¶é´ |
| | | dist_no_bias = distance - dwt_getrangebias(config.chan, (float)distance, config.prf); //è·ç¦»åå»ç«æ£ç³»æ° |
| | | dist_cm = dist_no_bias * 100; //dis 为åä½ä¸ºcmçè·ç¦» |
| | | dist_cm = dist_no_bias * 1000; //dis 为åä½ä¸ºcmçè·ç¦» |
| | | |
| | | dwt_readdiagnostics(&d1); |
| | | LOS(&d1); |
| | | /*--------------------------以ä¸ä¸ºéæµè·é»è¾------------------------*/ |
| | | //dist_cm=33000; |
| | | |
| | | getrange_success = 1; |
| | | g_Resttimer=0; |
| | | LED0_BLINK; //æ¯æå䏿¬¡é讯åéªç䏿¬¡ |
| | | dis_after_filter=dist_cm; |
| | | hex_dist = dist_cm+(int16_t)g_com_map[DIST_OFFSET]; |
| | | hex_dist = dist_cm+(int16_t)g_com_map[DIST_OFFSET]*10; |
| | | g_flag_Taggetdist[taglist_pos]=0; |
| | | if(hex_dist>-1000&&hex_dist<100000) |
| | | { |
| | | if(abs(hex_dist-his_dist[taglist_pos])<1500||misdist_num[taglist_pos]>3) |
| | | { |
| | | // if(hex_dist>0&&hex_dist<2000000) |
| | | //{ |
| | | //if(abs(hex_dist-his_dist[taglist_pos])<10000||misdist_num[taglist_pos]>3) |
| | | //{ |
| | | int32_t filter_dist; |
| | | #ifdef TDFILTER |
| | | NewTrackingDiffUpdate(taglist_pos, (float)hex_dist); |
| | | filter_dist=pos_predict[taglist_pos]/10; |
| | | #else |
| | | filter_dist=hex_dist/10; |
| | | #endif |
| | | misdist_num[taglist_pos]=0; |
| | | tagdist_list[taglist_pos] = hex_dist; |
| | | tagdist_list[taglist_pos] = filter_dist; |
| | | his_dist[taglist_pos]=hex_dist; |
| | | g_Tagdist[taglist_pos]=hex_dist; |
| | | #ifndef USART_INTEGRATE_OUTPUT |
| | | g_Tagdist[taglist_pos]=filter_dist; |
| | | #ifndef USART_INTEGRATE_OUTPUT |
| | | usart_send[2] = 1;//æ£å¸¸æ¨¡å¼ |
| | | usart_send[3] = 17;//æ°æ®æ®µé¿åº¦ |
| | | usart_send[4] = frame_seq_nb;//æ°æ®æ®µé¿åº¦ |
| | | usart_send[4] = frame_seq_nb2;//æ°æ®æ®µé¿åº¦ |
| | | memcpy(&usart_send[5],&tag_id_recv,2); |
| | | memcpy(&usart_send[7],&dev_id,2); |
| | | memcpy(&usart_send[9],&tagdist_list[taglist_pos],4); |
| | | usart_send[13] = battary; |
| | | usart_send[14] = button; |
| | | usart_send[15] = firstpath_power; |
| | | usart_send[16] = rx_power; |
| | | checksum = Checksum_u16(&usart_send[2],17); |
| | | memcpy(&usart_send[19],&checksum,2); |
| | | UART_PushFrame(usart_send,21); |
| | |
| | | memcpy(&usart_send_anc[6+6*anc_report_num],&tagdist_list[taglist_pos],4); |
| | | anc_report_num++; |
| | | #endif |
| | | }else{ |
| | | // printf("%d",hex_dist); |
| | | misdist_num[taglist_pos]++; |
| | | } |
| | | } |
| | | // }else{ |
| | | // // printf("%d",hex_dist); |
| | | // misdist_num[taglist_pos]++; |
| | | // } |
| | | // } |
| | | } |
| | | }else{ |
| | | //printf("%x/n",status_reg); |
| | |
| | | // GPIO_WriteBit(GPIOA, GPIO_Pin_10, Bit_SET); |
| | | while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR))&&!g_start_send_flag&&!g_start_sync_flag)//䏿æ¥è¯¢è¯çç¶æç´å°æ¥æ¶æåæè
åºç°é误 |
| | | { |
| | | |
| | | IdleTask(); |
| | | }; |
| | | //GPIO_WriteBit(GPIOA, GPIO_Pin_10, Bit_RESET); |
| | |
| | | { u16 tag_recv_interval; |
| | | float temp_tagpos; |
| | | |
| | | g_Resttimer=0; |
| | | |
| | | dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG);//æ¸
餿 å¿ä½ |
| | | frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFL_MASK_1023;//è·å¾æ¥æ¶æ°æ®é¿åº¦ |
| | | dwt_readrxdata(rx_buffer, frame_len, 0);//è¯»åæ¥æ¶æ°æ® |
| | | memcpy(&anc_id_recv,&rx_buffer[ANCHOR_ID_IDX],2); |
| | | //å°æ¶å°çtag_idåå«åå
¥å次é讯çå
ä¸ï¼ä¸ºå¤æ ç¾é讯æå¡ï¼é²æ¢ä¸æ¬¡éè®¯ä¸æ¥æ¶å°ä¸åIDæ ç¾çæ°æ® |
| | | tag_id_recv = rx_buffer[TAG_ID_IDX]; |
| | | memcpy(&tag_id_recv,&rx_buffer[TAG_ID_IDX],2); |
| | | switch(rx_buffer[MESSAGE_TYPE_IDX]) |
| | | { |
| | | // case POLL: |
| | | // if (anchor_type == rx_buffer[ANC_TYPE_IDX]) |
| | | // Anchor_RecPoll(); |
| | | // break; |
| | | case SYNC: |
| | | case SYNC: |
| | | memcpy(&rec_syncid,&rx_buffer[ANCHOR_ID_IDX],4); |
| | | if(rec_syncid<current_syncid) |
| | | { |
| | |
| | | } |
| | | break; |
| | | |
| | | case NEAR_POLL: |
| | | case NEAR_POLL: |
| | | memcpy(&tag_id_recv,&rx_buffer[TAG_ID_IDX],2); |
| | | if(tag_id_recv>=g_com_map[WHITELIST1_START]&&tag_id_recv<=g_com_map[WHITELIST1_END]) |
| | | {break;} |
| | | taglist_pos=CmpTagInList(tag_id_recv); |
| | | if(taglist_pos==taglist_num) |
| | | { |
| | |
| | | temp_tagpos=round((float)(sync_timer%g_com_map[COM_INTERVAL])/slottime); |
| | | tagpos_rec[(u8)temp_tagpos]=1; |
| | | rec_nearbase_num=rx_buffer[NEARBASENUM_INDEX]; |
| | | |
| | | tagrec_datalen = rx_buffer[NEARBASEID_INDEX+rec_nearbase_num*2+2]; |
| | | memcpy(&rec_userdata_targetid,&rx_buffer[NEARBASEID_INDEX+rec_nearbase_num*2],2); |
| | | if(tagrec_datalen==USERDATA_LEN) |
| | | { |
| | | if(rec_userdata_targetid==dev_id||rec_userdata_targetid==0xffff) |
| | | { |
| | | memcpy(tagrec_userdata,&rx_buffer[NEARBASEID_INDEX+rec_nearbase_num*2+2],tagrec_datalen+1); |
| | | OutputUserData(tag_id_recv,tagrec_userdata,tagrec_datalen); |
| | | } |
| | | } |
| | | if(rec_nearbase_num>ancidlist_num) |
| | | { |
| | | ancidlist_num=rec_nearbase_num; |