UsbCmd.h

Go to the documentation of this file.

// ---API (Go to the Doxygen documentation of this file)---
#ifndef _USBCMD_H
#define _USBCMD_H
#include "StatusCode.h"
#include "ReadWriteBits.h"
#include "BiColorLed.h"
#include "Usb.h"
#include "SpiMaster.h"
 
/* ---------------------------------------- */
/* | ---Command helpers (not commands)--- | */
/* ---------------------------------------- */
inline uint8_t ReadLedState(void) // -> led_state
{
    if (BitIsClear(BiColorLed_ddr, status_led))
        return OFF;
    else // LED is on
        return BitIsClear(BiColorLed_port, status_led)
            ? GREEN : RED;
}
 
/* ------------------ */
/* | ---Commands--- | */
/* ------------------ */
inline void NullCommand(void)
{ 
}
inline void GetBridgeLED(void)
{
    // loop until led_num received
    while (UsbRxbufferIsEmpty());
 
    // read led_num
    uint8_t led_num = 0xFF;
    UsbReadByte(&led_num);
 
    if (led_num == 0) // led_num is valid
    {
        // write OK and LED STATE
        UsbWriteByte(OK);
        UsbWriteByte(ReadLedState());
    }
    else // led_num is invalid
    {
        // write ERROR and pad second byte
        UsbWriteByte(ERROR);
        UsbWriteByte(PADDING);
    }
}
inline void SetBridgeLED(void)
{
    // loop until led_num received
    while (UsbRxbufferIsEmpty());
 
    // read led_num
    uint8_t led_num = 0xFF;
    UsbReadByte(&led_num);
 
    // loop until led_setting received
    while (UsbRxbufferIsEmpty());
 
    // read led_setting
    uint8_t led_setting = 0xFF;
    UsbReadByte(&led_setting);
 
    if ( (led_num == 0) && led_setting_is_valid(led_setting) ) // parameters are valid
    {
        // apply led_setting
        switch (led_setting)
        {
            case 0: BiColorLedOff(status_led); break;
            case 1: BiColorLedOn(status_led); BiColorLedGreen(status_led); break;
            case 2: BiColorLedOn(status_led); BiColorLedRed(status_led); break;
        }
        // write OK
        UsbWriteByte(OK);
    }
    else // at least one parameter is invalid
    {
        UsbWriteByte(ERROR);
    }
}
inline void GetSensorLED(void)
{
    uint8_t const cmd = 3; // command is GetSensorLED
 
    // loop until led_num received
    while (UsbRxbufferIsEmpty());
 
    // read led_num
    uint8_t led_num = 0xFF;
    UsbReadByte(&led_num);
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
    SpiMasterXfrByte(led_num);
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
    // wait for data ready LOW: sensor ready to send LED_SETTING
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read led_setting
    uint8_t led_setting = SpiMasterXfrByte(PADDING);
 
    // write response
    UsbWriteByte(status);
    UsbWriteByte(led_setting);
}
inline void SetSensorLED(void)
{
    uint8_t const cmd = 4; // command is SetSensorLED
 
    // loop until led_num received
    while (UsbRxbufferIsEmpty());
 
    // read led_num
    uint8_t led_num = 0xFF;
    UsbReadByte(&led_num);
 
    // loop until led_setting received
    while (UsbRxbufferIsEmpty());
 
    // read led_setting
    uint8_t led_setting = 0xFF;
    UsbReadByte(&led_setting);
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
    SpiMasterXfrByte(led_num);
    SpiMasterXfrByte(led_setting);
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
 
    // write response from sensor
    UsbWriteByte(status);
}
inline void GetSensorConfig(void)
{
    uint8_t const cmd = 7; // command is GetSensorConfig
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
 
    // TODO(sustainablelab): Add status check and junk bytes to unit tests and docstring.
 
    // Return junk PADDING if vis-spi-out status is ERROR.
    uint8_t binning = PADDING;
    uint8_t gain = PADDING;
    uint8_t row_bitmap = PADDING;
 
    // Proceed with getting the LIS config if status is OK.
    if (status == OK)
    {
        // wait for data ready LOW: sensor ready to send BINNING
        while( BitIsSet(Spi_PortInput, Spi_DataReady));
        // read binning
        binning = SpiMasterXfrByte(PADDING);
 
        // wait for data ready LOW: sensor ready to send GAIN
        while( BitIsSet(Spi_PortInput, Spi_DataReady));
        // read gain
        gain = SpiMasterXfrByte(PADDING);
 
        // wait for data ready LOW: sensor ready to send ROW_BITMAP
        while( BitIsSet(Spi_PortInput, Spi_DataReady));
        // read row_bitmap
        row_bitmap = SpiMasterXfrByte(PADDING);
 
    }
 
    // write response from sensor
    UsbWriteByte(status);
    UsbWriteByte(binning);
    UsbWriteByte(gain);
    UsbWriteByte(row_bitmap);
}
inline void SetSensorConfig(void)
{
    uint8_t const cmd = 8; // command is SetSensorConfig
 
    // loop until binning received
    while (UsbRxbufferIsEmpty());
 
    // read binning
    uint8_t binning = 0xFF;
    UsbReadByte(&binning);
 
    // loop until gain received
    while (UsbRxbufferIsEmpty());
 
    // read gain
    uint8_t gain = 0xFF;
    UsbReadByte(&gain);
 
    // loop until row_bitmap received
    while (UsbRxbufferIsEmpty());
 
    // read row_bitmap
    uint8_t row_bitmap = 0xFF;
    UsbReadByte(&row_bitmap);
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
 
    // Check sensor recognizes command before sending args!
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
 
    // Proceed with sending the LIS config if status is OK.
    if (status == OK)
    {
        SpiMasterXfrByte(binning);
        SpiMasterXfrByte(gain);
        SpiMasterXfrByte(row_bitmap);
 
        // vis-spi-out responds OK after loading new config.
        // vis-spi-out responds ERROR if config is invalid.
 
        // wait for data ready LOW: sensor ready to send STATUS
        while( BitIsSet(Spi_PortInput, Spi_DataReady));
        // read status
        status = SpiMasterXfrByte(PADDING);
    }
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // write response
    UsbWriteByte(status);
 
}
 
