?? ubcsp.c
字號:
}
/* We didn't have a packet, or it was reliable
Must wait for ACK before allowing another packet to be sent */
return 0;
}
/*****************************************************************************/
/** **/
/** ubcsp_poll **/
/** **/
/** This is the main function for ubcsp **/
/** It performs a number of tasks **/
/** **/
/** 1) Send another octet to the UART - escaping as required **/
/** 2) Setup the payload to be sent after the header has been sent **/
/** 3) Send the CRC for the packet if required **/
/** **/
/** 4) Calculate the next Link Establishment State **/
/** 5) Send a Link Establishment packet **/
/** 6) Send a normal packet if available **/
/** 7) Send an ACK packet if required **/
/** **/
/** 8) Receive octets from UART and deslip them as required **/
/** 9) Place received octets into receive header or receive payload buffer **/
/** 10) Process received packet when SLIP_END is received **/
/** **/
/** 11) Keep track of ability of caller to delay recalling **/
/** **/
/*****************************************************************************/
uint8 ubcsp_poll (uint8 *activity)
{
uint8
delay = UBCSP_POLL_TIME_IMMEDIATE;
uint8
value;
/* Assume no activity to start with */
*activity = 0;
/* If we don't have to delay, then send something if we can */
if (!ubcsp_config.delay)
{
/* Do we have something we are sending to send */
if (ubcsp_config.send_size)
{
/* We have something to send so send it */
if (ubcsp_config.send_slip_escape)
{
/* Last time we send a SLIP_ESCAPE octet
this time send the second escape code */
put_uart (ubcsp_config.send_slip_escape);
ubcsp_config.send_slip_escape = 0;
}
else
{
#if UBCSP_CRC
/* get the value to send, and calculate CRC as we go */
value = *ubcsp_config.send_ptr ++;
ubcsp_config.send_crc = ubcsp_calc_crc (value, ubcsp_config.send_crc);
/* Output the octet */
ubcsp_put_slip_uart (value);
#else
/* Just output the octet*/
ubcsp_put_slip_uart (*ubcsp_config.send_ptr ++);
#endif
}
/* If we did output a SLIP_ESCAPE, then don't process the end of a block */
if ((!ubcsp_config.send_slip_escape) && ((ubcsp_config.send_size = ubcsp_config.send_size - 1) == 0))
{
/*** We are at the end of a block - either header or payload ***/
/* setup the next block */
ubcsp_config.send_ptr = ubcsp_config.next_send_ptr;
ubcsp_config.send_size = ubcsp_config.next_send_size;
ubcsp_config.next_send_ptr = 0;
ubcsp_config.next_send_size = 0;
#if UBCSP_CRC
/* If we have no successor block
then we might need to send the CRC */
if (!ubcsp_config.send_ptr)
{
if (ubcsp_config.need_send_crc)
{
/* reverse the CRC from what we computed along the way */
ubcsp_config.need_send_crc = 0;
ubcsp_config.send_crc = ubcsp_crc_reverse (ubcsp_config.send_crc);
/* Save in the send_crc buffer */
ubcsp_send_crc[0] = (uint8) (ubcsp_config.send_crc >> 8);
ubcsp_send_crc[1] = (uint8) ubcsp_config.send_crc;
/* Setup to send this buffer */
ubcsp_config.send_ptr = ubcsp_send_crc;
ubcsp_config.send_size = 2;
}
else
{
/* We don't need to send the crc
either we just have, or this packet doesn't include it */
/* Output the end of FRAME marker */
put_uart (SLIP_FRAME);
/* Check if this is an unreliable packet */
*activity |= ubcsp_sent_packet ();
/* We've sent the packet, so don't need to have be called quickly soon */
delay = UBCSP_POLL_TIME_DELAY;
}
}
#else
/* If we have no successor block
then we might need to send the CRC */
if (!ubcsp_config.send_ptr)
{
/* Output the end of FRAME marker */
put_uart (SLIP_FRAME);
/* Check if this is an unreliable packet */
*activity |= ubcsp_sent_packet ();
/* We've sent the packet, so don't need to have be called quickly soon */
delay = UBCSP_POLL_TIME_DELAY;
}
#endif
}
}
else if (ubcsp_config.link_establishment_packet == ubcsp_le_none)
{
/* We didn't have something to send
AND we have no Link Establishment packet to send */
if (ubcsp_config.link_establishment_resp & 2)
{
/* Send the start of FRAME packet */
put_uart (SLIP_FRAME);
/* We did require a RESP packet - so setup the send */
ubcsp_setup_packet ((uint8*) ubcsp_send_le_header, 0, (uint8*) ubcsp_le_buffer[ubcsp_le_conf_resp], 4);
/* We have now "sent" this packet */
ubcsp_config.link_establishment_resp = 0;
}
else if (ubcsp_config.send_packet)
{
/* There is a packet ready to be sent */
/* Send the start of FRAME packet */
put_uart (SLIP_FRAME);
/* Encode up the packet header using ACK and SEQ numbers */
ubcsp_send_header[0] =
(ubcsp_config.send_packet->reliable << 7) |
#if UBCSP_CRC
0x40 | /* Always use CRC's */
#endif
(ubcsp_config.ack_number << 3) |
(ubcsp_config.sequence_number);
/* Encode up the packet header's channel and length */
ubcsp_send_header[1] =
(ubcsp_config.send_packet->channel & 0x0f) |
((ubcsp_config.send_packet->length << 4) & 0xf0);
ubcsp_send_header[2] =
(ubcsp_config.send_packet->length >> 4) & 0xff;
/* Let the ubcsp_setup_packet function calculate the header checksum */
ubcsp_setup_packet ((uint8*) ubcsp_send_header, 1, ubcsp_config.send_packet->payload, ubcsp_config.send_packet->length);
/* Don't need to send an ACK - we just place on in this packet */
ubcsp_config.send_ack = 0;
#if SHOW_PACKET_ERRORS
printf (" : %10d Send %d Ack %d\n",
GetTickCount () % 100000,
ubcsp_config.sequence_number,
ubcsp_config.ack_number);
#endif
}
else if (ubcsp_config.send_ack)
{
/* Send the start of FRAME packet */
put_uart (SLIP_FRAME);
#if SHOW_PACKET_ERRORS
printf (" : %10d Send ACK %d\n",
GetTickCount () % 100000,
ubcsp_config.ack_number);
#endif
/* The ack packet is already computed apart from the first octet */
ubcsp_send_ack_header[0] =
#if UBCSP_CRC
0x40 |
#endif
(ubcsp_config.ack_number << 3);
/* Let the ubcsp_setup_packet function calculate the header checksum */
ubcsp_setup_packet (ubcsp_send_ack_header, 1, 0, 0);
/* We've now sent the ack */
ubcsp_config.send_ack = 0;
}
else
{
/* We didn't have a Link Establishment response packet,
a normal packet or an ACK packet to send */
delay = UBCSP_POLL_TIME_DELAY;
}
}
else
{
#if SHOW_PACKET_ERRORS
// printf (" : %10d Send LE %d\n",
// GetTickCount () % 100000,
// ubcsp_config.link_establishment_packet);
#endif
/* Send A Link Establishment Message */
put_uart (SLIP_FRAME);
/* Send the Link Establishment header followed by the
Link Establishment packet */
ubcsp_setup_packet ((uint8*) ubcsp_send_le_header, 0, (uint8*) ubcsp_le_buffer[ubcsp_config.link_establishment_packet], 4);
/* start sending immediately */
ubcsp_config.delay = 0;
/* workout what the next link establishment packet should be */
ubcsp_config.link_establishment_packet = next_le_packet[ubcsp_config.link_establishment_state + ubcsp_config.link_establishment_resp * 4];
/* We have now delt with any response packet that we needed */
ubcsp_config.link_establishment_resp = 0;
return 0;
}
}
/* We now need to receive any octets from the UART */
while ((ubcsp_config.receive_packet) && (get_uart (&value)))
{
/* If the last octet was SLIP_ESCAPE, then special processing is required */
if (ubcsp_config.receive_slip_escape)
{
/* WARNING - out of range values are not detected !!!
This will probably be caught with the checksum or CRC check */
value = ubcsp_deslip[value - SLIP_ESCAPE_FRAME];
ubcsp_config.receive_slip_escape = 0;
}
else
{
/* Check for the SLIP_FRAME octet - must be start or end of packet */
if (value == SLIP_FRAME)
{
/* If we had a full header then we have a packet */
if (ubcsp_config.receive_index >= 0)
{
/* process the received packet */
*activity |= ubcsp_recevied_packet ();
if (*activity & UBCSP_PACKET_ACK)
{
/* We need to ACK this packet, then don't delay its sending */
ubcsp_config.delay = 0;
}
}
/* Setup to receive the next packet */
ubcsp_config.receive_index = -4;
/* Ok, next octet */
goto finished_receive;
}
else if (value == SLIP_ESCAPE)
{
/* If we receive a SLIP_ESCAPE,
then remember to process the next special octet */
ubcsp_config.receive_slip_escape = 1;
goto finished_receive;
}
}
if (ubcsp_config.receive_index < 0)
{
/* We are still receiving the header */
ubcsp_receive_header[ubcsp_config.receive_index + 4] = value;
ubcsp_config.receive_index ++;
}
else if (ubcsp_config.receive_index < ubcsp_config.receive_packet->length)
{
/* We are receiving the payload */
/* We might stop comming here if we are receiving a
packet which is longer than the receive_packet->length
given by the host */
ubcsp_config.receive_packet->payload[ubcsp_config.receive_index] = value;
ubcsp_config.receive_index ++;
}
finished_receive:
{
}
}
if (ubcsp_config.delay > 0)
{
/* We were delayed so delay some more
this could be cancelled if we received something */
ubcsp_config.delay --;
}
else
{
/* We had no delay, so use the delay we just decided to us */
ubcsp_config.delay = delay;
}
/* Report the current delay to the user */
return ubcsp_config.delay;
}
/*****************************************************************************/
/** **/
/** ubcsp_end_of_functions **/
/** **/
/*****************************************************************************/
/* This function is only included to allow for the size
of the code to be determined */
void ubcsp_end_of_functions (void)
{
}?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -