Tooltron

#ifndef _BOOTLOADER_H_

#define _BOOTLOADER_H_

#include <avr/io.h>

#include <avr/boot.h>

#include <avr/wdt.h>

#include <tooltron.h>

#include "rs485_poll.h"

#include "packet.h"

/** @brief This is the address of the tool. Change this pre program instance */

#define ADDR    18

#endif

#include <tooltron.h>

#include <packet.h>

/**

 * @brief Packet handler states

 * @param sd Looking for a start delimiter

 * @param src Looking for a source

 * @param dest Looking for a destination

 * @param comd Looking for a command

 * @param read Reading data payload

 * @param cs Calcualting the checksum and returning

 */

typedef enum {

    sd,   

    src,  

    dest, 

    comd, 

    read, 

    cs    

} state_t;

/**

 * @brief Parses a tooltron packet

 * 

 * This is a state machine that parses the packet. It uses a software 

 * counter to track timeout status. The timeout is not reset unless

 * a fully valid packet is found. It will fail if there is a timeout,

 * crc error, or any error in the packet. All data will be placed in

 * mbuf. Note that mbuf must be able to handle PROGD_PACKET_SIZE

 * bytes.

 *

 * @pre mbuf is PROGD_PACKET_SIZE bytes large

 * @param mbuf Buffer to write the packet data payload to if there is one

 * @return the command received or TT_BAD on any error

 */

char parse_packet(uint8_t *mbuf) {

  uint8_t r;        // Byte from the network

  uint8_t crc;      // Running checksum of the packet

  uint8_t cmd;      // The command received

  uint8_t pos;      // Position in the message buffer

  uint8_t lim;      // Max number of bytes to read into the message buf

  state_t state;    // State machine

  uint16_t count;

  r = 0;

  crc = 0;

  cmd = 0;

  pos = 0;

  lim = 0;

  state = sd;

  count = 0;

  while (1) {

    // Wait for the next byte

    while ((rs485_get_byte(&r)) < 0) {

        if (count >= MAX_TIMEOUT) {

            return TT_BAD;

        } else {

            count++;

        }

    }

    switch (state) {

        case sd:

            if (r == DELIM) {

                state = src;

            }

            break;

        case src:

            if (r == DELIM) {

                state = src;

            } else {

                crc = r;

                state = dest;

            }

            break;

        case dest:

            if (r == DELIM) {

                state = src;

            } else if (r == ADDR) {

                crc ^= r;

                state = comd;

            } else {

                state = sd;

            }

            break;

        case comd:

            cmd = r;

            crc ^= r;

            if (r == DELIM) {

                state = src;

            } else if (r == TT_PROGM) {

                lim = PROGM_PACKET_SIZE;

                state = read;

            } else if (r == TT_PROGD) {

                lim = PROGD_PACKET_SIZE;

                state = read;

            } else {

                state = cs;

            }

            break;

        case read:

            mbuf[pos] = r;

            crc ^= r;

            pos++;

            if (pos == lim) {

                state = cs;

            }

            break;

        case cs:

            if (r == crc) {

                return cmd;

            } else {

                return TT_BAD;

            }

            break;

        default:

            return TT_BAD;

    }

  }

}

/**

 * @brief Sends a packet of type cmd onto the network

 * @param cmd The command to send

 */

void send_packet(uint8_t cmd) {

    rs485_send_byte(DELIM);

    rs485_send_byte(ADDR);

    rs485_send_byte(SERVER);

    rs485_send_byte(cmd);

    rs485_send_byte(ACK_CRC ^ cmd);

}

#include "bootloader.h"

#ifndef _PACKET_H_

#define _PACKET_H_

#include "packet.h"

#include "rs485_poll.h"

#include "bootloader.h"

/** @brief Max time to wait until we exit the packet handler */

#define MAX_TIMEOUT 60000

char parse_packet(uint8_t *mbuf);

void send_packet(uint8_t cmd);

#endif