inline void GetExposure(void)
{
    uint8_t const cmd = 9; // command is GetExposure
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send EXPOSURE_MSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read exposure_msb
    uint8_t exposure_msb = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send EXPOSURE_LSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read exposure_lsb
    uint8_t exposure_lsb = SpiMasterXfrByte(PADDING);
 
    // write response from sensor
    UsbWriteByte(status);
    UsbWriteByte(exposure_msb);
    UsbWriteByte(exposure_lsb);
}
inline void SetExposure(void)
{
    uint8_t const cmd = 10; // command is SetExposure
 
    // loop until exposure_MSB received
    while (UsbRxbufferIsEmpty());
    
    // read exposure_MSB
    uint8_t exposure_MSB = 0xFF;
    UsbReadByte(&exposure_MSB);
 
    // loop until exposure_LSB received
    while (UsbRxbufferIsEmpty());
    
    // read exposure_LSB
    uint8_t exposure_LSB = 0xFF;
    UsbReadByte(&exposure_LSB);
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
    SpiMasterXfrByte(exposure_MSB);
    SpiMasterXfrByte(exposure_LSB);
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
 
    // write response
    UsbWriteByte(status);
}
inline void CaptureFrame(void)
{
    uint8_t const cmd = 11; // command is CaptureFrame
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send num_pixels_MSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read num_pixels_MSB
    uint8_t num_pixels_MSB = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send num_pixels_LSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read num_pixels_LSB
    uint8_t num_pixels_LSB = SpiMasterXfrByte(PADDING);
 
    // write first three bytes of response from sensor
    UsbWriteByte(status);
    UsbWriteByte(num_pixels_MSB);
    UsbWriteByte(num_pixels_LSB);
 
    if (status == OK)
    {
        /* ------------------ */
        /* | READ THE FRAME | */
        /* ------------------ */
 
        uint16_t num_pixels = (num_pixels_MSB << 8) | num_pixels_LSB;
        uint16_t nbytes = 2*num_pixels;
        uint16_t nbytes_read = 0;
        while(nbytes_read++ < nbytes)
        {
            // wait for data ready LOW: sensor ready to send next byte
            while( BitIsSet(Spi_PortInput, Spi_DataReady));
            // read next byte of frame data and write to USB host
            UsbWriteByte( SpiMasterXfrByte(PADDING) );
        }
    }
 
}
inline void AutoExposure(void)
{
    uint8_t const cmd = 12; // command is GetAutoExposeConfig
 
    /* // indicate BUSY */
    /* BiColorLedRed(status_led); */
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send success
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read success true/false
    uint8_t success = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send iterations
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read number of iterations to hit AutoExpose target
    uint8_t iterations = SpiMasterXfrByte(PADDING);
 
    // write response from sensor
    UsbWriteByte(status);
    UsbWriteByte(success);
    UsbWriteByte(iterations);
 
    /* // indicate DONE */
    /* BiColorLedGreen(status_led); */
}
inline void GetAutoExposeConfig(void)
{
    uint8_t const cmd = 13; // command is GetAutoExposeConfig
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send MAX_TRIES
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read max_tries
    uint8_t max_tries = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send START_PIXEL_MSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read start_pixel_msb
    uint8_t start_pixel_msb = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send START_PIXEL_LSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read start_pixel_lsb
    uint8_t start_pixel_lsb = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send STOP_PIXEL_MSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read stop_pixel_msb
    uint8_t stop_pixel_msb = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send STOP_PIXEL_LSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read stop_pixel_lsb
    uint8_t stop_pixel_lsb = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send TARGET_MSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read target_msb
    uint8_t target_msb = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send TARGET_LSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read target_lsb
    uint8_t target_lsb = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send target_tolerance_MSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read target_tolerance_msb
    uint8_t target_tolerance_msb = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send target_tolerance_LSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read target_tolerance_lsb
    uint8_t target_tolerance_lsb = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send max_exposure_MSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read max_exposure_msb
    uint8_t max_exposure_msb = SpiMasterXfrByte(PADDING);
 
    // wait for data ready LOW: sensor ready to send max_exposure_LSB
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read max_exposure_lsb
    uint8_t max_exposure_lsb = SpiMasterXfrByte(PADDING);
 
    // write response from sensor
    UsbWriteByte(status);
    // default: 10 = 0x0a
    UsbWriteByte(max_tries);
    // default: 7 = 0x0007
    UsbWriteByte(start_pixel_msb); // 0
    UsbWriteByte(start_pixel_lsb); // 7
    // default: 392 = 0x0188
    UsbWriteByte(stop_pixel_msb); // 0x01 -- 1 (*256)
    UsbWriteByte(stop_pixel_lsb); // 0x88 -- 136
    // default: 46420 = 0xb554
    UsbWriteByte(target_msb); // 0xb5 -- 181 (*256)
    UsbWriteByte(target_lsb); // 0x54 -- 84
    // default: 3277 = 0x0ccd
    UsbWriteByte(target_tolerance_msb); // 0x0c -- 12 (*256)
    UsbWriteByte(target_tolerance_lsb); // 0xcd -- 205
    // default: 65535 = 0xFFFF
    UsbWriteByte(max_exposure_msb); // 0x0c -- 12 (*256)
    UsbWriteByte(max_exposure_lsb); // 0xcd -- 205
}
inline void SetAutoExposeConfig(void)
{
 
    /* // indicate BUSY */
    /* BiColorLedRed(status_led); */
    uint8_t const cmd = 14; // command is SetAutoExposeConfig
 
    // loop until max_tries is received
    while (UsbRxbufferIsEmpty());
    // read max_tries
    uint8_t max_tries = 0xFF;
    UsbReadByte(&max_tries);
 
    // loop until start_pixel_msb is received
    while (UsbRxbufferIsEmpty());
    // read start_pixel_msb
    uint8_t start_pixel_msb = 0xFF;
    UsbReadByte(&start_pixel_msb);
 
    // loop until start_pixel_lsb is received
    while (UsbRxbufferIsEmpty());
    // read start_pixel_lsb
    uint8_t start_pixel_lsb = 0xFF;
    UsbReadByte(&start_pixel_lsb);
 
    // loop until stop_pixel_msb is received
    while (UsbRxbufferIsEmpty());
    // read stop_pixel_msb
    uint8_t stop_pixel_msb = 0xFF;
    UsbReadByte(&stop_pixel_msb);
 
    // loop until stop_pixel_lsb is received
    while (UsbRxbufferIsEmpty());
    // read stop_pixel_lsb
    uint8_t stop_pixel_lsb = 0xFF;
    UsbReadByte(&stop_pixel_lsb);
 
    // loop until target_msb is received
    while (UsbRxbufferIsEmpty());
    // read target_msb
    uint8_t target_msb = 0xFF;
    UsbReadByte(&target_msb);
 
    // loop until target_lsb is received
    while (UsbRxbufferIsEmpty());
    // read target_lsb
    uint8_t target_lsb = 0xFF;
    UsbReadByte(&target_lsb);
 
    // loop until target_tolerance_msb is received
    while (UsbRxbufferIsEmpty());
    // read target_tolerance_msb
    uint8_t target_tolerance_msb = 0xFF;
    UsbReadByte(&target_tolerance_msb);
 
    // loop until target_tolerance_lsb is received
    while (UsbRxbufferIsEmpty());
    // read target_tolerance_lsb
    uint8_t target_tolerance_lsb = 0xFF;
    UsbReadByte(&target_tolerance_lsb);
 
    // loop until max_exposure_msb is received
    while (UsbRxbufferIsEmpty());
    // read max_exposure_msb
    uint8_t max_exposure_msb = 0xFF;
    UsbReadByte(&max_exposure_msb);
 
    // loop until max_exposure_lsb is received
    while (UsbRxbufferIsEmpty());
    // read max_exposure_lsb
    uint8_t max_exposure_lsb = 0xFF;
    UsbReadByte(&max_exposure_lsb);
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
    SpiMasterXfrByte(max_tries);
    SpiMasterXfrByte(start_pixel_msb);
    SpiMasterXfrByte(start_pixel_lsb);
    SpiMasterXfrByte(stop_pixel_msb);
    SpiMasterXfrByte(stop_pixel_lsb);
    SpiMasterXfrByte(target_msb);
    SpiMasterXfrByte(target_lsb);
    SpiMasterXfrByte(target_tolerance_msb);
    SpiMasterXfrByte(target_tolerance_lsb);
    SpiMasterXfrByte(max_exposure_msb);
    SpiMasterXfrByte(max_exposure_lsb);
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
 
    // write response
    UsbWriteByte(status);
 
    /* // indicate DONE */
    /* BiColorLedGreen(status_led); */
}
 
