VisCmd.c

#include "VisCmd.h"
uint8_t frame[2*MAX_NUM_PIXELS];
/* ------------------ */
/* | ---Commands--- | */
/* ------------------ */
void NullCommand(void);
void GetSensorLED(void);
void SetSensorLED(void);
void GetSensorConfig(void);
void SetSensorConfig(void);
void GetExposure(void);
void SetExposure(void);
void CaptureFrame(void);
void AutoExposure(void);
void GetAutoExposeConfig(void);
void SetAutoExposeConfig(void);
void GetSensorHash(void);
 
/* ---------------------------------------- */
/* | ---Command helpers (not commands)--- | */
/* ---------------------------------------- */
bool LedNumIsValid(bicolorled_num);
uint8_t ReadLedState(bicolorled_num);
bool AutoExposeConfigIsValid(uint8_t, uint16_t, uint16_t, uint16_t);
 
void LisReadout(uint16_t num_pixels);
void S13131Readout(void);
 
uint16_t GetPeak(uint16_t const _start_pixel, uint16_t const _stop_pixel)
{
    // start with a peak value of 0
    uint16_t peak = 0;
 
    // do not look for peak if _stop_pixel < _start_pixel
    if (_stop_pixel < _start_pixel) return peak;
 
    // convert pixel number to index into global frame buffer
    uint16_t byte_index = (_start_pixel-1) * 2; // 2 bytes per pixel
 
    // point at _start_pixel in the global frame buffer
    uint8_t * pframe = frame + byte_index;
 
    // check every pixel until _stop_pixel
    for (uint16_t pixnum = _start_pixel; pixnum++ <= _stop_pixel;)
    {
        uint16_t pixval = (*(pframe++)) << 8;
        pixval |= (*(pframe++));
        if (pixval > peak) peak = pixval;
    }
    return peak;
}
 
#ifdef USE_FAKES
#define LisExpose LisExpose_fake
#define LisReadout LisReadout_fake
#define S13131Expose S13131Expose_fake
#define S13131Readout S13131Readout_fake
#endif
uint16_t AutoExpose(void)
{
    // red means AutoExpose started
    BiColorLedRed(led_1);
 
    // report AutoExpose success/failure
    bool success = false;
 
    // return final peak value for inspecting algorithm behavior
    uint16_t peak=0;
 
    // determine number of pixels to readout
#ifdef LIS
    uint16_t num_pixels;
    if (binning == BINNING_OFF) num_pixels = MAX_NUM_PIXELS;
    else num_pixels = MAX_NUM_PIXELS/2;
#endif
#ifdef S13131
// always 512 pixels, don't need a num_pixels variable
#endif
    /* -------------------- */
    /* | AutoExpose SETUP | */
    /* -------------------- */
 
    // give up after iterations == max_tries
    // SetAutoExposeConfig guarantees at least one try.
    uint8_t iterations = 0;
 
    // calculate target range for peak values
    uint16_t min_peak = _MinPeak(target, target_tolerance);
    uint16_t max_peak = _MaxPeak(target, target_tolerance);
 
    /* ------------------- */
    /* | AutoExpose LOOP | */
    /* ------------------- */
 
    bool done = false;
    while (!done)
    {
        /* -------------- */
        /* | READ FRAME | */
        /* -------------- */
 
#ifdef LIS
        // expose the LIS-770i pixels
        LisExpose();
 
        // readout the LIS-770i pixels into global frame buffer
        LisReadout(num_pixels);
#endif // LIS
#ifdef S13131
        // expose the S13131-512 pixels
        S13131Expose();
 
        // readout the S13131-512 pixels into global frame buffer
        S13131Readout();
#endif
 
        // find peak in range start_pixel : stop_pixel
        peak = GetPeak(start_pixel, stop_pixel);
 
        /* ------------------------ */
        /* | ADJUST EXPOSURE TIME | */
        /* ------------------------ */
 
        // one variable for all big calculation results
        uint32_t big_result; // stores up to 4294967295
 
        // any signal?
        if (peak < max_dark)
        {
            // stop if already at maximum exposure
            // (compare with >= because max_exposure < UINT16_MAX)
            if (exposure_ticks >= max_exposure) done = true;
 
            // otherwise, 10x exposure
            else
            {
                big_result = 10 * exposure_ticks;
 
                // clamp exposure at its maximum value
                if (big_result > max_exposure) big_result = max_exposure;
                exposure_ticks = big_result;
            }
        }
 
        // peak ABOVE target range?
        else if (peak > max_peak)
        {
            // TAKE BACK HALF
            exposure_ticks = exposure_ticks >> 1;
 
            // clamp exposure at its minimum value
            if (exposure_ticks < min_exposure) exposure_ticks = min_exposure;
        }
 
        // peak BELOW target range?
        else if (peak < min_peak)
        {
            // stop if already at maximum exposure
            // (compare with >= because max_exposure < UINT16_MAX)
            if (exposure_ticks >= max_exposure) done = true;
 
            // otherwise, scale exposure by gain
            else
            {
                // -------------------------------------------------
                // | AT LEAST ONE OPERAND MUST BE CAST AS uint32_t |
                // | OTHERWISE THE OPERATION IS TREATED AS 16-bit  |
                // -------------------------------------------------
                big_result = (uint32_t)target * exposure_ticks;
                big_result = big_result / peak;
 
                // clamp exposure at its maximum value
                if (big_result > max_exposure) big_result = max_exposure;
                exposure_ticks = big_result;
            }
        }
 
        // peak is in the target range
        else
        {
            done = true;
            success = true;
            // green means target hit
            BiColorLedGreen(led_1);
        }
 
        // give up if peak fails to hit target range after many tries
        if (++iterations == max_tries) done = true;
    }
    // return success as MSB and iterations as LSB
    uint16_t result = (uint16_t)(success << 8) | iterations;
    return result;
}
#ifdef USE_FAKES
#undef LisExpose
#undef LisReadout
#undef S13131Expose
#undef S13131Readout
#endif