GC24001/User/nodelink_slave_app.c

#include "nodelink_slave_app.h"
#include "board.h"
#include "DataHelper.h"
#include "io_app.h"
#include "NodeLinkSlave.h"
#include "NodeLinkCommon.h"

nodelink_slave_t slave;  //扩展模块从站数据结构

int slave_bytes_count = 0;
int check_error_count = 0;
int recv_bytes_missing = 0;
int total_packed = 0;

int nl_recv_master_step = 0;        //接收主站步骤
static int nl_recv_slave_step = 0;        //接收从站步骤
static int nl_send_step = 0;        //发送步骤
static int nl_send_step1 = 0;        //发送步骤

unsigned char master_data_buffer[256];
unsigned char master_data_buffer1[256];


unsigned char slave_data_buffer[256];
unsigned char recv_master_buffer[256];
unsigned char recv_slave_buffer[256];

unsigned char send_buffer[256];
unsigned char send_buffer1[4];
int transfersize;
int transfersize1;
int txcount;
int txcount1;

fifo_buffer_t fifo;
extern sw_timer_t send_timer;
extern unsigned char receive_master_flag;
extern unsigned char receive_master_flag1;
extern unsigned char receive_slave_flag;
extern unsigned short master_rxlen;
extern unsigned short master_rxlen1;
extern unsigned short slave_rxlen;

extern unsigned char MissCount;
extern unsigned char DebugSendFlg;
extern unsigned char LifeSignal;
extern unsigned char LastLifeSignal;
sw_timer_t error_timer;
sw_timer_t err_reset_timer;
extern sw_timer_t decode_err_timer;
extern unsigned long errcnt;
extern unsigned char BeginRecvFlg;
extern unsigned char RecvErrFlg;

fifo_buffer_t Rxfifo;


/**
 * 端口数据下发，用于主串口进入的数据往副串串口发
 * 
 * @author lxz (070120 11:26:38)
 * 
 * @param dat 
 */
static void nodelink_slave_port_down(unsigned char dat) {
    //hw_dma_uart_write_byte(0, dat);
}

/**
 * 从站接收主站数据处理
 * @author lxz (070120 12:03:56)
 * 
 * @param dat 
 * @param len 
 * 
 * @return int 
 */
static void nodelink_slave_on_recv(nodelink_slave_t * slave, unsigned char * data_in, int len) {
    switch (slave->model) {
    case 0x01://IO扩展类型
        io_outputs[0].value = data_in[0];
        break;
    }
}
/**
 * 从站接收主站数据处理
 * @author lxz (070120 12:03:56)
 * 
 * @param dat 
 * @param len 
 * 
 * @return int 
 */
static int nodelink_slave_on_send(nodelink_slave_t * slave, unsigned char * data_out) {
    int len=0;
    switch (slave->model) {
    case 0x01://IO扩展类型
        data_out[0] = io_inputs[0].value;
        len=1;
        break;
    }
    return len;
}

static void nodelink_slave_event(char cmd, int len) {
    switch (cmd) {
    case NL_SLAVE_EVENT_RESET:
        slave_bytes_count = 0;
        break;
    case NL_SLAVE_EVENT_SETID:
        total_packed = 0;
        check_error_count = 0;
        recv_bytes_missing = 0;
        break;
    case NL_SLAVE_EVENT_CRCERROR:
        check_error_count++;
        break;
    }
}

//扩展协议硬件相关接口
static nodelink_slave_ops slave_ops = {
    nodelink_slave_port_down,
    nodelink_slave_on_recv,
    nodelink_slave_on_send,
    nodelink_slave_event
};



/**
 * 初始化扩展模块协议与端口
 * 
 * @author lxz (063020 16:07:37)
 * 
 * @param void 
 */
void nodelink_slave_app_init(void) {;
    //为上行数据申请先入先出缓冲
    dh_fifo_init(&fifo, 20);
    dh_fifo_init(&Rxfifo, 5);
    
    nodelink_slave_init(&slave, 1, &slave_ops);
    {
        int value = 2000;
        //hw_dma_uart_control(1, UART_CTRL_SET_RDFIN_TIME, &value);
    } 
    nodelink_slave_reset(&slave);
    sw_timer_start(&error_timer, 5, 0);
    BeginRecvFlg=0;
    RecvErrFlg=0;
}
/**
 * 扩展模块执行主程序
 * 
 * @author lxz (063020 16:10:05)
 * 
 * @param void 
 */
