hwa/atmel/avr/examples/99-01-TCS3200-color-detector/main.c

TCS3200 color detector

The microcontroller outputs a color number in binary form on 4 LED connected to PIN_OUTS according to what it's has been taught previously.

It can also communicate with the host through two host applications:

./tcs3200.py to:

• show status of device (threshold and regions)
• show real-time sampling and store samples into a file
• define a region in the device
• set the value of the maximum period (minimum light level) on the clear channel that enables sampling (0..65535)

./display.py to display (3D) the samples contained in the provided files

The same counter as the software uart swuart0 is used to compute the period of the TCS3200 output signal.

With S0=0 and S1=1, output frequency of the TCS is below 12 kHz, so period is over 83 µs. With HW_SYSHZ=8 MHz, this gives periods >660 counter units. As the counter has 16 bits, the lowest period it can measure is about 122 Hz. Experience shows that it is enough.

boards/attiny84-tcs3200.h

 
/*  This file is part of the HWA project.
 *  Copyright (c) 2012,2015 Christophe Duparquet.
 *  All rights reserved. Read LICENSE.TXT for details.
 */
 
#define BOARD_TCS3200
 
/*  Device configuration
 */
#define HW_DEVICE_CLK_SRC               rc_8MHz
#define HW_DEVICE_CLK_PSC               1
#define HW_DEVICE_EXTERNAL_RESET        enabled
#define HW_DEVICE_SELF_PROGRAMMING      enabled
#define HW_DEVICE_DEBUG_WIRE            disabled
#define HW_DEVICE_WATCHDOG_ALWAYS_ON    no
#define HW_DEVICE_CLOCK_OUTPUT          disabled
#define HW_DEVICE_BROWNOUT_DETECTION    2500_2900mV
 
/*  Settings for building the Diabolo bootloader.
 *  (Settings for the host application are in the board's Makefile)
 */
#define DIABOLO_PIN_RX                  (pin,2)
#define DIABOLO_PIN_TX                  (pin,2)
#define DIABOLO_SYNC                    101
 
/*  Channel selection pins
 */
#define PIN_TCS3200_S2                  (pin,5)
#define PIN_TCS3200_S3                  (pin,3)
 
/*  Create a `PIN_OUTS` object consisting of the 4 consecutive I/O pins
 *  PA5,PA4,PA3,PA2 (14pdip: 8..11)
 */
#define PIN_OUTS                        (porta, 4, 2)
 
/*  Include HWA definitions
 */
#include <hwa/attiny84a_pu.h>

config.h

 
/*  This file is part of the HWA project.
 *  Copyright (c) 2012,2015 Christophe Duparquet.
 *  All rights reserved. Read LICENSE.TXT for details.
 */
 
#ifndef CONFIG_H
#define CONFIG_H
 
#include BOARD_H
 
#include <hwa/ext/swuarta.h>
 
/*
 *  NOTE: do not leave the RX pin floating. Fix-it to high level through 10 kohms.
 */
#define UART                    HW_SWUARTA( txd,      DIABOLO_PIN_TX,   \
                                            rxd,      DIABOLO_PIN_RX,   \
                                            startirq, (DIABOLO_PIN_RX,port,pcic,irq), \
                                            counter,  counter1,         \
                                            compare,  compare0,         \
                                            clkdiv,   1,                \
                                            autosync, 51,               \
                                            fastreg,  (shared,gpior0) )
 
HW_DECLARE(UART);
 
#define COUNTER                 counter1
#define CAPTURE                 (counter1,capture0)
#define COMPARE                 (counter1,compare1)
 
#endif

main.c

 
/*  This file is part of the HWA project.
 *  Copyright (c) 2012,2015 Christophe Duparquet.
 *  All rights reserved. Read LICENSE.TXT for details.
 */
 
#include "config.h"
 
#if ! defined BOARD_TCS3200
#  error Incompatible board
#endif
 
 
/*  Maximum period (minimum light level) required
 */
uint16_t                tclear_max ;
 
 
/*  A region is a structure that describes a 3D sphere in the RGB space
 *  and the result to produce when a RGB point is inside the sphere
 */
typedef struct {
  uint8_t       radius ;
  uint8_t       red, green, blue ;
  uint8_t       result ;  
} region_t ;
 
 
/*  Data stored in EEPROM
 */
