relay.c

VC下USB的驱动代码,及其相关操作检测。

#include "relay.h"

#include "RF_USB_MAC.h"

#include <stdio.h>

#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 *)&current_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 *)&current_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", &current_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;
    
}