V2.8 完成注册功能

zhyinch

2020-11-02 c194f604712122b2640e10b6d7d901cf4ba3712f

 Ô´Âë/ºËÐÄ°å/Src/application/dw_app.c

@@ -9,11 +9,11 @@
static dwt_config_t config = {
   2,               /* Channel number. */
   DWT_PRF_64M,     /* Pulse repetition frequency. */
   DWT_PLEN_128,    /* Preamble length. */
   DWT_PLEN_64,    /* Preamble length. */
   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. */
@@ -38,7 +38,7 @@
static uint64_t resp_tx_ts;
static uint64_t final_rx_ts;
static double tof;
int32_t anchor_dist_last_frm[TAG_NUM_IN_SYS],his_dist[TAG_NUM_IN_SYS];   ;	
int32_t anchor_dist_last_frm[TAG_NUM_IN_SYS],his_dist[TAG_NUM_IN_SYS];
uint32_t tag_id = 0;
uint32_t tag_id_recv = 0;
uint32_t anc_id_recv = 0;
@@ -176,14 +176,14 @@

extern uint8_t g_start_send_flag;
u8 g_start_sync_flag;
void SyncPoll(u8 sync_seq,uint32_t sync_baseid)
void SyncPoll(u8 sync_seq)
{u8 result;
   g_start_sync_flag=1;   //中断模式，退出终端后，需要重新来过
   dwt_forcetrxoff();      //关闭接收，以防在RX ON çŠ¶æ€
   
   
   tx_sync_msg[SYNC_SEQ_IDX]=sync_seq;
   memcpy(&tx_sync_msg[ANCHOR_ID_IDX],&sync_baseid,4);
   memcpy(&tx_sync_msg[ANCHOR_ID_IDX],&dev_id,4);
   dwt_writetxdata(sizeof(tx_sync_msg), tx_sync_msg, 0);//将Poll包数据传给DW1000，将在开启发送时传出去
   dwt_writetxfctrl(sizeof(tx_sync_msg), 0);//设置超宽带发送数据长度
   dwt_starttx(DWT_START_TX_IMMEDIATE);
@@ -309,11 +309,30 @@
   }
return max_slotpos-1;
}
dwt_rxdiag_t d1;
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;
 double firstpath_power, rx_power;
  double f1, f2, r1, r2;
