src/knot_thing_protocol.c

 /*
 * Copyright (c) 2016, CESAR.
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms
 * of the BSD license. See the LICENSE file for details.
 *
 */

/* Flag to enable debug logs via Serial */
#define KNOT_DEBUG_ENABLED 0

#include <stdint.h>

#ifdef ARDUINO
#include <Arduino.h>
#include <hal/avr_errno.h>
#include <hal/avr_unistd.h>
#include <hal/avr_log.h>
#define CLEAR_EEPROM_PIN 7
#define PIN_LED_STATUS   6 //LED used to show thing status
#endif

#include <hal/storage.h>
#include <hal/nrf24.h>
#include <hal/comm.h>
#include <hal/gpio.h>
#include <hal/time.h>
#include "knot_thing_protocol.h"
#include "knot_thing_main.h"
#include "knot_thing_config.h"

/* KNoT protocol client states */
#define STATE_DISCONNECTED		0
#define STATE_ACCEPTING			1
#define STATE_CONNECTED			2
#define STATE_AUTHENTICATING		3
#define STATE_REGISTERING		4
#define STATE_SCHEMA			5
#define STATE_SCHEMA_RESP		6
#define STATE_ONLINE			7
#define STATE_RUNNING			8
#define STATE_ERROR			9

/* Intervals for LED blinking */
#define LONG_INTERVAL			10000
#define SHORT_INTERVAL			1000

/* Number of times LED is blinking */
#define BLINK_DISCONNECTED		100
#define BLINK_STABLISHING		2
#define BLINK_ONLINE			1

/* Periods for LED blinking in HALT conditions */
#define NAME_ERROR			50
#define COMM_ERROR			100
#define AUTH_ERROR			250

/* Time that the clear eeprom button needs to be pressed */
#define BUTTON_PRESSED_TIME		5000

/* KNoT MTU */
#define MTU 256

#ifndef MIN
#define MIN(a,b)			(((a) < (b)) ? (a) : (b))
#endif

/* Retransmission timeout in ms */
#define RETRANSMISSION_TIMEOUT				20000

static knot_msg msg;
static struct nrf24_config config = { .mac = 0, .channel = 76 , .name = NULL};
static unsigned long clear_time;
static uint32_t last_timeout;
static int sock = -1;
static int cli_sock = -1;
static bool schema_flag = false;
static uint8_t enable_run = 0, msg_sensor_id = 0;

/*
 * FIXME: Thing address should be received via NFC
 * Mac address must be stored in big endian format
 */

void(* reset_function) (void) = 0; //declare reset function @ address 0

static void set_nrf24MAC(void)
{
	hal_getrandom(config.mac.address.b, sizeof(struct nrf24_mac));
	hal_storage_write_end(HAL_STORAGE_ID_MAC, &config.mac,
						sizeof(struct nrf24_mac));
}

static void verify_clear_data(void)
{
	if (!hal_gpio_digital_read(CLEAR_EEPROM_PIN)) {

		if (clear_time == 0)
			clear_time = hal_time_ms();

		if (hal_timeout(hal_time_ms(), clear_time, BUTTON_PRESSED_TIME)) {
			/* close connection */
			knot_thing_protocol_exit();

			/* generate new MAC addr */
			hal_storage_reset_end();
			set_nrf24MAC();

			/* reset thing */
			reset_function();

		}
	} else
		clear_time = 0;

}

static void halt_blinking_led(uint32_t period)
{
	while (1) {
		hal_gpio_digital_write(PIN_LED_STATUS, 0);
		hal_delay_ms(period);
		hal_gpio_digital_write(PIN_LED_STATUS, 1);
		hal_delay_ms(period);
		verify_clear_data();
	}
}

static int init_connection(void)
{
#if (KNOT_DEBUG_ENABLED == 1)
	char macString[25] = {0};
	nrf24_mac2str(&config.mac, macString);

	hal_log_str("MAC");
	hal_log_str(macString);
#endif
	if (hal_comm_init("NRF0", &config) < 0)
		halt_blinking_led(COMM_ERROR);

	sock = hal_comm_socket(HAL_COMM_PF_NRF24, HAL_COMM_PROTO_RAW);
	if (sock < 0)
		halt_blinking_led(COMM_ERROR);

	clear_time = 0;
	enable_run = 1;
	last_timeout = 0;

	return 0;
}

