www.pudn.com > Usb_Project.rar > relay.c

 
#include "relay.h" 
 
#include "RF_USB_MAC.h" 
 
#include  
 
#include "relay_file.h" 
 
 
extern unsigned char blank_deviceID[6]; 
 
extern unsigned char blank_frame[RF_MAC_FRM_LEN]; 
 
unsigned char assign_relay_deviceID[] = {0xF0, 0, 0, 0, 0, 1}; 
 
unsigned char current_relay_deviceID[] = {0xF0, 0, 0, 0, 0, 1}; 
 
unsigned short current_group_address = 0x2100; 
unsigned short current_next_prev_hop = 0xFFFF; 
unsigned short current_chan_baud = 0xFFFF; 
 
signed short numof_ftp_recs = -2; 
 
unsigned short continuity_test; 
 
extern unsigned int selected_mode; 
 
int _RF_USB_send_relay_frame(unsigned char * frame, unsigned int flen) 
{ 
    PrintTime("\n-> Decoded TX Time:"); 
    PrintHexBuffer((unsigned char *)&frame[0], flen); 
 
    LogTime("\n-> Decoded TX Time:"); 
    LogHexBuffer((unsigned char *)&frame[0], flen); 
     
    RF_USB_send_frame(frame, flen); 
 
    return 0; 
} 
 
static void RF_preset_config_frame(unsigned char * frame) 
{ 
    struct relay_cfg_hdr * _cfg_ptr = (struct relay_cfg_hdr *)&frame[0];  
    struct rf_mac_hdr *_hptr = (struct rf_mac_hdr *)&frame[RF_MAC_FRM_HEAD]; 
 
    memset((unsigned char *)&frame[0], 0, RF_MAC_FRM_DATA_LEN); 
 
} 
 
static void RF_preset_local_frame(unsigned char * frame) 
{ 
    struct relay_cfg_hdr * _cfg_ptr = (struct relay_cfg_hdr *)&frame[0];  
    struct rf_mac_hdr *_hptr = (struct rf_mac_hdr *)&frame[RF_MAC_FRM_HEAD]; 
 
    RF_preset_config_frame(frame); 
 
    _hptr->grp = 255; 
    _hptr->dst = 255; 
    _hptr->src = 0; 
     
    _hptr->cmd = FRM_CMD_RELAY_CFG; 
     
    _cfg_ptr->relay_cmd = 0; 
     
} 
 
int _RF_USB_Relay_poll(unsigned short group_address) 
{ 
    struct relay_cfg_hdr * _cfg_ptr = (struct relay_cfg_hdr *)&blank_frame[0];  
    struct rf_mac_hdr *_hptr = (struct rf_mac_hdr *)&blank_frame[RF_MAC_FRM_HEAD]; 
 
    RF_preset_local_frame(blank_frame); 
 
    memset(_cfg_ptr->data, 0xFF, sizeof(_cfg_ptr->data)); 
    memset(_cfg_ptr->id, 0xFF, sizeof(_cfg_ptr->id)); 
     
    _hptr->grp = 255; 
    _hptr->dst = (unsigned char)group_address; 
    _hptr->src = 0; 
    _hptr->relay = (unsigned char)(group_address>>8); 
     
    _hptr->cmd = FRM_CMD_RELAY_CFG; 
     
    _RF_USB_send_relay_frame(blank_frame, RF_MAC_FRM_DATA_LEN); 
     
    return 0; 
} 
 