uint16_t F1,F2,F3,N,C;
double B = 131072;
double A = 121.74;
double min_power;
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 Poll(void)
{
   uint32_t frame_len;
@@ -506,7 +525,7 @@
   flag_rxon=1;
   neartimout_timer=0;
   get_newbase=0;
   timeout=ceil((float)nearbase_num*SLOT_SCALE)+3;
   timeout=ceil((float)nearbase_num*SLOT_SCALE)+2;
   //timeout=5;
   mainbase_dist=100000;
   mainbase_lost_count++;
@@ -551,14 +570,8 @@
                        resp_rx_ts = get_rx_timestamp_u64();                              //获得RESPONSE接收时间T4   
                        recbase_num++;
                        memcpy(&rec_nearbaseid,&rx_buffer[ANCHOR_ID_IDX],2);
                        if(last_nearbase_num==0)
                        {
                           get_newbase=1;
                           nearbaseid_list[0]=rec_nearbaseid;
                           nearbase_num=1;
                           memcpy(&tx_nearfinal_msg[ANCHOR_ID_IDX],&rec_nearbaseid,2);
                        }
                        if(rec_nearbaseid==nearbaseid_list[0])

                        if(rec_nearbaseid==mainbase_id)
                        {
                           //////////////////////////////////时间同步
                           temp_sync_timer2=sync_timer;
@@ -593,7 +606,7 @@
                           rec_nearbasepos=0;
                           
                           memcpy(&temp_dist,&rx_buffer[DIST_IDX],4);
                           nearbase_distlist[rec_nearbasepos]=temp_dist;
                           mainbase_dist = temp_dist;
                        if(temp_dist!=0x1ffff)
                           exsistbase_list[rec_nearbasepos]=KEEP_TIMES;
                        
@@ -611,35 +624,6 @@
                           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)
                           {
                           #ifdef TAG_OUTPUT
                              #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
                           #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{
                           rec_nearbasepos=FindNearBasePos(rec_nearbaseid);
@@ -767,17 +751,7 @@
         }
         
         report_num=0;
   for (i=0;i<last_nearbase_num;i++)
         {
            nearbaseid_list[i]=true_nearbase_idlist[i];
            nearbase_distlist[i]=true_nearbase_distlist[i];
            if(nearbase_distlist[i]!=0x1ffff&&true_exsistbase_list[i]==KEEP_TIMES)
            {
               memcpy(&usart_send[4+6*report_num],&nearbaseid_list[i],2);
               memcpy(&usart_send[6+6*report_num],&nearbase_distlist[i],4);
               report_num++;
            }
         }

         for(i=0;i<MAX_NEARBASE_NUM;i++)
         {
            nearbase_distlist[i]=0x1ffff;
@@ -931,7 +905,7 @@
               LED0_BLINK; //每成功一次通讯则闪烁一次
               dis_after_filter=dist_cm;
               hex_dist = dist_cm+(int16_t)g_com_map[DIST_OFFSET];
               if(abs(hex_dist-his_dist[tag_id_recv-TAG_ID_START])<1000)
               if(abs(hex_dist-his_dist[taglist_pos])<1000)
                  {
                     tagdist_list[taglist_pos] = hex_dist;
                        }
@@ -941,6 +915,7 @@
            dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
         }
}
uint32_t time_monitor[10];
extern uint16_t configremotetagID;
extern u8 remotetag_paralen;
u8 misdist_num[TAG_NUM_IN_SYS],seize_anchor,waittagconfig_reponse;
@@ -954,11 +929,11 @@
         memcpy(&tx_nearresp_msg[TAG_ID_IDX],&tag_id_recv,2);
         poll_rx_ts = get_rx_timestamp_u64();//获得Poll包接收时间T2

         resp_tx_time = (poll_rx_ts + ((POLL_RX_TO_RESP_TX_DLY_UUS+ancrec_nearbasepos*DELAY_BETWEEN_TWO_FRAME_UUS) * UUS_TO_DWT_TIME)) >> 8;//计算Response发送时间T3。
         resp_tx_time = (poll_rx_ts + ((POLL_RX_TO_RESP_TX_DLY_UUS+(ancrec_nearbasepos)*DELAY_BETWEEN_TWO_FRAME_UUS) * UUS_TO_DWT_TIME)) >> 8;//计算Response发送时间T3。
         dwt_setdelayedtrxtime(resp_tx_time);//设置Response发送时间T3
         dwt_setrxaftertxdelay(RESP_TX_TO_FINAL_RX_DLY_UUS+(rec_nearbase_num+1-ancrec_nearbasepos)*DELAY_BETWEEN_TWO_FRAME_UUS);//设置发送完成后开启接收延迟时间
         dwt_setrxtimeout(FINAL_RX_TIMEOUT_UUS);//接收超时时间
			
         dwt_readdiagnostics(&d1);
         if(tagdist_list[taglist_pos]<g_com_map[ALARM_DISTANCE1])
         {
            motorstate =0;
@@ -1048,6 +1023,10 @@
               int64_t tof_dtu;
               resp_tx_ts = get_tx_timestamp_u64();//获得response发送时间T3
               final_rx_ts = get_rx_timestamp_u64();//获得final接收时间T6

//               dwt_setrxtimeout(0);//设定接收超时时间，0位没有超时时间
//               dwt_rxenable(0);//打开接收
					
               final_msg_get_ts(&rx_buffer[FINAL_MSG_POLL_TX_TS_IDX], &poll_tx_ts);//从接收数据中读取T1，T4，T5
               final_msg_get_ts(&rx_buffer[FINAL_MSG_RESP_RX_NEARBASE_IDX+ancrec_nearbasepos*4], &resp_rx_ts);
               final_msg_get_ts(&rx_buffer[FINAL_MSG_FINAL_TX_TS_IDX], &final_tx_ts);
@@ -1055,6 +1034,7 @@
               poll_rx_ts_32 = (uint32_t)poll_rx_ts;//使用32位数据计算
               resp_tx_ts_32 = (uint32_t)resp_tx_ts;
               final_rx_ts_32 = (uint32_t)final_rx_ts;
               time_monitor[1] = sync_timer*1000+TIM3->CNT;	
               Ra = (double)(resp_rx_ts - poll_tx_ts);//Tround1 = T4 - T1
               Rb = (double)(final_rx_ts_32 - resp_tx_ts_32);//Tround2 = T6 - T3
               Da = (double)(final_tx_ts - resp_rx_ts);//Treply2 = T5 - T4
@@ -1063,10 +1043,14 @@
               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 * 100; //dis ä¸ºå•ä½ä¸ºcm的距离		
               dwt_readdiagnostics(&d1);
//               time_monitor[2] = sync_timer*1000+TIM3->CNT;	
               LOS(&d1);		
               time_monitor[3] = sync_timer*1000+TIM3->CNT;					
               /*--------------------------以下为非测距逻辑------------------------*/
               //dist_cm=33000;
					
               GPIO_WriteBit(GPIOB, GPIO_Pin_10, Bit_RESET);		
               LED0_BLINK; //每成功一次通讯则闪烁一次
               dis_after_filter=dist_cm;
               hex_dist = dist_cm+(int16_t)g_com_map[DIST_OFFSET];
@@ -1088,6 +1072,8 @@
               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-firstpath_power)*10;
               checksum = Checksum_u16(&usart_send[2],17);
               memcpy(&usart_send[19],&checksum,2);
               UART_PushFrame(usart_send,21);