int knot_thing_protocol_init(const char *thing_name)
{
	hal_gpio_pin_mode(PIN_LED_STATUS, OUTPUT);
	hal_gpio_pin_mode(CLEAR_EEPROM_PIN, INPUT_PULLUP);

	if (thing_name == NULL)
		halt_blinking_led(NAME_ERROR);

	config.name = (const char *) thing_name;

	/* Set mac address if it's invalid on eeprom */
	hal_storage_read_end(HAL_STORAGE_ID_MAC, &config.mac,
						sizeof(struct nrf24_mac));
	/* MAC criteria: less significant 32-bits should not be zero */
	if (!(config.mac.address.uint64 & 0x00000000ffffffff)) {
		hal_storage_reset_end();
		set_nrf24MAC();
	}

	return init_connection();
}

void knot_thing_protocol_exit(void)
{
	hal_comm_close(cli_sock);
	hal_comm_close(sock);
	hal_comm_deinit();
	enable_run = 0;
}

/*
 * The function receives the number of times LED shall blink.
 * For each number n, the status LED should flash 2 * n
 * (once to light, another to turn off)
 */
static void led_status(uint8_t status)
{
	static uint32_t previous_status_time = 0;
	static uint16_t status_interval;
	static uint8_t nblink, led_state, previous_led_state = LOW;
	uint32_t current_status_time = hal_time_ms();

	/*
	 * If the LED has lit and off twice the state,
	 * a set a long interval
	 */
	if (nblink >= (status * 2)) {
		nblink = 0;
		status_interval = LONG_INTERVAL;
		hal_gpio_digital_write(PIN_LED_STATUS, 0);
	}

	/*
	 * Ensures that whenever the status changes,
	 * the blink starts by turning on the LED
	 **/
	if (status != previous_led_state) {
		previous_led_state = status;
		led_state = LOW;
	}

	if ((current_status_time - previous_status_time) >= status_interval) {
		previous_status_time = current_status_time;
		led_state = !led_state;
		hal_gpio_digital_write(PIN_LED_STATUS, led_state);

		nblink++;
		status_interval = SHORT_INTERVAL;
	}
}

static int send_register(void)
{
	uint8_t len;

	len = MIN(sizeof(msg.reg.devName), strlen(config.name));
	msg.hdr.type = KNOT_MSG_REGISTER_REQ;
	msg.reg.id = config.mac.address.uint64; /* Maps id to nRF24 MAC */
	strncpy(msg.reg.devName, config.name, len);
	msg.hdr.payload_len = len + sizeof(msg.reg.id);

	if (hal_comm_write(cli_sock, &(msg.buffer),
			   sizeof(msg.hdr) + msg.hdr.payload_len) < 0)
		return -1;

	return 0;
}

static int read_register(void)
{
	ssize_t nbytes;

	nbytes = hal_comm_read(cli_sock, &(msg.buffer), KNOT_MSG_SIZE);
	if (nbytes <= 0)
		return nbytes;

	if (msg.cred.result != KNOT_SUCCESS)
		return -1;

	hal_storage_write_end(HAL_STORAGE_ID_UUID, msg.cred.uuid,
			      KNOT_PROTOCOL_UUID_LEN);
	hal_storage_write_end(HAL_STORAGE_ID_TOKEN, msg.cred.token,
			      KNOT_PROTOCOL_TOKEN_LEN);
	return 0;
}

static int read_auth(void)
{
	ssize_t nbytes;

	nbytes = hal_comm_read(cli_sock, &(msg.buffer), KNOT_MSG_SIZE);
	if (nbytes <= 0)
		return nbytes;

	if (msg.action.result != KNOT_SUCCESS)
		return -1;
	return 0;
}

