Classes |
| struct | ec_stackT |
Defines |
| #define | RX_PRIM priMAC[1] |
| #define | RX_SEC secMAC[1] |
Enumerations |
| enum | { ECT_RED_NONE,
ECT_RED_DOUBLE
} |
Functions |
| int | ec_closenic (void) |
| uint8 | ec_getindex (void) |
| int | ec_inframe (uint8 idx, int stacknumber) |
| int | ec_outframe (uint8 idx, int stacknumber) |
| int | ec_outframe_red (uint8 idx) |
| static int | ec_recvpkt (int stacknumber) |
| void | ec_setbufstat (uint8 idx, int bufstat) |
| void | ec_setupheader (void *p) |
| int | ec_setupnic (const char *ifname, int secondary) |
| int | ec_srconfirm (uint8 idx, int timeout) |
| int | ec_waitinframe (uint8 idx, int timeout) |
| static int | ec_waitinframe_red (uint8 idx, struct timeval tvs) |
Variables |
| int | ec_errcnt |
| pthread_mutex_t | ec_getindex_mutex = PTHREAD_MUTEX_INITIALIZER |
| int | ec_incnt |
| static uint8 | ec_lastidx |
| int | ec_redstate |
| pthread_mutex_t | ec_rx_mutex = PTHREAD_MUTEX_INITIALIZER |
| ec_bufT | ec_rxbuf [EC_MAXBUF] |
| static ec_bufT | ec_rxbuf2 [EC_MAXBUF] |
| int | ec_rxbufstat [EC_MAXBUF] |
| static int | ec_rxbufstat2 [EC_MAXBUF] |
| static int | ec_rxsa [EC_MAXBUF] |
| static int | ec_rxsa2 [EC_MAXBUF] |
| static ec_stackT | ec_stack [2] |
| static ec_bufT | ec_tempinbuf |
| static ec_bufT | ec_tempinbuf2 |
| static int | ec_tempinbufs |
| pthread_mutex_t | ec_tx_mutex = PTHREAD_MUTEX_INITIALIZER |
| ec_bufT | ec_txbuf [EC_MAXBUF] |
| ec_bufT | ec_txbuf2 |
| int | ec_txbuflength [EC_MAXBUF] |
| int | ec_txbuflength2 |
| int | hlp_rxtime |
| int | hlp_txtime |
| const uint16 | priMAC [3] = {0x0101, 0x0101, 0x0101} |
| const uint16 | secMAC [3] = {0x0404, 0x0404, 0x0404} |
| int | sockhandle = -1 |
| int | sockhandle2 = -1 |
EtherCAT RAW socket driver.
Low level interface functions to send and receive EtherCAT packets. EtherCAT has the property that packets are only send by the master, and the send packets allways return in the receive buffer. There can be multiple packets "on the wire" before they return. To combine the received packets with the original send packets a buffer system is installed. The identifier is put in the index item of the EtherCAT header. The index is stored and compared when a frame is recieved. If there is a match the packet can be combined with the transmit packet and returned to the higher level function.
The socket layer can exhibit a reversal in the packet order (rare). If the Tx order is A-B-C the return order could be A-C-B. The indexed buffer will reorder the packets automatically.
The "redundant" option will configure two sockets and two NIC interfaces. Slaves are connected to both interfaces, one on the IN port and one on the OUT port. Packets are send via both interfaces. Any one of the connections (also an interconnect) can be removed and the slaves are still serviced with packets. The software layer will detect the possible failure modes and compensate. If needed the packets from interface A are resend through interface B. This layer if fully transparent for the higher layers.
Definition in file nicdrv.c.
Non blocking receive frame function. Uses RX buffer and index to combine read frame with transmitted frame. To compensate for received frames that are out-of-order all frames are stored in their respective indexed buffer. If a frame was placed in the buffer previously, the function retreives it from that buffer index without calling ec_recvpkt. If the requested index is not already in the buffer it calls ec_recvpkt to fetch it. There are three options now, 1 no frame read, so exit. 2 frame read but other than requested index, store in buffer and exit. 3 frame read with matching index, store in buffer, set completed flag in buffer status and exit.
- Parameters:
-
| [in] | idx | = requested index of frame |
| [in] | stacknumber | = 0=primary 1=secondary stack |
- Returns:
- Workcounter if a frame is found with corresponding index, otherwise EC_NOFRAME or EC_OTHERFRAME.
Definition at line 415 of file nicdrv.c.
