/** Transmit buffer over socket (non blocking).
* @param[in] port = port context struct
* @param[in] idx = index in tx buffer array
* @return socket send result
*/
int ecx_portt::outframe_red(int idx)
{
EtherNetHeader *ehp = txbuf[idx].getEtherNetHeader();
/* rewrite MAC source address 1 to primary */
ehp->sa1 = htons(priMAC[1]);
/* transmit over primary socket*/
int rval = outframe(idx, 0);
if (this->redstate != ECT_RED_NONE)
{
EnterCriticalSection(&(this->tx_mutex));
ehp = (EtherNetHeader *)&(this->txbuf2);
/* use dummy frame for secondary socket transmit (BRD) */
EC_Header *datagramP = txbuf2.getECATHeader();
/* write index to frame */
datagramP->setIndex(idx);
/* rewrite MAC source address 1 to secondary */
ehp->sa1 = htons(secMAC[1]);
/* transmit over secondary socket */
pcap_sendpacket(this->redport->sockhandle, (u_char const *)&(this->txbuf2), this->txbuflength2);
LeaveCriticalSection(&(this->tx_mutex));
this->redport->rxbufstat[idx] = EC_BUF_TX;
}
return rval;
}
int main()
{
InitIOPorts();
/* Only cyclical draw the one frame. */
while (1)
{
outframe();
}
return (EXIT_SUCCESS);
}
int main()
{
int frame_counter = 0;
int frame_sec = 0;
InitIOPorts();
while (1)
{
outframe();
frame_sec = (frame_counter++ / 4);
if (frame_sec >= 12)
{
frame_sec = 0;
frame_counter = 0;
}
SCREEN_POINTER = &SCREEN_BUFFER_02[305 * frame_sec];
}
return (EXIT_SUCCESS);
}
/** Blocking redundant receive frame function. If redundant mode is not active then
* it skips the secondary stack and redundancy functions. In redundant mode it waits
* for both (primary and secondary) frames to come in. The result goes in an decision
* tree that decides, depending on the route of the packet and its possible missing arrival,
* how to reroute the original packet to get the data in an other try.
*
* @param[in] port = port context struct
* @param[in] idx = requested index of frame
* @param[in] tvs = timeout
* @return Workcounter if a frame is found with corresponding index, otherwise
* EC_NOFRAME.
*/
int ecx_portt::waitinframe_red(int idx, osal_timert *timer)
{
osal_timert timer2;
int wkc = EC_NOFRAME;
int wkc2 = EC_NOFRAME;
int primrx, secrx;
/* if not in redundant mode then always assume secondary is OK */
if (this->redstate == ECT_RED_NONE)
wkc2 = 0;
do
{
/* only read frame if not already in */
if (wkc <= EC_NOFRAME)
wkc = inframe(idx, 0);
/* only try secondary if in redundant mode */
if (this->redstate != ECT_RED_NONE)
{
/* only read frame if not already in */
if (wkc2 <= EC_NOFRAME)
wkc2 = inframe(idx, 1);
}
/* wait for both frames to arrive or timeout */
} while (((wkc <= EC_NOFRAME) || (wkc2 <= EC_NOFRAME)) && !osal_timer_is_expired(timer));
/* only do redundant functions when in redundant mode */
if (this->redstate != ECT_RED_NONE)
{
/* primrx if the reveived MAC source on primary socket */
primrx = 0;
if (wkc > EC_NOFRAME) primrx = this->rxsa[idx];
/* secrx if the reveived MAC source on psecondary socket */
secrx = 0;
if (wkc2 > EC_NOFRAME) secrx = this->redport->rxsa[idx];
/* primary socket got secondary frame and secondary socket got primary frame */
/* normal situation in redundant mode */
if (((primrx == RX_SEC) && (secrx == RX_PRIM)))
{
/* copy secondary buffer to primary */
memcpy(&(this->rxbuf[idx]), &(this->redport->rxbuf[idx]), this->txbuflength[idx] - sizeof(EtherNetHeader));
wkc = wkc2;
}
/* primary socket got nothing or primary frame, and secondary socket got secondary frame */
/* we need to resend TX packet */
if (((primrx == 0) && (secrx == RX_SEC)) ||
((primrx == RX_PRIM) && (secrx == RX_SEC)))
{
/* If both primary and secondary have partial connection retransmit the primary received
* frame over the secondary socket. The result from the secondary received frame is a combined
* frame that traversed all slaves in standard order. */
if ((primrx == RX_PRIM) && (secrx == RX_SEC))
{
/* copy primary rx to tx buffer */
memcpy(this->txbuf[idx].getECATHeader(), &(this->rxbuf[idx]), this->txbuflength[idx] - sizeof(EtherNetHeader));
}
osal_timer_start(&timer2, EC_TIMEOUTRET);
/* resend secondary tx */
outframe(idx, 1);
do
{
/* retrieve frame */
wkc2 = inframe(idx, 1);
} while ((wkc2 <= EC_NOFRAME) && !osal_timer_is_expired(&timer2));
if (wkc2 > EC_NOFRAME)
{
/* copy secondary result to primary rx buffer */
memcpy(&(this->rxbuf[idx]), &(this->redport->rxbuf[idx]), this->txbuflength[idx] - sizeof(EtherNetHeader));
wkc = wkc2;
}
}
}
/* return WKC or EC_NOFRAME */
return wkc;
}