static int send_schema(void)
{
	int8_t err;

	err = knot_thing_create_schema(msg_sensor_id, &(msg.schema));

	if (err < 0)
		return err;

	if (hal_comm_write(cli_sock, &(msg.buffer),
				sizeof(msg.hdr) + msg.hdr.payload_len) < 0)
		/* TODO create a better error define in the protocol */
		return KNOT_ERROR_UNKNOWN;

	return KNOT_SUCCESS;
}

static int msg_set_config(uint8_t sensor_id)
{
	int8_t err;

	err = knot_thing_config_data_item(msg.config.sensor_id,
					msg.config.values.event_flags,
					msg.config.values.time_sec,
					&(msg.config.values.lower_limit),
					&(msg.config.values.upper_limit));
	if (err)
		return KNOT_ERROR_UNKNOWN;

	msg.item.sensor_id = sensor_id;
	msg.hdr.type = KNOT_MSG_CONFIG_RESP;
	msg.hdr.payload_len = sizeof(msg.item.sensor_id);

	if (hal_comm_write(cli_sock, &(msg.buffer),
				sizeof(msg.hdr) + msg.hdr.payload_len) < 0)
		return -1;

	return 0;
}

static int msg_set_data(uint8_t sensor_id)
{
	int8_t err;

	err = knot_thing_data_item_write(sensor_id, &(msg.data));

	/*
	 * GW must be aware if the data was succesfully set, so we resend
	 * the request only changing the header type
	 */
	msg.hdr.type = KNOT_MSG_DATA_RESP;
	/* TODO: Improve error handling: Sensor not found, invalid data, etc */
	if (err < 0)
		msg.hdr.type = KNOT_ERROR_UNKNOWN;

	if (hal_comm_write(cli_sock, &(msg.buffer),
				sizeof(msg.hdr) + msg.hdr.payload_len) < 0)
		return -1;

	return 0;
}

static int msg_get_data(uint8_t sensor_id)
{
	int8_t err;

	err = knot_thing_data_item_read(sensor_id, &(msg.data));
	if (err == -2)
		return err;

	msg.hdr.type = KNOT_MSG_DATA;
	if (err < 0)
		msg.hdr.type = KNOT_ERROR_UNKNOWN;

	msg.data.sensor_id = sensor_id;

	if (hal_comm_write(cli_sock, &(msg.buffer),
				sizeof(msg.hdr) + msg.hdr.payload_len) < 0)
		return -1;

	return 0;
}

static inline int is_uuid(const char *string)
{
	return (string != NULL && string[8] == '-' &&
		string[13] == '-' && string[18] == '-' && string[23] == '-');
}

static int8_t mgmt_read(void)
{
	uint8_t buffer[MTU];
	struct mgmt_nrf24_header *mhdr = (struct mgmt_nrf24_header *) buffer;
	ssize_t retval;

	retval = hal_comm_read(sock, buffer, sizeof(buffer));
	if (retval < 0)
		return retval;

	/* Return/ignore if it is not an event? */
	if (!(mhdr->opcode & 0x0200))
		return -EPROTO;

	switch (mhdr->opcode) {

	case MGMT_EVT_NRF24_DISCONNECTED:
		return -ENOTCONN;
	}

	return 0;
}

static void read_online_messages(void)
{
	if (hal_comm_read(cli_sock, &(msg.buffer), KNOT_MSG_SIZE) <= 0)
		return;

	/* There is a message to read */
	switch (msg.hdr.type) {
	case KNOT_MSG_SET_CONFIG:
		msg_set_config(msg.config.sensor_id);
		break;

	case KNOT_MSG_SET_DATA:
		msg_set_data(msg.data.sensor_id);
		break;

	case KNOT_MSG_GET_DATA:
		msg_get_data(msg.item.sensor_id);
		break;

	case KNOT_MSG_DATA_RESP:
		hal_log_str("DT RSP");
		if (msg.action.result != KNOT_SUCCESS) {
			hal_log_str("DT R ERR");
			msg_get_data(msg.item.sensor_id);
		}
		break;

	default:
		/* Invalid command, ignore */
		break;
	}
}

