arrow-firmware/main/tnc_kiss.c

/*
 * tnc_kiss.c
 *
 *  Created on: Feb 26, 2019
 *      Author: curiousmuch
 */

// basic set of functions at this moment which decodes KISS

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/ringbuf.h"
#include "esp_log.h"
#include <stdio.h>

// Logging Tag
#define TNC_TAG "KISS TNC"

// Frame Buffer
#define FRAME_BUFFER_SIZE 512

// KISS Specific Characters
#define KISS_FEND 	0xC0
#define KISS_FESC 	0xDB
#define KISS_TFEND 	0xDC
#define KISS_TFESC 	0xDD

// KISS Commands
// command Structure: [ 4 bits ][ 4 bits ]
//				 	  [ TNC #  ][   cmd  ]
#define KISS_DATAFRAME			0x00		// data to be send on HDLC channel
#define KISS_CMD_TXDELAY		0x01		// keyup delay in 10ms units. default is 50ms.
#define KISS_CMD_P				0x02
#define KISS_CMD_SLOTTIME		0x03
#define KISS_CMD_TXTAIL 		0x04
#define KISS_CMD_FULLDUPLEX		0x05
#define KISS_CMD_SETHARDWARE	0x06
#define KISS_CMD_RETURN			0xFF

 typedef struct {
	uint8_t tx_delay;
	uint8_t persistence;
	uint8_t slot_time;
	uint8_t tx_tail;
	uint8_t full_duplex;
	uint8_t tnc_number;
//	uint8_t max_frame_size;
} tnc_settings_t;

typedef enum {
	ESC_MODE = 0,
	FRAME_ASS,
	FRAME_END,
} KISS_STATE_t;

typedef struct {
	uint8_t 	buf[FRAME_BUFFER_SIZE];
	uint32_t 	max_len;
	uint32_t 	index;
} buffer_handle_t;

buffer_handle_t buffer_handle;
tnc_settings_t tnc_settings;

void kiss_clear_buffer(void)
{
	ESP_LOGD(TNC_TAG, "TNC buffer cleared.");
	buffer_handle.index = 0;
}

void kiss_append_buffer(uint8_t chr)
{
	ESP_LOGD(TNC_TAG, "Appending %x to TNC buffer.", chr);
	// ERROR - Packet Buffer Overflow
	if (buffer_handle.index >= buffer_handle.max_len)
	{
		ESP_LOGE(TNC_TAG, "TNC buffer overflow");
		kiss_clear_buffer();
	}
	buffer_handle.buf[(buffer_handle.index)] = chr;
	buffer_handle.index = buffer_handle.index + 1;
}

// Frame Format
// [ Command Byte ][ Data ]
void kiss_process_frame(void)
{
    uint8_t data_byte, tnc_number;
    data_byte = buffer_handle.buf[0];
    tnc_number = (data_byte >> 4) & 0x0F;

    if (tnc_number != tnc_settings.tnc_number)					// ignore irrelevent TNC data
    	return;

	switch( data_byte ) {
		case KISS_DATAFRAME: {
			ESP_LOGI(TNC_TAG, "Received Data Frame - Length %d", (buffer_handle.index));
			ESP_LOG_BUFFER_HEXDUMP(TNC_TAG, buffer_handle.buf, buffer_handle.index, ESP_LOG_INFO);
			// unblock AX.25 code to process code
			break;
		}
		case KISS_CMD_TXDELAY: {
			ESP_LOGI(TNC_TAG, "Updated TX Delay");
			tnc_settings.tx_delay = buffer_handle.buf[1];
			break;
		}
		case KISS_CMD_P: {
			ESP_LOGI(TNC_TAG, "Update Persistence");
			tnc_settings.persistence = buffer_handle.buf[1];
			break;
		}
		case KISS_CMD_SLOTTIME: {
			ESP_LOGI(TNC_TAG, "Updated Slottime");
			tnc_settings.slot_time = buffer_handle.buf[1];
			break;
		}
		case KISS_CMD_TXTAIL: {
			ESP_LOGI(TNC_TAG, "Updated TX Tail");
			tnc_settings.tx_tail= buffer_handle.buf[1];
			break;
		}
		case KISS_CMD_FULLDUPLEX: {
			ESP_LOGI(TNC_TAG, "Updated Full/Half Duplex Setting");
			tnc_settings.full_duplex = buffer_handle.buf[1];
			break;
		}
//		case KISS_CMD_SETHARDWARE: {
//			break;
//		}
//		case KISS_CMD_RETURN: {
//			tnc_settings.tx_delay = buffer_handle.buff_ptr[1];
//			break;
//		}
		default: {
			// error
			break;
		}
	}
	kiss_clear_buffer();
	return;
}

