这些小活动你都参加了吗?快来围观一下吧!>>
电子产品世界 » 论坛首页 » 嵌入式开发 » FPGA » TMS320VC5416与TLC16C554的接口函数

共1条 1/1 1 跳转至

TMS320VC5416与TLC16C554的接口函数

工程师
2015-01-09 14:42:40     打赏
#include "N1S16DSP.H"

//////////////////////
// 串口访问参数设置 //
//////////////////////

//////////////////////////////
//  串口信息的流向设计思想  //
//////////////////////////////
// 1、临时发送和接收缓冲、实际发送和接收缓冲均为缓冲缓冲;
//
// 2、串口接收的信息,首先存放到临时接收缓冲*uiLowComRxd中,当接收的实际字节数uiComTempRecvBytePtr大于等于
//    2*cnComTmpRecvBufWordSize时,将*uiLowComRxd的数据转存到扩展RAM中的uiExtComRxd;然后根据转发到网络
//    的需要转移到低端RAM中的uTxdNet,即组织网络报文;当扩展RAM中没有数据时,也可以从uiLowComRxd中直接
//    组织网络报文,具体如下:
//
//         中断                             当接收的字节数大于等于临时缓冲的大小时,                           发送时
//    COM ------> 临时接收缓冲*uiLowComRxd -----------------------------------------> 扩展RAM中的uiExtComRxd --------> 低端RAM的uTxdNet
//         查询          |                  每次转移cnComTmpRecvBufWordSize个字                                  |
//                       |                                                                                       |
//                       ------------------------------------扩展RAM中没有数据或数据不足时--------------------->>-
//
// 3、网络接收的信息,即串口将要发送的信息,首先存放到临时发送缓冲*uiLowComTxd中,多余的数据存放到扩展RAM
//    中的uiExtComTxd,然后根据发送情况转移到临时发送缓冲*uiLowComTxd中,以便发送到串口;具体如下:
//
//          中断                                                发送时
//    网络 ------> 低端RAM的uRxdNet --> 扩展RAM中的uiExtComTxd --------> 临时发送缓冲*uiLowComTxd
//          查询         |                                         |
//                       |                                         |
//                       -----------临时发送缓冲为空时----------->>-
//
UINT uiComTempRecvBytePtr[cnMaxComThisType]; // 串口临时接收字节指针(以字节为单位),单向缓冲,满时转入扩展RAM
UINT uiComTempRecvByteUse[cnMaxComThisType]; // 串口临时接收使用字节指针(以字节为单位),单向缓冲,满时转入扩展RAM
UINT uiComTempSendBytePtr[cnMaxComThisType]; // 串口临时发送字节指针(以字节为单位),单向缓冲,空时由扩展RAM转入
UINT uiComTempSendByteUse[cnMaxComThisType]; // 串口临时发送使用字节指针(以字节为单位),单向缓冲,空时由扩展RAM转入

UINT uiComRealRecvWordPtr[cnMaxComThisType]; // 串口实际接收字节指针(以字为单位),环形缓冲
UINT uiComRealRecvWordUse[cnMaxComThisType]; // 串口实际接收使用字节指针(以字为单位),环形缓冲
UINT uiComRealSendWordPtr[cnMaxComThisType]; // 串口实际发送字节指针(以字为单位),环形缓冲
UINT uiComRealSendWordUse[cnMaxComThisType]; // 串口实际发送使用字节指针(以字为单位),环形缓冲

// 网络数据的按帧接收,或帧数据流的识别:
// =====================================
//  串口发向网络的条件具体为:
//  ⑴ 待发送的字节数满足一个以太网帧最大字节数时;
//  ⑵ 未满足以太网帧最大字节数,串口接收空闲时间超过10倍单字节发送时间(由波特率折算);
UINT uiM10Sec10CharsTime[cnMaxComThisType];    // 按波特率计算,接收(发送)一个字节所需要的时间(以10ms为单位)
UINT uiM10SecCountCharDelay[cnMaxComThisType]; // 该串口自接收完上一个字节到现在的时间间隔

UINT *uiLowComRxd[cnMaxComThisType]; // 串口临时接收缓冲区指针
UINT *uiLowComTxd[cnMaxComThisType]; // 串口临时发送缓冲区指针