void nodelink_slave_app_run(void) {

    int length = 0;
    static unsigned long timeout;
    
    //接收主站数据
    if(receive_master_flag)
    {
      if(BeginRecvFlg==0)
      {
        BeginRecvFlg=1;
        sw_timer_start(&decode_err_timer, 0, 100000);
      }
      nodelink_slave_recv_master(&slave, master_data_buffer, master_rxlen);
      sw_timer_start(&error_timer, 5, 0);
      sw_timer_start(&err_reset_timer, 0, 100000);
      if(slave.bus_status == 0xF1)
      {
        run_led_speed=500000;
      }
      else
      {
        run_led_speed=100000;
      }
    }
    if(receive_master_flag1)
    {
      nodelink_slave_recv_master(&slave, master_data_buffer1, master_rxlen1);
      receive_master_flag1=0;
    }
    if (sw_timer_expire(&error_timer)) 
    {
      run_led_speed=2000000;
    }
    if (BeginRecvFlg==1 && sw_timer_expire(&err_reset_timer)) 
    {
      RecvErrFlg=1;
    }
    
    //接收从站数据
    if(receive_slave_flag)
    {
        nodelink_slave_recv_slave(&slave, slave_data_buffer, slave_rxlen);
    } 
    //超时没有接收到从站信息，说明自己是最后一块板
    if (slave.bus_status == 0xF0 && (slave.step == 1) && sw_timer_expire(&send_timer)) 
    {
      slave.id=1;
      slave.step=6;
      slave.count = 100; 
    }

    //发送数据
    if((RESET != usart_flag_get(USART1, USART_FLAG_TC)) && (txcount==transfersize))
    {
      txcount=0;
      transfersize = nodelink_slave_send(&slave, send_buffer);
      if(transfersize>0)
      {
        usart_data_transmit(USART1, send_buffer[txcount++]);
        usart_interrupt_enable(USART1, USART_INT_TBE);
      }
      
    }

    
    //发送数据
//    if((RESET != usart_flag_get(USART0, USART_FLAG_TC)) && (txcount1==transfersize1))
//    {
//      if(DebugSendFlg)
//      {
//        errcnt++;
//        DebugSendFlg=0;
//        send_buffer1[0]=0xEE;
//        send_buffer1[1]=MissCount;
//        send_buffer1[2]=LifeSignal;
//        send_buffer1[3]=errcnt;
//        transfersize1=4;
//      }
//      else
//      {
//        transfersize1=0;
//        txcount1=0;
//      }
//      if(transfersize1>0)
//      {
//        txcount1=0;
//        usart_data_transmit(USART0, send_buffer1[txcount1++]);
//        usart_interrupt_enable(USART0, USART_INT_TBE);
//      }
//    }
  
//    switch (nl_send_step) {
//    case 0:
//        length = nodelink_slave_send(&slave, send_buffer);
//        if (length > 0) {
//                hw_dma_uart_begin_write(1, (const char *)send_buffer, length);
//                nl_send_step++;
//            }
//        break;
//    case 1:
//        if (hw_dma_uart_write_finish(1)) 
//        {
//            nl_send_step = 0;
//        }
//        break;
//
//    }
//    
//    //发送串口调试数据
//    switch (nl_send_step1) {
//    case 0:
//          if(DebugSendFlg)
//          {
//            errcnt++;
//            DebugSendFlg=0;
//            send_buffer1[0]=0xEE;
//            send_buffer1[1]=MissCount;
//            send_buffer1[2]=LifeSignal;
//            send_buffer1[3]=errcnt;
//            hw_dma_uart_begin_write(0, (const char *)send_buffer1, 4);
//            nl_send_step1++;
//          }
//        break;
//    case 1:
//        if (hw_dma_uart_write_finish(0)) 
//        {
//            nl_send_step1 = 0;
//        }
//        break;
//
//    }
}