static region_t HW_MEM_EEPROM   ee_regions[16] ;
static uint16_t HW_MEM_EEPROM   ee_tclear_max ;
 
 
uint8_t uart_getbyte ( )
{
  while ( !hw(stat,UART).rxc )
    hw( wait, irq );
  return hw( read, UART );
}
 
 
void uart_putbyte ( uint8_t byte )
{
  while ( !hw(stat,UART).txc )
    hw( wait, irq );
  hw( write, UART, byte );
}
 
 
/*  Measure the output signal period of the sensor on channel S3,S2 in HW_SYSHZ
 *  clock units. As we use period ratios, clock frequency has no incidence on
 *  the final results.
 */
static uint16_t measure ( uint8_t s3, uint8_t s2 )
{
  uint16_t t ;
 
  /*  Select the channel
   */
  hw( write, PIN_TCS3200_S3, s3!=0 );
  hw( write, PIN_TCS3200_S2, s2!=0 );
 
  /*    The datasheet says: ``The output-scaling counter registers are cleared
   *    upon the next pulse of the principal frequency after any transition of
   *    the S0, S1, S2, S3, and OE lines. The output goes high upon the next
   *    subsequent pulse of the principal frequency, beginning a new valid
   *    period.``
   *
   *    This is not what I've seen: the rising edge does not follow the change
   *    in S2/S3 immediately. This is not really a problem, just a little more
   *    time consuming.
   */
 
  /*  Prepare to capture the date of the next rising edge
   */
  hw( configure, CAPTURE, edge, rising );
  hw( clear, (CAPTURE,irq) );
 
  /*  Use the compare unit to detect a too long elapsed time for rising edge to
   *  occur
   */
  hw( write, COMPARE, hw(read, COUNTER) );
  hw( clear, (COMPARE,irq) );
 
  for (;;) {
    /*
     *  Rising edge occured: continue below
     */
    if ( hw( read, (CAPTURE,irq) ) ) {
      t = hw( read, CAPTURE ) ;
      break ;
    }
    /*
     *  Compare-match occured: signal period is too long
     */
    if ( hw( read, (COMPARE,irq) ) )
      return 0xFFFF ;
  }
 
  /*  Now wait for the falling edge
   */
  hw( configure, CAPTURE, edge, falling );
  hw( clear, (CAPTURE,irq) );
 
  hw( write, COMPARE, t );
  hw( clear, (COMPARE,irq) );
 
  for (;;) {
    if ( hw( read, (CAPTURE,irq) ) )
      /*
       *  Return the half-period
       */
      return hw( read, CAPTURE ) - t ;
    if ( hw( read, (COMPARE,irq) ) )
      /*
       *  Half-period is too long
       */
      return 0xFFFF ;
  }
}
 
 
/*  !0 if h is an hexa char '0'..'9','A'..'F'
 */
static uint8_t ishex ( uint8_t h )
{
  return (h>='0' && h<='9') || (h>='A' && h<='F') ;
}
 
 
/*  Send one hexa char on UART
 */
static void tx1h ( uint8_t n )
{
  if ( n < 10 )
    n = n + '0' ;
  else
    n = n - 10 + 'A' ;
 
  uart_putbyte( n );
}
 
 
/*  Send one hexa byte on UART
 */
static void tx2h ( uint8_t n )
{
  tx1h( (n>>4) & 0x0F );
  tx1h( (n>>0) & 0x0F );
}
 
 
/*  Send one hexa short on UART
 */
static void tx4h ( uint16_t n )
{
  tx2h( (n>>0) & 0xFF );
  tx2h( (n>>8) & 0xFF );
}
 
 
/*  Convert hexa char to uint8_t
 */
static uint8_t H2i ( uint8_t c )
{
  if ( c<='9' )
    return c-'0' ;
  return 10+c-'A' ;
}
 
 
/*  Convert hexa byte to uint8_t
 */
static uint8_t HH2i ( uint8_t s[] )
{
  return (H2i(s[0])<<4) + H2i(s[1]) ;
}
 
 
/*  Convert hexa short to uint16_t
 */