int _RF_USB_recv_frame_cmd11(unsigned char * frame, unsigned int flen) 
{ 
    struct rf_mac_hdr * _hptr; 
    struct relay_cfg_hdr * _cfg_ptr; 
    struct relay_cfg_hdr * _rpt_ptr; 
     
    _hptr = (struct rf_mac_hdr *)&frame[RF_MAC_FRM_HEAD]; 
    _rpt_ptr = (struct relay_cfg_hdr *)frame; 
    _cfg_ptr = (struct relay_cfg_hdr *)blank_frame; 
 
    PrintTime("\n<- Decoded RX Time:"); 
    PrintHexBuffer((unsigned char *)&frame[0], flen); 
 
    LogTime("\n<- Decoded RX Time:"); 
    LogHexBuffer((unsigned char *)&frame[0], flen); 
     
    //from rfd 
    if(_hptr->cmd == FRM_CMD_RELAY_CFG) 
    { 
        if(_memcmp(_rpt_ptr->id,  blank_deviceID, sizeof(blank_deviceID)) == 0) 
        { 
            //device ID 
            if(selected_mode == 101) 
            { 
                RF_preset_local_frame(blank_frame); 
 
                _memcpy(_cfg_ptr->id, assign_relay_deviceID, sizeof(assign_relay_deviceID)); 
 
                _RF_USB_send_relay_frame(blank_frame, RF_MAC_FRM_DATA_LEN);                 
            } 
        } 
        else  
        { 
            if(_memcmp(_cfg_ptr->id,  assign_relay_deviceID, sizeof(assign_relay_deviceID)) == 0) 
            { 
                _device_ID_inc(assign_relay_deviceID); 
            } 
 
            //this is the current ID 
            _memcpy(current_relay_deviceID, _rpt_ptr->id, sizeof(current_relay_deviceID)); 
 
            //zeroing 
            if(selected_mode == 102) 
            { 
                RF_preset_local_frame(blank_frame); 
 
                _memcpy(_cfg_ptr->id, current_relay_deviceID, sizeof(current_relay_deviceID)); 
 
                _cfg_ptr->relay_cmd = 0xFF; 
 
                _RF_USB_send_relay_frame(blank_frame, RF_MAC_FRM_DATA_LEN);                 
            } 
            else if(selected_mode == 103) 
            { 
                 
                //group address 
                RF_preset_local_frame(blank_frame); 
 
                _memcpy(_cfg_ptr->id, current_relay_deviceID, sizeof(current_relay_deviceID)); 
                _memcpy(&_cfg_ptr->data[2], (unsigned char *)¤t_group_address, sizeof(current_group_address)); 
 
                _cfg_ptr->relay_cmd = 0x02; 
 
                _RF_USB_send_relay_frame(blank_frame, RF_MAC_FRM_DATA_LEN);      
 
                selected_mode = 0; 
 
            } 
            else if(selected_mode == 104) 
            { 
                //prev_next hop 
                RF_preset_local_frame(blank_frame); 
 
                _memcpy(_cfg_ptr->id, current_relay_deviceID, sizeof(current_relay_deviceID)); 
                _memcpy(&_cfg_ptr->data[4], (unsigned char *)¤t_next_prev_hop, sizeof(current_next_prev_hop)); 
 
                _cfg_ptr->relay_cmd = 0x04; 
 
                _RF_USB_send_relay_frame(blank_frame, RF_MAC_FRM_DATA_LEN);                 
 
            } 
            else if(selected_mode == 105) 
            { 
                relay_ftp_xfer(current_group_address>>8, 0xFE, numof_ftp_recs); 
            } 
            else if(selected_mode == 106) 
            { 
                //arrived 
                if((_hptr->relay == 0) 
                    && (_hptr->dst == 0)) 
                { 
                    if(_hptr->cmd == FRM_CMD_GROUP_TRACE) 
                    { 
                        _RF_USB_send_relay_frame(frame, RF_MAC_FRM_DATA_LEN);  
                    } 
                } 
            } 
            else if(selected_mode == 107) 
            { 
                continuity_test ++; 
                _RF_USB_Relay_poll(current_group_address); 
            } 
        } 
    } 
    else if(_hptr->cmd == FRM_CMD_RELAY_FTP) 
    { 
        struct relay_ftp * _ftptr; 
 
        _ftptr = (struct relay_ftp *)frame; 
 
        printf("\n LIVE_TIME %ld CUR_POS %d", _ftptr->live_time, _ftptr->live_entry_pos); 
         
    }     
    else if(_hptr->cmd == FRM_CMD_RELAY_FTP_XFER) 
    { 
         
    }     
         
    return 0; 
} 
 
 
static void RF_send_gtrace_frame(unsigned char * frame) 
{ 
    struct relay_cfg_hdr * _cfg_ptr = (struct relay_cfg_hdr *)&frame[0];  
    struct rf_mac_hdr *_hptr = (struct rf_mac_hdr *)&frame[RF_MAC_FRM_HEAD]; 
 
    RF_preset_config_frame(frame); 
 
    _hptr->grp = current_group_address>>8; 
    _hptr->dst = (unsigned char)current_group_address; 
    _hptr->src = 0; 
     
    _hptr->cmd = FRM_CMD_GROUP_TRACE_ASK; 
 
    _RF_USB_send_relay_frame(blank_frame, RF_MAC_FRM_DATA_LEN); 
     
} 
 
 
int RelaySeleModeDone(void) 
{ 
    if(selected_mode > 100) 
    { 
        switch(selected_mode) 
        { 
            case 106: 
 
                //traceing 
                RF_send_gtrace_frame(blank_frame); 
                 
            break; 
             
            case 107: 
                continuity_test = 0; 
                _RF_USB_Relay_poll(current_group_address); 
            break; 
 
            case 109: 
                _RF_USB_Relay_poll(current_group_address); 
            break; 
            default: 
                 
                _RF_USB_Relay_poll(0xFFFF); 
            break; 
        } 
    } 
 
    return 0; 
 
} 
 
extern char line[250]; 
 
int RelaySeleModeMenu(void) 
{ 
    int cmd = 0; 
 
    printf("1. Device Numbering [startNo]\n"); 
    printf("2. Zeroing\n"); 
    printf("3. Group address\n"); 
    printf("4. Next Prev hop\n"); 
    printf("5. FTP download\n"); 
    printf("6. Group Tracing\n"); 
    printf("7. Continuity test\n"); 
    printf("8. Not available\n"); 
    printf("9. Localcast searching\n"); 
     
    fgets(line, sizeof(line), stdin); 
    sscanf(line, "%ld", &cmd); 
 
    selected_mode = cmd+100; 
    printf("Selected Mode %d\n", selected_mode); 
 
    switch(cmd) 
    { 
        case 0: 
        break; 
        case 1: 
//            printf(" %d\n",); 
        break; 
 
        case 4: 
//            printf(" %d\n",); 
        break; 
 
        case 3: 
        case 5: 
        case 6: 
        case 7: 
        default: 
             
            printf("Default Group Address %X\n [Press Enter to use default]- ", current_group_address); 
             
            line[0]='0'; 
            line[1]='x'; 
            fgets(&line[2], sizeof(line), stdin); 
            if((line[2] != 0x13)&&(line[2] != 0)) 
            { 
                sscanf(line, "%X", ¤t_group_address); 
            } 
         
        break; 
    } 
 
    switch(cmd) 
    { 
        case 5:             
            printf("Number of Entries to get %d\n [Press Enter to use default]- ", numof_ftp_recs); 
             
            fgets(&line[0], sizeof(line), stdin); 
            if((line[0] != 0x13)&&(line[0] != 0)) 
            { 
                sscanf(line, "%d", &numof_ftp_recs); 
            } 
 
            numof_ftp_recs = -1*abs(numof_ftp_recs); 
         
        break; 
    } 
 
    return cmd; 
     
}