//////////////////////////////////////////////////////////////////////////////////////
// Three types of information are stored in the internal registers used in the ACE:
// control, status, and data. Mnemonic abbreviations for the registers are shown in
// Table 1. Table 2 defines the address location of each register and whether it is
// read only, write only, or read writable.
//
// Table 1. Internal Register Mnemonic Abbreviations
// ================================================================================================================
// CONTROL                    MNEMONIC | STATUS                 MNEMONIC  | DATA                          MNEMONIC
// -------------------------  -------- | ---------------------  --------  | ----------------------------  --------
// Line control register      LCR      | Line status register   LSR       | Receiver buffer register      RBR
// FIFO control register      FCR      | Modem status register  MSR       | Transmitter holding register  THR
// Modem control register     MCR      |                                  |
// Divisor latch LSB          DLL      |                                  |
// Divisor latch MSB          DLM      |                                  |
// Interrupt enable register  IER      |                                  |
// -----------------------------------------------------------------------------------------------------------------
//
// Table 2. Register Selection
// ===========================
// DLAB  A2  A1  A0  READ MODE                 WRITE MODE
// ----  --  --  --  ------------------------  ----------------------------
//   0    0   0   0  Receiver buffer register  Transmitter holding register
//   0    0   0   1                            Interrupt enable register
//   X    0   1   0  Interrupt identification  register FIFO control register
//   X    0   1   1                            Line control register
//   X    1   0   0                            Modem control register
//   X    1   0   1  Line status register
//   X    1   1   0  Modem status register
//   X    1   1   1  Scratchpad register       Scratchpad register
//   1    0   0   0                            LSB divisor latch
//   1    0   0   1                            MSB divisor latch
// ------------------------------------------------------------------------
// X = irrelevant, 0 = low level, 1 = high level
// The serial channel is accessed when either /CSA or /CSD is low.
// DLAB is the divisor latch access bit and bit 7 in the LCR.
// A2-A0 are device terminals.
//
// Individual bits within the registers are referred to by the register mnemonic
// and the bit number in parentheses. For example, LCR7 refers to line control
// register bit 7. The transmitter buffer register and receiver buffer register
// are data registers that hold from five to eight bits of data. If less than eight
// data bits are transmitted, data is right justified to the LSB. Bit 0 of a data
// word is always the first serial data bit received and transmitted. The ACE data
// registers are double buffered (TL16450 mode) or FIFO buffered (FIFO mode) so
// that read and write operations can be performed when the ACE is performing the
// parallel-to-serial or serial-to-parallel conversion.
//
// The scratch register is an 8-bit read/write register that has no affect on either
// channel in the ACE. It is intended to be used by the programmer to hold data
// temporarily.
//
// /RXRDY operation  选择 mode 1
// ================
// In mode 0, /RXRDY is asserted (low) when the receive FIFO is not empty; it is
// released (high) when the FIFO is empty. In this way, the receiver FIFO is read
// when /RXRDY is asserted (low).
// In mode 1, /RXRDY is asserted (low) when the receive FIFO has filled to the
// trigger level or a character time-out has occurred (four character times with
// no transmission of characters); it is released (high) when the FIFO is empty. In
// this mode, multiple received characters are read by the DMA device, reducing the
// number of times it is interrupted.
// /RXRDY and /TXRDY outputs from each of the four internal ACEs of the TL16C554 are
// ANDed together internally. This combined signal is brought out externally to
// /RXRDY and /TXRDY. Following the removal of the reset condition (RESET low), the
// ACE remains in the idle mode until programmed.
// A hardware reset of the ACE sets the THRE and TEMT status bits in the LSR. When
// interrupts are subsequently enabled, an interrupt occurs due to THRE. A summary
// of the effect of a reset on the ACE is given in Table 12.
//
// /TXRDY operation  选择 mode 1
// ================
// In mode 0, /TXRDY is asserted (low) when the transmit FIFO is empty; it is released
// (high) when the FIFO contains at least one byte. In this way, the FIFO is written
// with 16 bytes when /TXRDY is asserted (low).
// In mode 1, /TXRDY is asserted (low) when the transmit FIFO is not full; in this mode,
// the transmit FIFO is written with another UINT when /TXRDY is asserted (low).
//
// scratchpad register
// ===================
// The scratch register is an 8-bit read/write register that has no affect on either
// channel in the ACE. It is intended to be used by the programmer to hold data
// temporarily.
////////////////////////////////////////////////////////////////////////////////////////

#define cnMaxBaudRate  691200 // 对应主振频率为11.0592MHz = 691200 * 16

////////////////////////////////////////////////////////////////////////////////////////
//
//  =============================
//  TL16C554访问基地址:读/写100H
//  =============================
//
//  ==================================
//  分选片选控制地址如下表:低电平有效
//  ==================================
//            端口地址   D0    D1    D2    D3    D4    D5    D6    D7
//            --------  ----  ----  ----  ----  ----  ----  ----  ----
//      INT0:  200H    CSA1  CSB1  CSC1  CSD1  CSA3  CSB3  CSC3  CSD3
//      INT1:  300H    CSA5  CSB5  CSC5  CSD5  CSA7  CSB7  CSC7  CSD7
//      INT2:  700H    CSA2  CSB2  CSC2  CSD2  CSA4  CSB4  CSC4  CSD4
//      Nmi:   900H    CSA6  CSB6  CSC6  CSD6  CSA8  CSB8  CSC8  CSD8
//
//    用通道号表示
//    ------------
//      INT0:  200H      1     2     3     4     9    10    11    12 
//      INT1:  300H     17    18    19    20    25    26    27    28 
//      INT2:  700H      5     6     7     8    13    14    15    16 
//      Nmi:   900H     21    22    23    24    29    39    31    32 
//
//      如要选择第 1路port900 = 0xff, port700 = 0xff, port300 = 0xff, port200 = 0xfe;
//      如要选择第 5路port900 = 0xff, port700 = 0xfe, port300 = 0xff, port200 = 0xff;
//      如要选择第 9路port900 = 0xff, port700 = 0xff, port300 = 0xff, port200 = 0xef;
//      如要选择第13路port900 = 0xff, port700 = 0xef, port300 = 0xff, port200 = 0xff;
//      如要选择第17路port900 = 0xff, port700 = 0xff, port300 = 0xfe, port200 = 0xff;
//      如要选择第21路port900 = 0xfe, port700 = 0xff, port300 = 0xff, port200 = 0xff;
//      如要选择第25路port900 = 0xff, port700 = 0xff, port300 = 0xef, port200 = 0xff;
//      如要选择第29路port900 = 0xef, port700 = 0xff, port300 = 0xff, port200 = 0xff;
//
//  ================
//  串口芯片复位地址
//  ================
//  写400H;D0 = 1,复位第一片串口芯片,D0 = 0,使第一片串口芯片工作;
//      写400H;D1 = 1,复位第二片串口芯片,D1 = 0,使第二片串口芯片工作;
//      写400H;D2 = 1,复位第三片串口芯片,D2 = 0,使第三片串口芯片工作;
//      写400H;D3 = 1,复位第四片串口芯片,D3 = 0,使第四片串口芯片工作;
//      写400H;D4 = 1,复位第五片串口芯片,D4 = 0,使第五片串口芯片工作;
//      写400H;D5 = 1,复位第六片串口芯片,D5 = 0,使第六片串口芯片工作;
//      写400H;D6 = 1,复位第七片串口芯片,D6 = 0,使第七片串口芯片工作;
//      写400H;D7 = 1,复位第八片串口芯片,D7 = 0,使第八片串口芯片工作;
//
//  ==========================
//  串口芯片中断标识位读取地址
//  ==========================
//      INT0:  写500H,D1D0 = 00,同时读取600H,D0-D8分别对应INTA1、INTB1、INTC1、INTD1、INTA3、INTB3、INTC3、INTD3;
//      INT2:  写500H,D1D0 = 01,同时读取A00H,D0-D8分别对应INTA2、INTB2、INTC2、INTD2、INTA4、INTB4、INTC4、INTD4;
//      INT1:  写500H,D1D0 = 10,同时读取600H,D0-D8分别对应INTA5、INTB5、INTC5、INTD5、INTA7、INTB7、INTC7、INTD7;
//      Nmi:  写500H,D1D0 = 11,同时读取A00H,D0-D8分别对应INTA6、INTB6、INTC6、INTD6、INTA8、INTB8、INTC8、INTD8;
//
//    用通道号表示
//    ------------
//      INT0:写500H,D1D0 = 00,同时读取600H,D0-D8分别对应 1、 2、 3、 4、 9、10、11、12;
//      INT2:写500H,D1D0 = 01,同时读取A00H,D0-D8分别对应 5、 6、 7、 8、13、14、15、16;
//      INT1:写500H,D1D0 = 10,同时读取600H,D0-D8分别对应17、18、19、20、25、26、27、28;
//      Nmi: 写500H,D1D0 = 11,同时读取A00H,D0-D8分别对应21、22、23、24、29、30、31、32;
//
// ========
// 中断处理
// ========
//  INT0:第一、三片串口芯片中断使用DSP的INT0, 1、 2、 3、 4、 9、10、11、12;
//  INT1:第五、七片串口芯片中断使用DSP的INT1,17、18、19、20、25、26、27、28;
//  INT2:第二、四片串口芯片中断使用DSP的INT2, 5、 6、 7、 8、13、14、15、16;
//  Nmi: 第六、八片串口芯片中断使用DSP的NMI, 21、22、23、24、29、30、31、32;
//
/////////////////////////////////////////////////////////////////////////////////////////