typedef struct {
	uint8_t *data;
	uint16_t len;
} raw_kiss_frame_t;

typedef struct {
	uint8_t *data;
	uint16_t len;
} raw_ax25_frame_t;

#define TNC_INPUT_QUEUE_LEN 1
#define TNC_INPUT_QUEUE_ITEM_SIZE sizeof(raw_kiss_frame_t)
#define TNC_OUTPUT_QUEUE_LEN 1
#define TNC_INPUT_QUEUE_ITEM_SIZE sizeof(raw_ax25_frame_t)

// TNC needs the ability to RX KISS frame, decode it, schedule it, and then send out via APRS or Arrow-Net
// TNC needs the ability to switch to RX mode,

void tnc_init(tnc_settings_t s)
{
	buffer_handle.max_len = FRAME_BUFFER_SIZE;			// TODO: make frame buffer dynamic
//	tnc_settings.max_frame_size = FRAME_BUFFER_SIZE;

	// TODO: Store / retrieve default TNC settings from flash?

	// set default TNC settings
	tnc_settings.tx_delay = s.tx_delay;
	tnc_settings.persistence = s.persistence;
	tnc_settings.slot_time = s.slot_time;
	tnc_settings.tx_tail = s.tx_tail;
	tnc_settings.full_duplex = s.full_duplex;
	tnc_settings.tnc_number = s.tnc_number;

	// setup TNC task with queue
}

// Decode KISS-TNC data from SPP Interface and combine until there is
// is a valid packet. Pass valid packet / frame to AX.25 engine.
// Data Flow:
// (1) SPP interface hands over data array which is runs a state machine to decode the KISS Frame
// (2) Decoded information is uploaded thrown into a buffer
// (3) When frame is complete the state machine will copy or indicate to another task to dump the buffer
// If the frame is not completed, the state machine will wait until more data is provided by the SPP interface.
// If the frame is corrupted or the buffer fills, the frame will be dumped and the error must be logged.
KISS_STATE_t kiss_state = FRAME_END;
void tnc_receive(uint8_t* data, uint16_t len)
{
	uint32_t i;
	uint8_t chr;
	for (i=0; i<len; i++)
	{
		chr = data[i];
		switch(kiss_state) {
			case ESC_MODE: {
				if (chr == KISS_TFEND)
				{
					kiss_append_buffer(KISS_FEND);		// append FEND to frame
					kiss_state = FRAME_ASS;				// return to assembly
				}
				else if (chr == KISS_TFESC)
				{
					kiss_append_buffer(KISS_FESC);		// append FESC to frame
					kiss_state = FRAME_ASS;				// return to assembly
				}
				else if (chr == KISS_FEND)
				{
					kiss_process_frame();				// process frame
					kiss_state = FRAME_END;				// end frame assembly
				}
				else
				{
					// log error
					kiss_append_buffer(chr);			// append chr to frame
					kiss_state = FRAME_ASS;				// return to assembly
				}
				break;
			}
			case FRAME_END: {
				if (chr != KISS_FEND)
				{
					kiss_append_buffer(chr);			// append chr to frame
					kiss_state = FRAME_ASS;				// return to assembly
				}
				else
				{
					kiss_state = FRAME_END;				// stay in frame end
				}
				break;
			}
			case FRAME_ASS: {
				if (chr == KISS_FESC)
				{
					kiss_state = ESC_MODE;
				}
				else if (chr == KISS_FEND)
				{
					kiss_process_frame();				// process frame
					kiss_state = FRAME_END;				// end frame assembly
				}
				else
				{
					kiss_append_buffer(chr);			// append chr to frame
					kiss_state = FRAME_ASS;				// continue frame assembly
				}
				break;
			default: {
				ESP_LOGE(TNC_TAG, "TNC FSM Error");
			}
			}
		}
	}
}