int knot_thing_protocol_run(void)
{
	static uint8_t	run_state = STATE_DISCONNECTED;

	struct nrf24_mac peer;
	int8_t retval;

	/*
	 * Verifies if the button for eeprom clear is pressed for more than 5s
	 */
	verify_clear_data();

	if (enable_run == 0) {
		return -1;
	}

	if (run_state >= STATE_CONNECTED) {
		if (mgmt_read() == -ENOTCONN)
			run_state = STATE_DISCONNECTED;
	}

	/* Network message handling state machine */
	switch (run_state) {
	case STATE_DISCONNECTED:
		/* Internally listen starts broadcasting presence*/
		led_status(BLINK_DISCONNECTED);
		hal_comm_close(cli_sock);
		hal_log_str("DISC");
		if (hal_comm_listen(sock) < 0) {
			break;
		}

		run_state = STATE_ACCEPTING;
		hal_log_str("ACCT");
		break;

	case STATE_ACCEPTING:
		/*
		 * Try to accept GW connection request. EAGAIN means keep
		 * waiting, less then 0 means error and greater then 0 success
		 */
		led_status(BLINK_DISCONNECTED);
		cli_sock = hal_comm_accept(sock, (void *) &peer);
		if (cli_sock == -EAGAIN)
			break;
		else if (cli_sock < 0) {
			run_state = STATE_DISCONNECTED;
			break;
		}
		run_state = STATE_CONNECTED;
		hal_log_str("CONN");
		break;

	case STATE_CONNECTED:
		/*
		 * If uuid/token were found, read the addresses and send
		 * the auth request, otherwise register request
		 */
		led_status(BLINK_STABLISHING);
		hal_storage_read_end(HAL_STORAGE_ID_UUID, &(msg.auth.uuid),
					KNOT_PROTOCOL_UUID_LEN);
		hal_storage_read_end(HAL_STORAGE_ID_TOKEN, &(msg.auth.token),
				KNOT_PROTOCOL_TOKEN_LEN);

		if (is_uuid(msg.auth.uuid)) {
			run_state = STATE_AUTHENTICATING;
			hal_log_str("AUTH");
			msg.hdr.type = KNOT_MSG_AUTH_REQ;
			msg.hdr.payload_len = KNOT_PROTOCOL_UUID_LEN +
						KNOT_PROTOCOL_TOKEN_LEN;

			if (hal_comm_write(cli_sock, &(msg.buffer),
				sizeof(msg.hdr) + msg.hdr.payload_len) < 0)
				run_state = STATE_ERROR;
		} else {
			hal_log_str("REG");
			run_state = STATE_REGISTERING;
			if (send_register() < 0)
				run_state = STATE_ERROR;
		}
		last_timeout = hal_time_ms();
		break;

	/*
	 * Authenticating, Resgistering cases waits (without blocking)
	 * for an response of the respective requests, -EAGAIN means there was
	 * nothing to read so we ignore it, less then 0 an error and 0 success
	 */
	case STATE_AUTHENTICATING:
		led_status(BLINK_STABLISHING);
		retval = read_auth();
		if (retval == KNOT_SUCCESS) {
			run_state = STATE_ONLINE;
			hal_log_str("ONLN");
			/* Checks if all the schemas were sent to the GW and */
			hal_storage_read_end(HAL_STORAGE_ID_SCHEMA_FLAG,
					&schema_flag, sizeof(schema_flag));
			if (!schema_flag)
				run_state = STATE_SCHEMA;
		}
		else if (retval != -EAGAIN)
			halt_blinking_led(AUTH_ERROR);
		else if (hal_timeout(hal_time_ms(), last_timeout,
						RETRANSMISSION_TIMEOUT) > 0)
			run_state = STATE_CONNECTED;
		break;

	case STATE_REGISTERING:
		led_status(BLINK_STABLISHING);
		retval = read_register();
		if (!retval)
			run_state = STATE_SCHEMA;
		else if (retval != -EAGAIN)
			run_state = STATE_ERROR;
		else if (hal_timeout(hal_time_ms(), last_timeout,
						RETRANSMISSION_TIMEOUT) > 0)
			run_state = STATE_CONNECTED;
		break;

	/*
	 * STATE_SCHEMA tries to send an schema and go to STATE_SCHEMA_RESP to
	 * wait for the ack of this schema. If there is no schema for that
	 * msg_sensor_id, increments and stays in the STATE_SCHEMA. If an
	 * error occurs, goes to STATE_ERROR.
	 */
	case STATE_SCHEMA:
		led_status(BLINK_STABLISHING);
		hal_log_str("SCH");
		retval = send_schema();
		switch (retval) {
		case KNOT_SUCCESS:
			last_timeout = hal_time_ms();
			run_state = STATE_SCHEMA_RESP;
			break;
		case KNOT_ERROR_UNKNOWN:
			run_state = STATE_ERROR;
			break;
		case KNOT_SCHEMA_EMPTY:
		case KNOT_INVALID_DEVICE:
			run_state = STATE_SCHEMA;
			msg_sensor_id++;
			break;
		default:
			run_state = STATE_ERROR;
			break;
		}
		break;

	/*
	 * Receives the ack from the GW and returns to STATE_SCHEMA to send the
	 * next schema. If it was the ack for the last schema, goes to
	 * STATE_ONLINE. If it is not a KNOT_MSG_SCHEMA_RESP, ignores. If the
	 * result was not KNOT_SUCCESS, goes to STATE_ERROR.
	 */
	case STATE_SCHEMA_RESP:
		led_status(BLINK_STABLISHING);
		hal_log_str("SCH_R");
		if (hal_comm_read(cli_sock, &(msg.buffer), KNOT_MSG_SIZE) > 0) {
			if (msg.hdr.type != KNOT_MSG_SCHEMA_RESP &&
				msg.hdr.type != KNOT_MSG_SCHEMA_END_RESP)
				break;
			if (msg.action.result != KNOT_SUCCESS) {
				run_state = STATE_SCHEMA;
				break;
			}
			if (msg.hdr.type != KNOT_MSG_SCHEMA_END_RESP) {
				run_state = STATE_SCHEMA;
				msg_sensor_id++;
				break;
			}
			/* All the schemas were sent to GW */
			schema_flag = true;
			hal_storage_write_end(HAL_STORAGE_ID_SCHEMA_FLAG,
					&schema_flag, sizeof(schema_flag));
			run_state = STATE_ONLINE;
			hal_log_str("ONLN");
			msg_sensor_id = 0;
		} else if (hal_timeout(hal_time_ms(), last_timeout,
						RETRANSMISSION_TIMEOUT) > 0)
			run_state = STATE_SCHEMA;
		break;

	case STATE_ONLINE:
		led_status(BLINK_ONLINE);
		read_online_messages();
		msg_sensor_id++;
		msg_get_data(msg_sensor_id);
		hal_log_str("DT");
		if (msg_sensor_id >= KNOT_THING_DATA_MAX) {
			msg_sensor_id = 0;
			run_state = STATE_RUNNING;
			hal_log_str("RUN");
		}
		break;

	case STATE_RUNNING:
		led_status(BLINK_ONLINE);
		read_online_messages();
		/* If some event ocurred send msg_data */
		if (knot_thing_verify_events(&(msg.data)) == 0) {
			if (hal_comm_write(cli_sock, &(msg.buffer),
			sizeof(msg.hdr) + msg.hdr.payload_len) < 0) {
				hal_log_str("DT ERR");
				hal_comm_write(cli_sock, &(msg.buffer),
					sizeof(msg.hdr) + msg.hdr.payload_len);
			} else {
				hal_log_str("DT");
			}
		}
		break;

	case STATE_ERROR:
		hal_gpio_digital_write(PIN_LED_STATUS, 1);
		hal_log_str("ERR");
		/* TODO: Review error state handling */
		run_state = STATE_DISCONNECTED;
		hal_delay_ms(1000);
		break;

	default:
		hal_log_str("INV");
		run_state = STATE_DISCONNECTED;
		break;
	}

	return 0;
}