// TL16c554访问I/O地址
// ===================
// 0,cnRBR_16c554,Receiver buffer register(READ)
// 0,cnTHR_16c554,Transmitter holding register(WRITE)
// 0,cnDLL_16c554,Divisor latch LSB(When LCR.7=1)(WRITE)
// 1,cnDLM_16c554,Divisor latch MSB(When LCR.7=1)(WRITE)
// 1,cnIER_16c554,Interrupt enable register(WRITE)
// 2,cnIIR_16c554,Interrupt identification(READ)
// 2,cnFCR_16c554,FIFO control register(WRITE)
// 3,cnLCR_16c554,Line control register(WRITE)
// 4,cnMCR_16c554,Modem control register(WRITE)
// 5,cnLSR_16c554,Line status register(READ)
// 6,cnMSR_16c554,Modem status register(READ)
// 7,cnSCR_16c554,Scratchpad register(READ & WRITE)
ioport UINT port100; // 0,cnRBR_16c554,Receiver buffer register(READ)
      // 0,cnTHR_16c554,Transmitter holding register(WRITE)
      // 0,cnDLL_16c554,Divisor latch LSB(When LCR.7=1)(WRITE)
ioport UINT port101; // 1,cnDLM_16c554,Divisor latch MSB(When LCR.7=1)(WRITE)
      // 1,cnIER_16c554,Interrupt enable register(WRITE)
ioport UINT port102; // 2,cnIIR_16c554,Interrupt identification(READ)
      // 2,cnFCR_16c554,FIFO control register(WRITE)
ioport UINT port103; // 3,cnLCR_16c554,Line control register(WRITE)
ioport UINT port104; // 4,cnMCR_16c554,Modem control register(WRITE)
ioport UINT port105; // 5,cnLSR_16c554,Line status register(READ)
ioport UINT port106; // 6,cnMSR_16c554,Modem status register(READ)
ioport UINT port107; // 7,cnSCR_16c554,Scratchpad register(READ & WRITE)

// TL16c554路选方法
// ================
//            端口地址   D0    D1    D2    D3    D4    D5    D6    D7
//            --------  ----  ----  ----  ----  ----  ----  ----  ----
//      INT0:  200H    CSA1  CSB1  CSC1  CSD1  CSA3  CSB3  CSC3  CSD3
//      INT1:  300H    CSA5  CSB5  CSC5  CSD5  CSA7  CSB7  CSC7  CSD7
//      INT2:  700H    CSA2  CSB2  CSC2  CSD2  CSA4  CSB4  CSC4  CSD4
//      Nmi:   900H    CSA6  CSB6  CSC6  CSD6  CSA8  CSB8  CSC8  CSD8
//
//    用通道号表示
//    ------------
//      INT0:  200H      1     2     3     4     9    10    11    12 
//      INT1:  300H     17    18    19    20    25    26    27    28 
//      INT2:  700H      5     6     7     8    13    14    15    16 
//      Nmi:   900H     21    22    23    24    29    39    31    32 
//
//      如要选择第 1路port900 = 0xff, port700 = 0xff, port300 = 0xff, port200 = 0xfe;
//      如要选择第 5路port900 = 0xff, port700 = 0xfe, port300 = 0xff, port200 = 0xff;
//      如要选择第 9路port900 = 0xff, port700 = 0xff, port300 = 0xff, port200 = 0xef;
//      如要选择第13路port900 = 0xff, port700 = 0xef, port300 = 0xff, port200 = 0xff;
//      如要选择第17路port900 = 0xff, port700 = 0xff, port300 = 0xfe, port200 = 0xff;
//      如要选择第21路port900 = 0xfe, port700 = 0xff, port300 = 0xff, port200 = 0xff;
//      如要选择第25路port900 = 0xff, port700 = 0xff, port300 = 0xef, port200 = 0xff;
//      如要选择第29路port900 = 0xef, port700 = 0xff, port300 = 0xff, port200 = 0xff;

ioport UINT port200; // 通道选择
ioport UINT port300;
ioport UINT port700;
ioport UINT port900;

// 串口芯片中断标识位读取地址
// --------------------------
//   INT0:写500H,D1D0 = 00,同时读取600H,D0-D8分别对应INTA1、INTB1、INTC1、INTD1、INTA3、INTB3、INTC3、INTD3;
//   INT2:写500H,D1D0 = 01,同时读取A00H,D0-D8分别对应INTA2、INTB2、INTC2、INTD2、INTA4、INTB4、INTC4、INTD4;
//   INT1:写500H,D1D0 = 10,同时读取600H,D0-D8分别对应INTA5、INTB5、INTC5、INTD5、INTA7、INTB7、INTC7、INTD7;
//   Nmi: 写500H,D1D0 = 11,同时读取A00H,D0-D8分别对应INTA6、INTB6、INTC6、INTD6、INTA8、INTB8、INTC8、INTD8;
//
// 用通道号表示
// ------------
//   INT0:写500H,D1D0 = 00,同时读取600H,D0-D8分别对应 1、 2、 3、 4、 9、10、11、12;
//   INT2:写500H,D1D0 = 01,同时读取A00H,D0-D8分别对应 5、 6、 7、 8、13、14、15、16;
//   INT1:写500H,D1D0 = 10,同时读取600H,D0-D8分别对应17、18、19、20、25、26、27、28;
//   NMI: 写500H,D1D0 = 11,同时读取A00H,D0-D8分别对应21、22、23、24、29、30、31、32;