// TODO(slab): unit test
inline void GetSensorHash(void)
{
    uint8_t const cmd = 15; // command is GetSensorHash
 
    // send command to sensor
    SpiMasterXfrByte(cmd);
 
    // write OK to indicate command sent to sensor
    UsbWriteByte(OK);
 
    // wait for data ready LOW: sensor ready to send STATUS
    while( BitIsSet(Spi_PortInput, Spi_DataReady));
    // read status
    uint8_t status = SpiMasterXfrByte(PADDING);
 
    // Return junk PADDING if vis-spi-out status is ERROR.
    uint8_t first_byte = PADDING;
    uint8_t second_byte = PADDING;
    uint8_t third_byte = PADDING;
 
    // Proceed with getting the hash if status is OK.
    if (status == OK)
    {
        // wait for data ready LOW: sensor ready to send byte
        while( BitIsSet(Spi_PortInput, Spi_DataReady));
        // read byte
        first_byte = SpiMasterXfrByte(PADDING);
 
        // wait for data ready LOW: sensor ready to send byte
        while( BitIsSet(Spi_PortInput, Spi_DataReady));
        // read byte
        second_byte = SpiMasterXfrByte(PADDING);
 
        // wait for data ready LOW: sensor ready to send byte
        while( BitIsSet(Spi_PortInput, Spi_DataReady));
        // read byte
        third_byte = SpiMasterXfrByte(PADDING);
    }
 
    // write response from sensor
    UsbWriteByte(status);
    UsbWriteByte(first_byte);
    UsbWriteByte(second_byte);
    UsbWriteByte(third_byte);
}
 
#endif // _USBCMD_H