@@ -1124,8 +1110,10 @@
            dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
         }
}

extern u16 synclost_count;
uint32_t current_syncid=0xffffffff,synclost_timer;
extern u8 flag_syncbase;
extern u8 flag_syncbase,waitsync_flag;
u8 tagpos_rec[50],tagpos_send[50],ancidlist_num;
u16 ancidlist_rec[20],ancidlist_send[20];
void Anchor_App(void)
@@ -1149,7 +1137,7 @@
   if (status_reg & SYS_STATUS_RXFCG)//成功接收
   { u16 tag_recv_interval;
      float temp_tagpos;
	
   time_monitor[0] = sync_timer*1000+TIM3->CNT;
      g_Resttimer=0;
      dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG);//清除标志位
      frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFL_MASK_1023;//获得接收数据长度
@@ -1159,34 +1147,24 @@
      memcpy(&tag_id_recv,&rx_buffer[TAG_ID_IDX],2);
      switch(rx_buffer[MESSAGE_TYPE_IDX])
      {
         uint16_t checksum;
         case POLL:
            if (anchor_type == rx_buffer[ANC_TYPE_IDX])
            Anchor_RecPoll();
            break;
         case SYNC:         
            memcpy(&rec_syncid,&rx_buffer[ANCHOR_ID_IDX],4);
            if(rec_syncid<current_syncid)
            {
               current_syncid=rec_syncid;
         if(anc_id_recv==g_com_map[SYNCBASEID])
         {
               synclost_count = 0;
               flag_syncbase=0;
               sync_seq=rx_buffer[SYNC_SEQ_IDX]+1;
               TIM3->CNT = sync_seq*325%1000+15;
               sync_timer = sync_seq*325/1000;
               TIM3->CNT = (sync_seq*325%1000)-80;
               sync_timer = (sync_seq*325/1000);
               synclost_timer=0;
               //SyncPoll(sync_seq,rec_syncid);			
               }else if(rec_syncid==current_syncid)
            {
               if(rx_buffer[SYNC_SEQ_IDX]<sync_seq)		
                  {
                     flag_syncbase=0;
                     sync_seq=rx_buffer[SYNC_SEQ_IDX]+1;
                     TIM3->CNT = sync_seq*325%1000+5;
                     sync_timer = sync_seq*325/1000+995;
                     synclost_timer=0;
                     //SyncPoll(sync_seq,rec_syncid);
                  }
				
            }
            if(g_com_map[BASESYNCSEQ]==2)
               SyncPoll(sync_seq);
         }
            break;
         case NEAR_MSG:
            if(anc_id_recv==dev_id)
@@ -1198,14 +1176,50 @@
               ancidlist_num=g_com_map[NEARBASE_NUM];
               tx_near_msg[NEARBASENUM_INDEX]=g_com_map[NEARBASE_NUM];
               memcpy(&tx_near_msg[NEARBASEID_INDEX],&g_com_map[NEARBASE_ID1],g_com_map[NEARBASE_NUM]*2);
               send_len=11+ancidlist_num*2+2;
               send_len=21+ancidlist_num*2;
               dwt_writetxdata(send_len, tx_near_msg, 0);//将Poll包数据传给DW1000，将在开启发送时传出去
               dwt_writetxfctrl(send_len, 0);//设置超宽带发送数据长度
               dwt_starttx(DWT_START_TX_IMMEDIATE);
            }
            break;
      case REG_POLL:	
         for(i=0;i<MAX_REGTAGNUM;i++)
      {
         if(tag_id_recv==regtag_map.tagid[i])
         {
               tx_near_msg[REGR_TAGSLOTPOS_INDEX]=regtag_map.tag_slotpos[i];
               tx_near_msg[REGR_TAGFREQ_INDEX] = regtag_map.tag_frequency[i];
               memcpy(&tx_near_msg[TAG_ID_IDX],&tag_id_recv,2);
               memcpy(&tx_near_msg[ANCHOR_ID_IDX],&dev_id,2);
               tx_near_msg[MESSAGE_TYPE_IDX] = REG_RESPONSE;
               ancidlist_num=g_com_map[NEARBASE_NUM];
               tx_near_msg[NEARBASENUM_INDEX]=g_com_map[NEARBASE_NUM];
               memcpy(&tx_near_msg[NEARBASEID_INDEX],&g_com_map[NEARBASE_ID1],g_com_map[NEARBASE_NUM]*2);
               send_len=21+ancidlist_num*2;
               dwt_writetxdata(send_len, tx_near_msg, 0);//将Poll包数据传给DW1000，将在开启发送时传出去
               dwt_writetxfctrl(send_len, 0);//设置超宽带发送数据长度
               dwt_starttx(DWT_START_TX_IMMEDIATE);
               regtag_map.tagid[i] = 0;
         }
      
         case NEAR_POLL:			
      }
      if(i==MAX_REGTAGNUM)
      {
         dwt_readdiagnostics(&d1);
         LOS(&d1);	
         usart_send[2]=0x0a;
         usart_send[3]=20;
         memcpy(&usart_send[4],&dev_id,2);
         memcpy(&usart_send[6],&tag_id_recv,2);
         memcpy(&usart_send[8],&rx_buffer[10],9);
         usart_send[17] = firstpath_power;
         checksum = Checksum_u16(&usart_send[2],20);
         memcpy(&usart_send[22],&checksum,2);
         UART_PushFrame(usart_send,24);
      }
      break;
         case NEAR_POLL:		
      //   GPIO_WriteBit(GPIOB, GPIO_Pin_10, Bit_SET);					
            memcpy(&tag_id_recv,&rx_buffer[TAG_ID_IDX],2);
            taglist_pos=CmpTagInList(tag_id_recv);
            if(taglist_pos==taglist_num)