ioport UINT port500; // 中断标识
ioport UINT port600; // 读出8位中断状态,从而判断是那路发生了中断
ioport UINT portA00;

// 中断处理
// --------
//  INT0:第一、三片串口芯片中断使用DSP的INT0, 1、 2、 3、 4、 9、10、11、12;
//  INT1:第五、七片串口芯片中断使用DSP的INT1,17、18、19、20、25、26、27、28;
//  INT2:第二、四片串口芯片中断使用DSP的INT2, 5、 6、 7、 8、13、14、15、16;
//  Nmi: 第六、八片串口芯片中断使用DSP的NMI, 21、22、23、24、29、30、31、32;

BOOL blIntr0NeedToBeActive; // 主程序有必要启动一次INTR0;每次收到网络数据,均应置此标志,以便启动串口发送
BOOL blIntr1NeedToBeActive; // 主程序有必要启动一次INTR1;每次收到网络数据,均应置此标志,以便启动串口发送
BOOL blIntr2NeedToBeActive; // 主程序有必要启动一次INTR2;每次收到网络数据,均应置此标志,以便启动串口发送
BOOL blNmiNeedToBeActive;   // 主程序有必要启动一次NMI;每次收到网络数据,均应置此标志,以便启动串口发送

// 用于INT0、INT1和INT2公用
UINT uiComNo0_1_2, uiComNoINT0_1_2, uiInterruptFlagINT0_1_2, uiMaskINT0_1_2;
// 用于NMI
UINT uiComNoNmi, uiComNoIntNmi, uiInterruptFlagNmi, uiMaskNmi;
// 由于NMI可能中断INT0、INT1和INT2,因此需要保护现场
UINT uiInINT0_1_2; // 0x0000:未在INT0、INT1或INT2服务中;0xff00、0xff01和0xff02分别标识在INT0、INT1和INT2服务中
UINT uiPort900Val; // 不选中任何串口
UINT uiPort700Val;
UINT uiPort300Val;
UINT uiPort200Val;

// 由INT0、INT1和INT2调用的串口信息接收函数
void vRecvComInforByInt0_1_2() // 因为INT0、INT1和INT2的中断级别相同,因此可以使用同一函数,而不会造成重入问题
{
 UINT uiTemp, *uipRxdPtr, uiBytesCount;
 
 //////////////
 // 读取数据 //
 //////////////
 if (uiInterruptFlagINT0_1_2 & uiMaskINT0_1_2) // 接收或发送中断有效
 {
  uipRxdPtr = uiLowComRxd[uiComNoINT0_1_2] + (uiComTempRecvBytePtr[uiComNoINT0_1_2] >> 1); // 临时接收缓冲指针,以提高速度

  // 检查线状态寄存器 0 D6 D5 D4 D3 D2 D1 D0
  // ---------------------------------------
  // D0--接收数据准备好
  // D1--数据被冲出错
  // D2--校验出错
  // D3--数据格式出错
  // D4--检出间断
  // D5--发送保持寄存器空
  // D6--发送移位寄存器空
  
  uiBytesCount = 0;
  
  uiTemp = port105; // 线路状态寄存器
  while (uiTemp & 0x01) // 数据准备好否 D0
  {
   if (uiBytesCount ++ >= 16) break; // FIFO最大16字节,防止硬件错误导致死机!

   // D1--数据被冲出错
   // D2--校验出错
   // D3--数据格式出错
   if (uiTemp & 0x6) // D3.D2--校验出错
   {
    uiTemp = port100; // 接收当前字符(必须读取,否则可能导致该字符一直留在FIFO中)
    uiTemp = "?";
   }
   else // 中断接收缓存中, 用于放下一字节的位置
    uiTemp = port100 & 0xff; // 接收当前字符

   if (uiComTempRecvBytePtr[uiComNoINT0_1_2] & 0x01) // 第1、3、5、7、...字节在低字节位置
   {
    *uipRxdPtr = (*uipRxdPtr) + uiTemp;
    uipRxdPtr ++; // 整字指针加1
   }
   else // 第0、2、4、6、...字节在高字节位置
    *uipRxdPtr = uiTemp << 8;

   // 若指针位于末尾, 则指针回零,并转移数据
   uiComTempRecvBytePtr[uiComNoINT0_1_2] ++;
   if (uiComTempRecvBytePtr[uiComNoINT0_1_2] >= cnComTmpRecvBufByteSize) // 串口临时接收缓冲区大小
   {
    // 将低端RAM缓冲中的数据写入实际串口接收缓冲;
    uiWriteDataExtComRxd(uiComNoINT0_1_2, uiLowComRxd[uiComNoINT0_1_2], cnComTmpRecvBufWordSize); // 准备发给网络的数据
    uiComTempRecvBytePtr[uiComNoINT0_1_2] = 0;
    uiComTempRecvByteUse[uiComNoINT0_1_2] = 0;
    uipRxdPtr = uiLowComRxd[uiComNoINT0_1_2]; // 临时接收缓冲指针,以提高速度
   }
   
   uiTemp = port105; // 线路状态寄存器
  } // 数据准备好
/*  
  // 中断有效,但数据未准备好;属于错误状态
  if (uiBytesCount == 0) 
   uiTemp = port100; // 防止错误??????????????????
*/   
 } // 接收或发送中断有效

 //////////////
 // 发送数据 // 因为可能由软件启动中断发送数据,因此每次中断必须检查,而不管是否有硬件中断标志
 //////////////
 
 uiBytesCount = 0;
 
 do
 {
  if (uiBytesCount ++ >= 16) break; // FIFO最大16字节,防止硬件错误导致死机!
  
  // 是否有数据需要发送
  if (uiComTempSendByteUse[uiComNoINT0_1_2] == uiComTempSendBytePtr[uiComNoINT0_1_2]) break;

  uiTemp = port105; // 线路状态寄存器
  if (uiTemp & 0x60) // 移位寄存器或发送寄存器空否 D6 D5
  { 
   if (uiComTempSendByteUse[uiComNoINT0_1_2] & 0x01) // 第0、2、4、6、...字节在低字节位置  
    port100 = (*(uiLowComTxd[uiComNoINT0_1_2] + (uiComTempSendByteUse[uiComNoINT0_1_2] >> 1))) & 0xff; // 发送当前字节
   else // 第1、3、5、7、...字节在高字节位置
    port100 = (*(uiLowComTxd[uiComNoINT0_1_2] + (uiComTempSendByteUse[uiComNoINT0_1_2] >> 1))) >> 8; // 发送当前字节

   // 若临时发送缓冲内容发送完毕, 则指针回零,并准备转移数据
   uiComTempSendByteUse[uiComNoINT0_1_2] ++;
   if (uiComTempSendByteUse[uiComNoINT0_1_2] >= uiComTempSendBytePtr[uiComNoINT0_1_2]) // 临时缓冲信息发送完毕
   {
    uiComTempSendBytePtr[uiComNoINT0_1_2] = 0;
    break; // 每次中断仅发送临时发送缓冲中的内容
   }
  } // if ((uiTemp & 0x60)) // 移位寄存器或发送寄存器空否 D6 D5
  else
   break; // 发送寄存器不空,无法继续发送
 } while(TRUE);

 // 若还有数据等待发送,在上一级函数启动串口中断,以提高代码效率
 if (uiComTempSendBytePtr[uiComNoINT0_1_2])
  return;
 else // 串口临时发送缓冲内容发送完毕,检查扩展RAM中是否有数据
 {
  // 从实际串口发送缓冲中读取数据到指定的低端RAM缓冲;
  if (uiComRealSendWordUse[uiComNoINT0_1_2] != uiComRealSendWordPtr[uiComNoINT0_1_2]) // 实际缓冲中数据有效
  {
   // 从实际串口发送缓冲中读取数据到指定的低端RAM缓冲;
   uiComTempSendBytePtr[uiComNoINT0_1_2] = uiReadDataExtComTxd(uiComNoINT0_1_2, uiLowComTxd[uiComNoINT0_1_2], cnComTmpSendBufWordSize); // 需要发给串口的数据
   uiComTempSendBytePtr[uiComNoINT0_1_2] = uiComTempSendBytePtr[uiComNoINT0_1_2] << 1; // 字 = 2字节
  }
  uiComTempSendByteUse[uiComNoINT0_1_2] = 0;
 }
}