static uint16_t HHHH2i ( uint8_t s[] )
{
  uint16_t r = HH2i(&s[2]);
  r <<= 8 ;
  r |= HH2i(&s[0]) ;
  return r ;
}
 
 
int
main ( )
{
  hwa( begin, reset );
 
  hwa( configure, UART );
 
  /*  Capture used to compute the TCS output period
   */
  hwa( configure, CAPTURE,
       input,     pin_icp,
       edge,      rising );
 
  hwa( configure, PIN_TCS3200_S2, mode, digital_output );
  hwa( write, PIN_TCS3200_S2, 0 );
 
  /* hwa( configure, PIN_TCS3200_S3, mode, digital_output ); */
  hwa( write, PIN_TCS3200_S3, 0 );
 
  hwa( configure, PIN_OUTS, mode, digital_output );
  hwa( write, PIN_OUTS, 0 );
 
  hwa( commit );
 
  hw( enable, interrupts );
 
  /*  tclear_max is stored in EEPROM
   */
  hw( read_bytes, eeprom0, &tclear_max, &ee_tclear_max, sizeof(tclear_max) );
 
  /*  Main loop
   */
  uint16_t tclear ;
  uint16_t tred   ;
  uint16_t tgreen ;
  uint16_t tblue  ;
  uint32_t pred   ;     // Proportion of red
  uint32_t pgreen ;     // Proportion of green
  uint32_t pblue  ;     // Proportion of blue
 
  for(;;) {
    uint8_t  rn ;       /* region # that owns the sample */
 
    /*  Sample all channels in turn
     */
    tclear = measure( 0,1 );    /* S3S2 = 01: Clear */
    tred   = measure( 0,0 );    /*        00: Red   */
    tgreen = measure( 1,1 );    /*        11: Green */
    tblue  = measure( 1,0 );    /*        10: Blue  */
 
    /*  A minimum light level is required to trigger region search
     */
    if ( tclear < tclear_max &&
         tred   != 0xFFFF &&
         tgreen != 0xFFFF &&
         tblue  != 0xFFFF ) {
      /*
       *  Compute the contribution of each primary color
       *  in the range [0..255]
       */
      uint32_t tclear256 = 256 * (uint32_t)tclear ;
      pred   = (tclear256 + tred/2   ) / tred   ;
      pgreen = (tclear256 + tgreen/2 ) / tgreen ;
      pblue  = (tclear256 + tblue/2  ) / tblue  ;
      /*
       *  Find the region that owns the sample
       *    Compute the quadratic 3D distance
       */
      region_t r ;
      for ( rn=0 ; rn<sizeof(ee_regions)/sizeof(region_t) ; rn++ ) {
        hw( read_bytes, eeprom0, &r, &ee_regions[rn], sizeof(r) ) ;
        if ( r.radius < 0xFF ) {
          uint16_t qp, qr, qg, qb ;
          qp = r.radius ;
          if (pred   > r.red)   qr=pred-r.red ;     qr=r.red-pred ;
          if (pgreen > r.green) qg=pgreen-r.green ; qg=r.green-pgreen ;
          if (pblue  > r.blue)  qb=pblue-r.blue ;   qb=r.blue-pblue ;
          qp = qp*qp ;
          qr = qr*qr ;
          qg = qg*qg ;
          qb = qb*qb ;
          if ( qr+qg+qb < qp )
            break ;
        }
      }
      if ( rn < 16 ) {
        /*
         *  Region found, produce the result
         */
        hw( write, PIN_OUTS, r.result & 0x0F );
      }
      else {
        /*
         *  No region found
         */
        rn = 0xFF ;
 
        hw( write, PIN_OUTS, 0 );
      }
    }
    else {
      /*
       *  Minimum light level is not reached
       */
      rn = 0xFF ;
 
      pred   = 0 ;
      pgreen = 0 ;
      pblue  = 0 ;
 
      hw( write, PIN_OUTS, 0 );
    }
 
    if ( hw(stat,UART).rxc ) {
      /*
       *  Process received byte on UART
       */
      uint8_t cmd = hw( read,UART); 
      if ( cmd=='s' ) {
        /*
         *  Return sampling data to host
         */
        if ( tclear != 0xFFFF &&
             tred   != 0xFFFF &&
             tgreen != 0xFFFF &&
             tblue  != 0xFFFF ) {
          tx4h( tclear );
          tx4h( tred   );
          tx4h( tgreen );
          tx4h( tblue  );
 
          tx2h( pred   );
          tx2h( pgreen );
          tx2h( pblue  );
 
          tx2h( rn  );
        }
        else
          uart_putbyte( '.');
        uart_putbyte( '\n' );
      }
      else if ( cmd=='r' ) {
        /*
         *  List regions stored in EEPROM
         */
        for ( uint8_t i=0 ; i<sizeof(ee_regions)/sizeof(region_t) ; i++ ) {
          region_t r ;
          hw( read_bytes, eeprom0, &r, &ee_regions[i], sizeof(region_t) );
          if ( r.radius != 0xFF ) {
            tx2h(i);
            tx2h(r.radius);
            tx2h(r.red);
            tx2h(r.green);
            tx2h(r.blue);
            tx2h(r.result);
            uart_putbyte( '\n' );
          }
        }
      }
      else if ( cmd=='R' ) {
        /*
         *  Store one region into EEPROM
         */
        /*
         *  Processing a sample can make the MCU busy for a long time compared
         *  to communication data rate and characters may be missed if the host
         *  sends several meanwhile. So, the host will have to wait a ' '
         *  indicating that we're listening before it completes the command.
         */
        uart_putbyte( ' ' );
        /*
         *  Receive the remaining of the command
         *
         *    0,1: region (0..15)
         *    2,3: radius
         *    4,5: red
         *    6,7: green
         *    8,9: blue
         *    A,B: decision
         *         '\n'
         */
        uint8_t cmdbuf[12] ;
        uint8_t i=0 ;
        for(;;) {
          if ( hw(stat,UART).rxc ) {
            uint8_t byte = hw( read,UART);
            if (byte=='\n')
              break ;
            if ( !ishex(byte) )
              i=0xFF ;
            if ( i<sizeof(cmdbuf) )
              cmdbuf[i++] = byte ;
            else
              i=0xFF ;
          }
        }
        if ( i!=sizeof(cmdbuf) )
          goto error ;
 
        /*  Command line seems valid, process it
         */
        uint8_t rn = HH2i( &cmdbuf[0] );        // Region number
        if ( rn > 15 )
          goto error ;
 
        region_t region ;
        region.radius = HH2i( &cmdbuf[2] );     // Region data
        region.red    = HH2i( &cmdbuf[4] );
        region.green  = HH2i( &cmdbuf[6] );
        region.blue   = HH2i( &cmdbuf[8] );
        region.result = HH2i( &cmdbuf[10] );
 
        region_t region0 ;
        hw( read_bytes, eeprom0, &region0, &ee_regions[rn], sizeof(region) );
 
        /*  Update region if different
         */
        if ( __builtin_memcmp(&region, &region0, sizeof(region_t)) )
          hw( write_bytes, eeprom0, &ee_regions[rn], &region, sizeof(region) );
 
        uart_putbyte( '\n' );
      }
      else if ( cmd=='l' ) {
        /*
         *  Return the threshold light level (maximum period on the clear
         *  channel)
         */
        tx4h(tclear_max);
        uart_putbyte( '\n' );
      }
      else if ( cmd=='L' ) {
        /*
         *  Store tclear_max in eeprom
         */
        /*
         *  Send a ' ' to indicate the host that we're now listening
         */
        uart_putbyte( ' ' );
 
        /*  Receive command line
         */
        uint8_t cmdbuf[4] ;
        uint8_t i=0 ;
        for(;;) {
          if ( hw(stat,UART).rxc ) {
            uint8_t byte = hw( read,UART);
            if (byte=='\n')
              break ;
            if ( !ishex(byte) )
              i=0xFF ;
            if ( i<sizeof(cmdbuf) )
              cmdbuf[i++] = byte ;
            else
              i=0xFF ;
          }
        }
        if ( i!=sizeof(cmdbuf) )
          goto error ;
 
        /*  Command line seems valid, process it
         */
        uint16_t max = HHHH2i( &cmdbuf[0] );
        if ( max != tclear_max ) {
          tclear_max = max ;
          hw( write_bytes, eeprom0, &ee_tclear_max, &tclear_max, sizeof(tclear_max) );
          uart_putbyte( 'w' );
        }
        uart_putbyte( '\n' );
      }
      else if ( cmd=='\n' )
        uart_putbyte( '\n' );
      else {
      error:
        uart_putbyte( '!' );
      }
    }
  }
}