So, finally, Barc is ready to go back to Germany. Last time I had the main program working well and I just had to tune the CapSense proximity sensors. Now I do not have to thread a USB cable through Barc's mouth the tuning process was pretty simple. I just right-clicked on the CapSense component to launch the tuner, then ran the noise tests, and played with the graph view of the signals to fine-tune the threshold values. Once I got them working I just sent the values back to the project and re-built it. Here is a picture of the raw signals (on top) and the recorded active/inactive values (below) as I put my hand against the left sensor (blue), then the right (orange), and finally above them both. The goal here is to optimize sensing range without being so sensitive that both sensors always fire (because then he'll almost always just back up when a hand is anywhere near him).

While working, however, I figured that I had a couple of defects and had a good idea for one last feature. even though I said I would not do that! First the defects... at the start of the CapSense loop I had a simple if statement.

if( CAPSENSE_NO_BUSY == CapSense_IsBusy() )

This works OK but, if it is busy, then I run the risk of the state variable jumping between a CapSense state and the IR sensor. I also noticed that sometimes Barc would jump forward momentarily when I remove my hand from the side of his face. To fix this I changed the "if" to a "while" so that the code waits until there is CapSense data.

while( CapSense_IsBusy() )
{
    /* Wait for CapSense */
}

This means that the code always checks the CapSense state and the jumpiness goes away.

The next problem was a slight tendency for Barc to get over-excited and run around in circles! This was happening because the motors tend to cause the noise floor to rise and the automatic baseline calculation cannot keep pace. It's not like I ever claimed this was a well-designed CapSense design! But it is a little annoying so I added some code that counts loops and periodically resets the baselines.

/* Periodically re-intialize the CapSense baseline to avoid noise-induced runaway dog */
if( 0 == ( loop_count % BASELINE_RESET_RATE ) )
{
    CapSense_InitializeWidgetBaseline( CapSense_LEFT_WDGT_ID );
    CapSense_InitializeWidgetBaseline( CapSense_RIGHT_WDGT_ID );
}
CapSense_ScanAllWidgets();                  // Start the next scan (non blocking call)

Because Barc is going to a trade show I decided I needed to save a little power or I would be swapping batteries every hour. There are many ways to do that. The ideal method would be to track activity and, if Barc is left alone, go into a deep sleep state, waking periodically to check for a proximity event. But I'll be honest, I ran out of time, so I put in a quick and dirty fix instead. I just added a count of loops with Barc in the WAIT state and, when he's still for a while, I just stop the motors and sensors, and go into stop mode (the lowest power state). He does not start up automatically but a press of the RESET switch does the trick.

Barc and I will be at the Cypress booth during the show - from Tuesday 27th through Thursday 1st - so please stop by and give him a gentle pat on the head.

Here is whole program for your reference. the actual project with the schematic and resources set up is attached to the blog page.

Barc_2.cyprj_.zip

/*
                ****************
                **** Barc_2 ****
                ****************

Barc_2 adds an IR sensor for longer range forward visibility. He supports the following activities.

    LEFT    hand detected on the right proximity sensor
    RIGHT   hand detected on the left proximity sensor
    REVERSE hand detected above (both proximity sensors)
    CHASE   hand detected ahead (IR sensor)
    WAIT    no hand detected
*/

/*
Peripheral includes
*/
#include "project.h"

/*
Library includes (for abs())
*/
#include "stdlib.h"

/*
Infrared sensor and ADC defines
*/
#define IR_POWER_ON             (1)
#define IR_POWER_OFF            (0)
#define IR_SENSOR_SETTLE_TIME   (100)

#define IR_ADC_CHANNEL          (0)
#define IR_ADC_THRESHOLD_MV     (1800)

/*
H-Bridge and PWM Motor defines
*/
#define HBRIDGE_POWER_ON        (1)
#define HBRIDGE_POWER_OFF       (0)

#define SPEED_ILLEGAL           (-1000)

#define SPEED_WALK_LEFT         (38)
#define SPEED_WALK_RIGHT        (40)
#define SPEED_RUN_LEFT          (57)
#define SPEED_RUN_RIGHT         (60)
#define SPEED_STOP              (0)