@@ -1222,22 +1236,24 @@
            tagpos_rec[(u8)temp_tagpos]=1;
            rec_nearbase_num=rx_buffer[NEARBASENUM_INDEX];
         
            if(rec_nearbase_num>ancidlist_num)
               {
                  ancidlist_num=rec_nearbase_num;
                  memcpy(ancidlist_rec,&rx_buffer[NEARBASEID_INDEX],rec_nearbase_num*2);
               }
GPIO_WriteBit(GPIOB, GPIO_Pin_10, Bit_SET);	
         if(anc_id_recv==dev_id)
         {
            Anchor_RecNearPoll(0);	
         }else{
               
            for(i=0;i<rec_nearbase_num;i++)
            {
                memcpy(&tempid,&rx_buffer[NEARBASEID_INDEX+i*2],2);
               if(tempid==dev_id)
               {
						
                  seize_anchor=0;  //非抢占。已存在列表中
                  Anchor_RecNearPoll(i);	
                  Anchor_RecNearPoll(i+1);	
                  break;
               }                  
            }
         }
            //抢占模式
//               if(i==rec_nearbase_num)
//               {
@@ -1246,7 +1262,10 @@
//               }

            
            break;		
            break;
          default:
				
            break;
      }   
   }else{
       #ifdef DEBUG_INF