// 由NMI调用的串口信息接收函数
void vRecvComInforByNMI()
{
 UINT uiTemp, *uipRxdPtr, uiBytesCount;
 
 //////////////
 // 读取数据 //
 //////////////
 if (uiInterruptFlagNmi & uiMaskNmi) // 接收或发送中断有效
 {
  uipRxdPtr = uiLowComRxd[uiComNoIntNmi] + (uiComTempRecvBytePtr[uiComNoIntNmi] >> 1); // 临时接收缓冲指针,以提高速度

  // 检查线状态寄存器 0 D6 D5 D4 D3 D2 D1 D0
  // ---------------------------------------
  // D0--接收数据准备好
  // D1--数据被冲出错
  // D2--校验出错
  // D3--数据格式出错
  // D4--检出间断
  // D5--发送保持寄存器空
  // D6--发送移位寄存器空
  
  uiBytesCount = 0;
  
  uiTemp = port105; // 线路状态寄存器
  while (uiTemp & 0x01) // 数据准备好否 D0
  {
   if (uiBytesCount ++ >= 16) break; // FIFO最大16字节,防止硬件错误导致死机!

   // D1--数据被冲出错
   // D2--校验出错
   // D3--数据格式出错
   if (uiTemp & 0x6) // D3.D2--校验出错
   {
    uiTemp = port100; // 接收当前字符(必须读取,否则可能导致该字符一直留在FIFO中)
    uiTemp = "?";
   }
   else // 中断接收缓存中, 用于放下一字节的位置
    uiTemp = port100 & 0xff; // 接收当前字符

   if (uiComTempRecvBytePtr[uiComNoIntNmi] & 0x01) // 第1、3、5、7、...字节在低字节位置
   {
    *uipRxdPtr = (*uipRxdPtr) + uiTemp;
    uipRxdPtr ++; // 整字指针加1
   }
   else // 第0、2、4、6、...字节在高字节位置
    *uipRxdPtr = uiTemp << 8;

   // 若指针位于末尾, 则指针回零,并转移数据
   uiComTempRecvBytePtr[uiComNoIntNmi] ++;
   if (uiComTempRecvBytePtr[uiComNoIntNmi] >= cnComTmpRecvBufByteSize) // 串口临时接收缓冲区大小
   {
    // 将低端RAM缓冲中的数据写入实际串口接收缓冲;
    uiWriteDataExtComRxd(uiComNoIntNmi, uiLowComRxd[uiComNoIntNmi], cnComTmpRecvBufWordSize); // 准备发给网络的数据
    uiComTempRecvBytePtr[uiComNoIntNmi] = 0;
    uiComTempRecvByteUse[uiComNoIntNmi] = 0;
    uipRxdPtr = uiLowComRxd[uiComNoIntNmi]; // 临时接收缓冲指针,以提高速度
   }
   
   uiTemp = port105; // 线路状态寄存器
  } // 数据准备好
/*  
  // 中断有效,但数据未准备好;属于错误状态
  if (uiBytesCount == 0) 
   uiTemp = port100; // 防止错误??????????????????
*/   
 } // 接收或发送中断有效

 //////////////
 // 发送数据 // 因为可能由软件启动中断发送数据,因此每次中断必须检查,而不管是否有硬件中断标志
 //////////////
 
 uiBytesCount = 0;
 
 do
 {
  if (uiBytesCount ++ >= 16) break; // FIFO最大16字节,防止硬件错误导致死机!
  
  // 是否有数据需要发送
  if (uiComTempSendByteUse[uiComNoIntNmi] == uiComTempSendBytePtr[uiComNoIntNmi]) break;
  
  uiTemp = port105; // 线路状态寄存器
   
  if (uiTemp & 0x60) // 移位寄存器或发送寄存器空否 D6 D5
  { 
   if (uiComTempSendByteUse[uiComNoIntNmi] & 0x01) // 第0、2、4、6、...字节在低字节位置  
    port100 = (*(uiLowComTxd[uiComNoIntNmi] + (uiComTempSendByteUse[uiComNoIntNmi] >> 1))) & 0xff; // 发送当前字节
   else // 第1、3、5、7、...字节在高字节位置
    port100 = (*(uiLowComTxd[uiComNoIntNmi] + (uiComTempSendByteUse[uiComNoIntNmi] >> 1))) >> 8; // 发送当前字节

   // 若临时发送缓冲内容发送完毕, 则指针回零,并准备转移数据
   uiComTempSendByteUse[uiComNoIntNmi] ++;
   if (uiComTempSendByteUse[uiComNoIntNmi] >= uiComTempSendBytePtr[uiComNoIntNmi]) // 临时缓冲信息发送完毕
   {
    uiComTempSendBytePtr[uiComNoIntNmi] = 0;
    break; // 每次中断仅发送临时发送缓冲中的内容
   }
  } // if ((uiTemp & 0x60)) // 移位寄存器或发送寄存器空否 D6 D5
  else
   break; // 发送寄存器不空,无法继续发送
 } while(TRUE);

 // 若还有数据等待发送,在上一级函数启动串口中断,以提高代码效率
 if (uiComTempSendBytePtr[uiComNoIntNmi])
  return;
 else // 串口临时发送缓冲内容发送完毕,检查扩展RAM中是否有数据
 {
  // 从实际串口发送缓冲中读取数据到指定的低端RAM缓冲;
  if (uiComRealSendWordUse[uiComNoIntNmi] != uiComRealSendWordPtr[uiComNoIntNmi]) // 实际缓冲中数据有效
  {
   // 从实际串口发送缓冲中读取数据到指定的低端RAM缓冲;
   uiComTempSendBytePtr[uiComNoIntNmi] = uiReadDataExtComTxd(uiComNoIntNmi, uiLowComTxd[uiComNoIntNmi], cnComTmpSendBufWordSize); // 需要发给串口的数据
   uiComTempSendBytePtr[uiComNoIntNmi] = uiComTempSendBytePtr[uiComNoIntNmi] << 1; // 字 = 2字节
  }
  uiComTempSendByteUse[uiComNoIntNmi] = 0;
 }
}