/*
LED defines
*/
#define LED_ON                  (1)
#define LED_OFF                 (0)

/*
Main loop timing defines
*/
#define WAIT_DEBOUNCE_MS        (50)
#define WAIT_LOOPS_PER_SECOND   (1000/WAIT_DEBOUNCE_MS)
#define WAIT_LOOPS_PER_MINUTE   (60*WAIT_LOOPS_PER_SECOND)
#define BASELINE_RESET_RATE     (5*WAIT_LOOPS_PER_SECOND)
#define HEARTBEAT_PERIOD        (20)
#define HEARTBEAT_DUTY_CYCLE    (1)

/*
Definition of the supported robot states
*/
typedef enum { WAIT, CHASE, REVERSE, LEFT, RIGHT } state_t;

/*
Function declarations
*/
void motor( int, int );

/*
Function:   main

Initialization:
    Turn on the CapSense (proximity sensors) and I2C for tuning
    Turn on the ADC (distance sensor)
    Turn on the motor PWM (outputs are held high to brake the motors)
    Power up the H-Bridge board
    Wait for hardware to settle

Main Loop:
    Read the ADC to detect an object in front
    Read Capsense to detect hands to the side or above
    Act on the detected state - move the robot
*/

int main(void)
{
    state_t state;                                      // Result of sensor scans
    int16 range = 0;                                    // ADC value
    uint32 loop_count = 0;                              // Counter for heartbeat and barking
    uint32_t wait_loop_count = 0;                       // Counter for time spent in WAIT state
    int left, right;                                    // CapSense widget states
    
    CyGlobalIntEnable;      
    
    /*
    Turn on the Capsense proximity detection (with I2C tuning)
    */
    EZI2C_Start();                                      // Turn on I2C (over kitprog bridge)
    EZI2C_EzI2CSetBuffer1( sizeof( CapSense_dsRam ),    // set up I2C buffer for tuning
                           sizeof( CapSense_dsRam ), 
                           (uint8 *)&CapSense_dsRam );
    CapSense_Start();                                   // Turn on CapSense
    CapSense_ScanAllWidgets();                          // Start scanning
    
    /*
    Turn on the IR sensor and ADC
    */
    Pin_IR_GND_Write( IR_POWER_OFF );                   // Make sure ground is low
    Pin_IR_Power_Write( IR_POWER_ON );                  // Turn on the sensor
    CyDelay( IR_SENSOR_SETTLE_TIME );                   // Allow time for sensor output to be valid
    
    ADC_IR_Sensor_Start();                              // Turn on the ADC
    ADC_IR_Sensor_StartConvert();                       // Start sampling (free running)
       
    /*
    Turn on the motors
    */
    PWM_Motor_Start();                                  // Turn on the 2-channel PWM
    motor( SPEED_STOP, SPEED_STOP );                    // Hold output high (no motion)
    Pin_SLP_Write( HBRIDGE_POWER_ON );                  // Turn on the H-bridge for the motors
    CyDelay( 1 );                                       // Allow time for FLT to go low (380us)

    
    /*
    Main loop - read the IR and CapSense sensors then set motor speed accordingly
    */
    for(;;)
    {   
        /*
        Start sensing - default state is WAIT (do nothing)
        */
        state = WAIT;
        
        /* Get an ADC value from the distance sensor and convert it to millivolts */
        if( ADC_IR_Sensor_IsEndConversion( ADC_IR_Sensor_RETURN_STATUS ) )
        {
            range = ADC_IR_Sensor_GetResult16( IR_ADC_CHANNEL );
            range = ADC_IR_Sensor_CountsTo_mVolts( IR_ADC_CHANNEL, range );
        
            /* Change the state if above the proximity threshold */
            if( range > IR_ADC_THRESHOLD_MV )
            {
                state = CHASE;
            }
        }
        
        /*
        CapSense - detect a hand to the left, right or overhead
        */
        while( CapSense_IsBusy() )
        {
            /* Wait for CapSense */
        }
            
        CapSense_ProcessAllWidgets();               // Get the scan results
        CapSense_RunTuner();                        // Tuning across EZI2C 
        
        /* Read the scan values */
        left = CapSense_IsWidgetActive( CapSense_LEFT_WDGT_ID );
        right = CapSense_IsWidgetActive( CapSense_RIGHT_WDGT_ID );
        
        /* Set the state if a hand is detected */
        if( left && right )
        {
            state = REVERSE;                        // Back up
        }
        else if( left )
        {
            state = RIGHT;                          // Turn away
        }
        else if( right )
        {
            state = LEFT;                           // Turn away
        }

        /* Periodically re-intialize the CapSense baseline to avoid noise-induced runaway dog */
        if( 0 == ( loop_count % BASELINE_RESET_RATE ) )
        {
            CapSense_InitializeWidgetBaseline( CapSense_LEFT_WDGT_ID );
            CapSense_InitializeWidgetBaseline( CapSense_RIGHT_WDGT_ID );
        }
    
        CapSense_ScanAllWidgets();                  // Start the next scan (non blocking call)
        
        /*
        State machine - act on the sensed state of the robot
        */
        switch( (int)state )
        {
            case RIGHT:
                /* reverse right motor, forward left */
                motor( SPEED_WALK_LEFT, -SPEED_WALK_RIGHT );
                wait_loop_count = 0;
            break;
            
            case LEFT:
                /* reverse left motor, forward right */
                motor( -SPEED_WALK_LEFT, SPEED_WALK_RIGHT );
                wait_loop_count = 0;
            break;
            
            case REVERSE:
                /* reverse both motors */
                motor( -SPEED_WALK_LEFT, -SPEED_WALK_RIGHT );
                wait_loop_count = 0;
            break;
            
            case CHASE:
                /* forward both motors, fast */             
                motor( SPEED_RUN_LEFT, SPEED_RUN_RIGHT );
                wait_loop_count = 0;
            break;
            
            case WAIT:
            default:
                /* stop both motors */
                motor( SPEED_STOP, SPEED_STOP );
                
                /* sleep if left alone too long */
                wait_loop_count++;
                if( wait_loop_count > WAIT_LOOPS_PER_MINUTE )
                {
                    /* Turn everything off */
                    Pin_Status_Write( LED_OFF );
                    Pin_IR_Power_Write( IR_POWER_OFF );
                    Pin_SLP_Write( HBRIDGE_POWER_OFF );
                    
                    /* Turn off the peripherals */
                    ADC_IR_Sensor_Stop();
                    PWM_Motor_Stop();
                    EZI2C_Stop();
                    CapSense_Stop();
                    
                    CySysPmStop();                      // Re-start via RESET switch
                }
            break;            
        }
        
        /* Create an inverse heart beat (mostly on, briefly off) with the LED */
        Pin_Status_Write( ( loop_count > HEARTBEAT_DUTY_CYCLE ) ? LED_ON : LED_OFF );
        
        loop_count++;
        if( loop_count > HEARTBEAT_PERIOD )
        {
            loop_count = 0;                             // Reset the loop counter
        }

        CyDelay( WAIT_DEBOUNCE_MS );                    // Let the motors run for a while to prevent "jitter"             
    }
}

/*
Function:   motor

Sets the direction register, which swaps the PWM output signal to the H-bridge inputs.
Changes the motor PWM compare value to control the speed.
Only updates the PWM if something needs to change.
*/
void motor( int left, int right )
{
    static int last_left = SPEED_ILLEGAL;               // Remember the previous speeds
    static int last_right = SPEED_ILLEGAL;
    
    /* Pack the directions into a 2-bit register */
    int dir = ( right >= 0 );
    dir <<= 1;
    dir |= ( left >= 0 );
    Reg_Direction_Write( dir );                         // Set the direction (control the OR gates)
    
    if( left != last_left )
        PWM_Motor_WriteCompare1( abs( left ) );         // Left motor speed
        
    if( right != last_right )
        PWM_Motor_WriteCompare2( abs( right ) );        // Right motor speed
        
    last_left = left;                                   // Remember for next call
    last_right = right;
}