int main(int argc, char *argv[])
{
//the endpoints used in message-oriented communication
mcapi_endpoint_t red_msg_point;
mcapi_endpoint_t yellow_msg_point;
mcapi_endpoint_t green_msg_point;
//the endpoints used in channel-oriented communication
mcapi_endpoint_t yellow_sin_chan;
mcapi_endpoint_t yellow_cos_chan;
mcapi_endpoint_t yellow_pkt_chan;
//status message received in almost all MCAPI-calls
mcapi_status_t status;
//info-struct received in initialization
mcapi_info_t info;
//buffer for incoming messages
char recv_buf[MAX_MSG_LEN];
//the status code converted to string
char status_msg[MCAPI_MAX_STATUS_MSG_LEN];
//size parameter required in some calls
size_t size = 1;
//an iterator used in loops
unsigned int i = 0;
//request handle is used to operate wait-calls
mcapi_request_t request;
//a second request handle! just so that we see it works :)
mcapi_request_t request2;
//sandles used in channel-messaging
mcapi_sclchan_recv_hndl_t sin_handle;
mcapi_sclchan_recv_hndl_t cos_handle;
mcapi_pktchan_send_hndl_t pkt_handle;
//how many scalars we are expecting
char count = 0;
//buffer of data sent in messages
unsigned char* send_buf;
printf(COLOR "here\n");
//We are yellow! initialize accordingly
mcapi_initialize( THE_DOMAIN, YELLOW_NODE, 0, 0, &info, &status );
check( MCAPI_SUCCESS, status );
//create our side of messaging
yellow_msg_point = mcapi_endpoint_create( YELLOW_MSG, &status );
check( MCAPI_SUCCESS, status );
//obtain the red message point
red_msg_point = mcapi_endpoint_get( THE_DOMAIN,
RED_NODE, RED_MSG, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "start-up messaging\n");
//wait for the amount to come
mcapi_msg_recv( yellow_msg_point, recv_buf, MAX_MSG_LEN, &size,
&status );
check( MCAPI_SUCCESS, status );
//read the count from first byte
count = recv_buf[0];
//surprise! this process reserves the buffer with malloc
send_buf = (char*)malloc(count*2);
//send ack
send_buf[0] = 'a';
mcapi_msg_send( yellow_msg_point, red_msg_point, send_buf, 1,
0, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "start-up messaged with %u bytes. expecting %u scalars\n",
size, count );
//open our channel endpoint to sin
yellow_sin_chan = mcapi_endpoint_create( YELLOW_SIN, &status );
check( MCAPI_SUCCESS, status );
//open our channel endpoint to cos
yellow_cos_chan = mcapi_endpoint_create( YELLOW_COS, &status );
check( MCAPI_SUCCESS, status );
//open our ends, let senders form connection
mcapi_sclchan_recv_open_i( &sin_handle, yellow_sin_chan, &request,
&status );
check( MCAPI_PENDING, status );
mcapi_sclchan_recv_open_i( &cos_handle, yellow_cos_chan, &request2,
&status );
check( MCAPI_PENDING, status );
//wait for it to happen
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
mcapi_wait( &request2, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "beginning the receive value\n");
for ( i = 0; i < 15000; ++i )
{
//an iterator used in loops
unsigned int j = 0;
//start to receveive stuff
//i+=2 because our values are two bytes while buf is one byte
for ( j = 0; j < count; ++j )
{
//receive cos scalar
short cval = mcapi_sclchan_recv_uint16( cos_handle, &status );
check( MCAPI_SUCCESS, status );
//receive sin scalar
short sval = mcapi_sclchan_recv_uint16( sin_handle, &status );
check( MCAPI_SUCCESS, status );
//addition
short sumval = sval + cval;
//put to buf
send_buf[j*2] = sumval;
send_buf[j*2+1] = sumval >> 8;
//printf( COLOR "%hX %hhX %hhX\n", sumval, send_buf[j*2],
//send_buf[j*2+1] );
}
}
printf(COLOR "receiving done, closing scalar channels\n");
//close our ends
mcapi_sclchan_recv_close_i( sin_handle, &request, &status );
check( MCAPI_PENDING, status );
mcapi_sclchan_recv_close_i( cos_handle, &request2, &status );
check( MCAPI_PENDING, status );
//wait for it to happen
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
mcapi_wait( &request2, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "closed, informing green\n");
//obtain their endpoint
green_msg_point = mcapi_endpoint_get( THE_DOMAIN,
GREEN_NODE, GREEN_MSG, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
//send the message
mcapi_msg_send( yellow_msg_point, green_msg_point, send_buf, 1,
0, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "informed, opening packet channel\n");
//open our channel endpoint to green
yellow_pkt_chan = mcapi_endpoint_create( YELLOW_PKT, &status );
check( MCAPI_SUCCESS, status );
//open our end, let receiver form connection
mcapi_pktchan_send_open_i( &pkt_handle, yellow_pkt_chan, &request,
&status );
check( MCAPI_PENDING, status );
//wait for it to happen
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
//now send
printf(COLOR "sending the packet\n");
mcapi_pktchan_send( pkt_handle, send_buf, count, &status );
//and now close
printf(COLOR "sent the packet, closing\n");
mcapi_pktchan_send_close_i( pkt_handle, &request, &status );
check( MCAPI_PENDING, status );
mcapi_wait( &request, &size, TIMEOUT, &status );
check( MCAPI_SUCCESS, status );
printf(COLOR "closed, shutdown\n");
//free buf
free( send_buf );
//shut-down
mcapi_finalize( &status );
check( MCAPI_SUCCESS, status );
return EXIT_SUCCESS;
}
/************************************************************************
*
* FUNCTION
*
* MCAPID_Destroy_Service
*
* DESCRIPTION
*
* This function loops through a list of structures, deallocating
* all resources associated with the respective endpoint.
*
* INPUTS
*
* *mcapi_struct A pointer to an array of MCAPID_STRUCT
* structures populated by
* MCAPID_Create_Service().
*
* count The number of elements in the mcapi_struct
* structure.
*
* RETURN
*
* None. The status field of each MCAPID_STRUCT parameter will be
* set according to the status of that service request.
*
*************************************************************************/
void MCAPID_Destroy_Service(MCAPID_STRUCT *mcapi_struct, int count)
{
int i;
for (i = 0; i < count; i ++)
{
/* Initialize status to success. */
mcapi_struct[i].status = MCAPI_SUCCESS;
/* If a service was specified. */
if (mcapi_struct[i].service)
{
/* Operate on the service field based on the type of endpoint. */
switch (mcapi_struct[i].type)
{
/* Server endpoints remove services from the registry. */
case MCAPI_CHAN_PKT_RX_TYPE:
case MCAPI_CHAN_SCL_RX_TYPE:
case MCAPI_MSG_RX_TYPE:
/* Remove the service from the registry. */
mcapi_struct[i].status =
MCAPID_Remove_Service(mcapi_struct[i].service,
mcapi_struct[i].node,
mcapi_struct[i].local_port);
break;
default:
break;
}
}
if (mcapi_struct[i].status == MCAPI_SUCCESS)
{
/* Operate on the structure based on the type of endpoint being
* created.
*/
switch (mcapi_struct[i].type)
{
/* The TX side of a packet channel. */
case MCAPI_CHAN_PKT_TX_TYPE:
/* Close the TX side. */
mcapi_packetchan_send_close_i(mcapi_struct[i].pkt_tx_handle,
&mcapi_struct[i].request,
&mcapi_struct[i].status);
break;
case MCAPI_CHAN_PKT_RX_TYPE:
/* Close the RX side. */
mcapi_packetchan_recv_close_i(mcapi_struct[i].pkt_rx_handle,
&mcapi_struct[i].request,
&mcapi_struct[i].status);
break;
case MCAPI_CHAN_SCL_TX_TYPE:
/* Close the TX side. */
mcapi_sclchan_send_close_i(mcapi_struct[i].scl_tx_handle,
&mcapi_struct[i].request,
&mcapi_struct[i].status);
break;
case MCAPI_CHAN_SCL_RX_TYPE:
/* Close the RX side. */
mcapi_sclchan_recv_close_i(mcapi_struct[i].scl_rx_handle,
&mcapi_struct[i].request,
&mcapi_struct[i].status);
break;
default:
break;
}
}
/* Delete the local endpoint. */
mcapi_delete_endpoint(mcapi_struct[i].local_endp, &mcapi_struct[i].status);
}
} /* MCAPID_Destroy_Service */