// INT0:第一、三片串口芯片中断使用DSP的INT0, 1、 2、 3、 4、 9、10、11、12;
interrupt void ivInt0Function() 
{
 UINT uiTotalComThisTime; // 用于防止串口数不同,错误的中断可能导致程序运行错误

 //////////////////
  // 中断函数主体 //
  //////////////////
  blIntr0NeedToBeActive = FALSE; // 主程序有必要启动一次INTR0;每次收到网络数据,均应置此标志,

 // INT0:第一、三片串口芯片中断使用DSP的INT0, 1、 2、 3、 4、 9、10、11、12;
 // if (cnMaxComThisType < 1) return; // 本类型的最大串口数 // 装置最少为8路

 uiInINT0_1_2 = 0xff00; // 在INT0服务中
 
 // 串口芯片中断标识位读取地址:
 //  INT0:写500H,D1D0 = 00,同时读取600H,D0-D8分别对应INTA1、INTB1、INTC1、INTD1、INTA3、INTB3、INTC3、INTD3;
 //  INT2:写500H,D1D0 = 01,同时读取A00H,D0-D8分别对应INTA2、INTB2、INTC2、INTD2、INTA4、INTB4、INTC4、INTD4;
 //  INT1:写500H,D1D0 = 10,同时读取600H,D0-D8分别对应INTA5、INTB5、INTC5、INTD5、INTA7、INTB7、INTC7、INTD7;
 //  Nmi: 写500H,D1D0 = 11,同时读取A00H,D0-D8分别对应INTA6、INTB6、INTC6、INTD6、INTA8、INTB8、INTC8、INTD8;
 //
 // 用通道号表示
 //  INT0:写500H,D1D0 = 00,同时读取600H,D0-D8分别对应 1、 2、 3、 4、 9、10、11、12;
 //  INT2:写500H,D1D0 = 01,同时读取A00H,D0-D8分别对应 5、 6、 7、 8、13、14、15、16;
 //  INT1:写500H,D1D0 = 10,同时读取600H,D0-D8分别对应17、18、19、20、25、26、27、28;
 //  Nmi: 写500H,D1D0 = 11,同时读取A00H,D0-D8分别对应21、22、23、24、29、30、31、32;

 // 具体查询是那路串口有中断发生
 // ----------------------------
 //  INT0:写500H,D1D0 = 00,同时读取600H,D0-D8分别对应 1、 2、 3、 4、 9、10、11、12;
   port500 = 0x00; 
   uiInterruptFlagINT0_1_2 = port600; // 读取8位串口中断位标志

 // TL16c554路选方法
 // ================
 //        端口地址   D0    D1    D2    D3    D4    D5    D6    D7
 //        --------  ----  ----  ----  ----  ----  ----  ----  ----
 //  INT0:  200H    CSA1  CSB1  CSC1  CSD1  CSA3  CSB3  CSC3  CSD3
 //  INT1:  300H    CSA5  CSB5  CSC5  CSD5  CSA7  CSB7  CSC7  CSD7
 // INT2:  700H    CSA2  CSB2  CSC2  CSD2  CSA4  CSB4  CSC4  CSD4
 // Nmi:    900H    CSA6  CSB6  CSC6  CSD6  CSA8  CSB8  CSC8  CSD8
 //
 //    用通道号表示
 // INT0:  200H      1     2     3     4     9    10    11    12 
 // INT1:  300H     17    18    19    20    25    26    27    28 
 // INT2:  700H      5     6     7     8    13    14    15    16 
 // Nmi:   900H     21    22    23    24    29    30    31    32 
 //
 //  INT0:1     2     3     4     9    10    11    12 
 // --------------------------------------------------
 // 如要选择第 1路port900 = 0xff, port700 = 0xff, port300 = 0xff, port200 = 0xfe;
 // 如要选择第 9路port900 = 0xff, port700 = 0xff, port300 = 0xff, port200 = 0xef;
 //
 //  INT1:17    18    19    20    25    26    27    28 
 // ---------------------------------------------------
 // 如要选择第17路port900 = 0xff, port700 = 0xff, port300 = 0xfe, port200 = 0xff;
 // 如要选择第25路port900 = 0xff, port700 = 0xff, port300 = 0xef, port200 = 0xff;
 //
 //  INT2:5     6     7     8    13    14    15    16
 // --------------------------------------------------
 // 如要选择第 5路port900 = 0xff, port700 = 0xfe, port300 = 0xff, port200 = 0xff;
 // 如要选择第13路port900 = 0xff, port700 = 0xef, port300 = 0xff, port200 = 0xff;
 //
 //  Nmi:21    22    23    24    29    30    31    32
 // --------------------------------------------------
 // 如要选择第21路port900 = 0xfe, port700 = 0xff, port300 = 0xff, port200 = 0xff;
 // 如要选择第29路port900 = 0xef, port700 = 0xff, port300 = 0xff, port200 = 0xff;
 
 uiPort900Val = 0xffff; uiPort700Val = 0xffff; uiPort300Val = 0xffff;
 port900 = uiPort900Val; port700 = uiPort700Val; port300 = uiPort300Val; // 以下只操作port200即可

 // 用于防止串口数不同,错误的中断可能导致程序运行错误
 // ---------------------------------------------------
 // INT0:第一、三片串口芯片中断使用DSP的INT0, 1、 2、 3、 4、 9、10、11、12;
 uiTotalComThisTime = cnMaxComThisType > 8 ? 8:4; // 本类型的最大串口数

 for (uiComNo0_1_2 = 0; uiComNo0_1_2 < uiTotalComThisTime; uiComNo0_1_2 ++)
 {
  uiMaskINT0_1_2 = 1 << uiComNo0_1_2;

  // INT0:第一、三片串口芯片中断使用DSP的INT0, 1、 2、 3、 4、 9、10、11、12;
  if (uiComNo0_1_2 < 4)
   uiComNoINT0_1_2 = uiComNo0_1_2; // 1、 2、 3、 4
  else
   uiComNoINT0_1_2 = uiComNo0_1_2 + 4; // 9、10、11、12
  
  if (uiComNo0_1_2 >= cnMaxComThisType) break; // 本类型的最大串口数
  
  uiPort200Val = ~uiMaskINT0_1_2;
  port200 = uiPort200Val; // TL16c554路选方法

  // 由INT0、INT1和INT2调用的串口信息接收函数
  vRecvComInforByInt0_1_2(); // 因为INT0、INT1和INT2的中断级别相同,因此可以使用同一函数,而不会造成重入问题

  // 若还有数据等待发送,启动串口中断
  if (uiComTempSendBytePtr[uiComNoINT0_1_2])
   blIntr0NeedToBeActive = TRUE; // 主程序有必要启动一次INTR0;每次收到网络数据,均应置此标志,以便启动串口发送
 } // for (uiComNo0_1_2 = 0; uiComNo0_1_2 < 8; uiComNo0_1_2 ++)
 
 uiPort200Val = 0xffff; // 放弃所有串口选择
 port200 = uiPort200Val; // TL16c554路选方法
 
 uiInINT0_1_2 = 0x0000; // 未在INT0、INT1或INT2服务中
}

