#include "arq.h"
#include <stdlib.h>
/* Expected frame data for ARQ
*
* +-----+-----+------+
* | seq | cmd | data |
* +-----+-----+------+
*
* seq: sequence number of frame (1 byte)
* cmd: command id of frame (1 byte), currently either ACK or DATA
* data: actual data of frame (arbitraty length, respecting frame limitations)
*
* Note: frame checking, headers and footers are not handled by arq, see 'framing' instead
*
*/
#define MAX_RESENDS 5 //number of resends before a timeout is generated
#define MAX_SEQ 255 //maximum sequence number of frames
#define DATA 0x05
#define ACK 0x06
#define SEQ_INDEX 0
#define CMD_INDEX 1
#define MESSAGE_OFFSET 2
#define MAX_MESSAGE_SIZE MAX_FRAME_SIZE - MESSAGE_OFFSET
typedef enum {
RECEIVED_FRAME,
TIMEOUT
} arq_event;
static void send_ack(arq* a, uint8_t seq) {
uint8_t data[] = {seq, ACK};
a->sender(2, data);
}
static void process_event(arq* a, arq_event event, int16_t data_size, uint8_t* data) {
if (event == RECEIVED_FRAME) {
uint8_t seq = data[SEQ_INDEX];
uint8_t cmd = data[CMD_INDEX];
uint8_t* message = &(data[MESSAGE_OFFSET]);
int16_t message_size = data_size - MESSAGE_OFFSET;
if (!a->awaiting_ack) { //ready to receive
if (cmd == DATA) {
if (a->last_received_seq != seq) {
a->last_received_seq = seq;
a->event_handler(RECEIVED, message_size, message);
}
send_ack(a, seq);
}
//ignore case in which an ack is received even though none is awaited
} else { //awaiting ack
a->awaiting_ack = false;
a->stop_timer();
if (cmd == ACK && seq == a->last_sent_buffer[SEQ_INDEX]) {
a->event_handler(SEND_SUCCESS, a->last_sent_size - MESSAGE_OFFSET, &(a->last_sent_buffer[MESSAGE_OFFSET]));
}
}
} else if (event == TIMEOUT) {
if (a->resends > MAX_RESENDS) {
a->awaiting_ack = false;
a->stop_timer();
a->event_handler(NO_ACK, a->last_sent_size - MESSAGE_OFFSET, &(a->last_sent_buffer[MESSAGE_OFFSET]));
} else {
a->resends += 1;
a->sender(a->last_sent_size, a->last_sent_buffer);
a->awaiting_ack = true;
a->start_timer();
}
}
}
void receive_frame(arq* a, int16_t size, uint8_t* data) {
process_event(a, RECEIVED_FRAME, size, data);
}
void timeout(arq* a) {
process_event(a, TIMEOUT, 0, NULL);
}
void send_message(arq* a, int16_t size, const uint8_t * const message) {
if (a->awaiting_ack) {
a->event_handler(BUSY, size, message);
return;
}
if (size > MAX_MESSAGE_SIZE) {
a->event_handler(SIZE_ERROR, size, message);
return;
}
a->last_sent_buffer[SEQ_INDEX] += 1; //increment seq
a->last_sent_buffer[CMD_INDEX] = DATA;
int i;
for (i = 0; i < size; ++i) {
a->last_sent_buffer[i + MESSAGE_OFFSET] = message[i];
}
a->last_sent_size = MESSAGE_OFFSET + size;
a->sender(a->last_sent_size, a->last_sent_buffer);
a->awaiting_ack = true;
a->resends = 0;
a->start_timer();
}
void init_arq(arq* a) {
a->last_sent_size = 0;
a->last_received_seq = 0;
a->resends = 0;
a->awaiting_ack = false;
}