// INT1:第五、七片串口芯片中断使用DSP的INT1,17、18、19、20、25、26、27、28;
interrupt void ivInt1Function() 
{
 UINT uiTotalComThisTime; // 用于防止串口数不同,错误的中断可能导致程序运行错误

 //////////////////
  // 中断函数主体 //
  //////////////////
  blIntr1NeedToBeActive = FALSE; // 主程序有必要启动一次INTR1;每次收到网络数据,均应置此标志,

 // INT1:第五、七片串口芯片中断使用DSP的INT1,17、18、19、20、25、26、27、28;
 if (cnMaxComThisType < 17) return; // 本类型的最大串口数
 
 uiInINT0_1_2 = 0xff01; // 在INT1服务中
 
 // 串口芯片中断标识位读取地址:
 //  INT0:写500H,D1D0 = 00,同时读取600H,D0-D8分别对应INTA1、INTB1、INTC1、INTD1、INTA3、INTB3、INTC3、INTD3;
 //  INT2:写500H,D1D0 = 01,同时读取A00H,D0-D8分别对应INTA2、INTB2、INTC2、INTD2、INTA4、INTB4、INTC4、INTD4;
 //  INT1:写500H,D1D0 = 10,同时读取600H,D0-D8分别对应INTA5、INTB5、INTC5、INTD5、INTA7、INTB7、INTC7、INTD7;
 //  Nmi: 写500H,D1D0 = 11,同时读取A00H,D0-D8分别对应INTA6、INTB6、INTC6、INTD6、INTA8、INTB8、INTC8、INTD8;
 //
 // 用通道号表示
 //  INT0:写500H,D1D0 = 00,同时读取600H,D0-D8分别对应 1、 2、 3、 4、 9、10、11、12;
 //  INT2:写500H,D1D0 = 01,同时读取A00H,D0-D8分别对应 5、 6、 7、 8、13、14、15、16;
 //  INT1:写500H,D1D0 = 10,同时读取600H,D0-D8分别对应17、18、19、20、25、26、27、28;
 //  Nmi: 写500H,D1D0 = 11,同时读取A00H,D0-D8分别对应21、22、23、24、29、30、31、32;

 // 具体查询是那路串口有中断发生
 // ----------------------------
 //  INT1:写500H,D1D0 = 10,同时读取600H,D0-D8分别对应17、18、19、20、25、26、27、28;
   port500 = 0x10; 
   uiInterruptFlagINT0_1_2 = port600; // 读取8位串口中断位标志

 // TL16c554路选方法
 // ================
 //        端口地址   D0    D1    D2    D3    D4    D5    D6    D7
 //        --------  ----  ----  ----  ----  ----  ----  ----  ----
 //  INT0:  200H    CSA1  CSB1  CSC1  CSD1  CSA3  CSB3  CSC3  CSD3
 //  INT1:  300H    CSA5  CSB5  CSC5  CSD5  CSA7  CSB7  CSC7  CSD7
 // INT2:  700H    CSA2  CSB2  CSC2  CSD2  CSA4  CSB4  CSC4  CSD4
 // Nmi:    900H    CSA6  CSB6  CSC6  CSD6  CSA8  CSB8  CSC8  CSD8
 //
 //    用通道号表示
 // INT0:  200H      1     2     3     4     9    10    11    12 
 // INT1:  300H     17    18    19    20    25    26    27    28 
 // INT2:  700H      5     6     7     8    13    14    15    16 
 // Nmi:   900H     21    22    23    24    29    30    31    32 
 //
 //  INT0:1     2     3     4     9    10    11    12 
 // --------------------------------------------------
 // 如要选择第 1路port900 = 0xff, port700 = 0xff, port300 = 0xff, port200 = 0xfe;
 // 如要选择第 9路port900 = 0xff, port700 = 0xff, port300 = 0xff, port200 = 0xef;
 //
 //  INT1:17    18    19    20    25    26    27    28 
 // ---------------------------------------------------
 // 如要选择第17路port900 = 0xff, port700 = 0xff, port300 = 0xfe, port200 = 0xff;
 // 如要选择第25路port900 = 0xff, port700 = 0xff, port300 = 0xef, port200 = 0xff;
 //
 //  INT2:5     6     7     8    13    14    15    16
 // --------------------------------------------------
 // 如要选择第 5路port900 = 0xff, port700 = 0xfe, port300 = 0xff, port200 = 0xff;
 // 如要选择第13路port900 = 0xff, port700 = 0xef, port300 = 0xff, port200 = 0xff;
 //
 //  Nmi:21    22    23    24    29    30    31    32
 // --------------------------------------------------
 // 如要选择第21路port900 = 0xfe, port700 = 0xff, port300 = 0xff, port200 = 0xff;
 // 如要选择第29路port900 = 0xef, port700 = 0xff, port300 = 0xff, port200 = 0xff;
 
 uiPort900Val = 0xffff; uiPort700Val = 0xffff; uiPort200Val = 0xffff;
 port900 = uiPort900Val; port700 = uiPort700Val; port200 = uiPort200Val; // 以下只操作port300即可

 // 用于防止串口数不同,错误的中断可能导致程序运行错误
 // ---------------------------------------------------
 // INT1:第五、七片串口芯片中断使用DSP的INT1,17、18、19、20、25、26、27、28;
 uiTotalComThisTime = cnMaxComThisType > 24 ? 8:4; // 本类型的最大串口数

 for (uiComNo0_1_2 = 0; uiComNo0_1_2 < uiTotalComThisTime; uiComNo0_1_2 ++)
 {
  uiMaskINT0_1_2 = 1 << uiComNo0_1_2;

  // INT1:第五、七片串口芯片中断使用DSP的INT1,17、18、19、20、25、26、27、28;
  if (uiComNo0_1_2 < 4)
   uiComNoINT0_1_2 = uiComNo0_1_2 + 16; // 17、18、19、20
  else
   uiComNoINT0_1_2 = uiComNo0_1_2 + 20; // 25、26、27、28
  
  if (uiComNo0_1_2 >= cnMaxComThisType) break; // 本类型的最大串口数
  
  uiPort300Val = ~uiMaskINT0_1_2;
  port300 = uiPort300Val; // TL16c554路选方法

  // 由INT0、INT1和INT2调用的串口信息接收函数
  vRecvComInforByInt0_1_2(); // 因为INT0、INT1和INT2的中断级别相同,因此可以使用同一函数,而不会造成重入问题

  // 若还有数据等待发送,启动串口中断
  if (uiComTempSendBytePtr[uiComNoINT0_1_2])
   blIntr1NeedToBeActive = TRUE; // 主程序有必要启动一次INTR1;每次收到网络数据,均应置此标志,以便启动串口发送
 } // for (uiComNo0_1_2 = 0; uiComNo0_1_2 < 8; uiComNo0_1_2 ++)

 uiPort300Val = 0xffff;  // 放弃所有串口选择
 port300 = uiPort300Val; // TL16c554路选方法
 
 uiInINT0_1_2 = 0x0000; // 未在INT0、INT1或INT2服务中
}

// INT2:第二、四片串口芯片中断使用DSP的INT2, 5、 6、 7、 8、13、14, 、15、16;
interrupt void ivInt2Function() 
{
 UINT uiTotalComThisTime; // 用于防止串口数不同,错误的中断可能导致程序运行错误

 //////////////////
  // 中断函数主体 //
  //////////////////
  blIntr2NeedToBeActive = FALSE; // 主程序有必要启动一次INTR2;每次收到网络数据,均应置此标志,

 // INT2:第二、四片串口芯片中断使用DSP的INT2, 5、 6、 7、 8、13、14、15、16;
 // if (cnMaxComThisType < 5) return; // 本类型的最大串口数 // 装置最少为8路
 
 uiInINT0_1_2 = 0xff02; // 在INT2服务中
 
 // 串口芯片中断标识位读取地址:
 //  INT0:写500H,D1D0 = 00,同时读取600H,D0-D8分别对应INTA1、INTB1、INTC1、INTD1、INTA3、INTB3、INTC3、INTD3;
 //  INT2:写500H,D1D0 = 01,同时读取A00H,D0-D8分别对应INTA2、INTB2、INTC2、INTD2、INTA4、INTB4、INTC4、INTD4;
 //  INT1:写500H,D1D0 = 10,同时读取600H,D0-D8分别对应INTA5、INTB5、INTC5、INTD5、INTA7、INTB7、INTC7、INTD7;
 //  Nmi: 写500H,D1D0 = 11,同时读取A00H,D0-D8分别对应INTA6、INTB6、INTC6、INTD6、INTA8、INTB8、INTC8、INTD8;
 //
 // 用通道号表示
 //  INT0:写500H,D1D0 = 00,同时读取600H,D0-D8分别对应 1、 2、 3、 4、 9、10、11、12;
 //  INT2:写500H,D1D0 = 01,同时读取A00H,D0-D8分别对应 5、 6、 7、 8、13、14、15、16;
 //  INT1:写500H,D1D0 = 10,同时读取600H,D0-D8分别对应17、18、19、20、25、26、27、28;
 //  Nmi: 写500H,D1D0 = 11,同时读取A00H,D0

 


共1条 1/1 1 跳转至

回复

匿名不能发帖!请先 [ 登陆 注册 ]