lpaseens' Blog: Ottawa Arduino Challange - lance sensor/kinetic lance.

I joined Ottawa Arduino Challange where you get a mystery sensor and then need to make something out of it. Besides figure out what to make of it I also need to make the project available on internet so people can see what I'm up to so I'm now writing this down.

The mystery sensor given is a proximity sensor called tcrt5000 and the datasheet indicates it's effective range is 0.2-15mm, practical testing indicates it's a little more depending on what the surface is.
When looking for what to do with it the first thing google took me to was all this robots that follow lines so that I quickly scratched any robot from my project list.
A friend (who like to stay off the net) suggested a kinetic knife. It's about a knife that has to come close but it can't touch. (The idea comes from the books/movies "Dune" where they have kinetic shields).
I have some other ideas but they need more time/material so I decided to go a version of this knife and at $$ store I found a toy that can be used for it.

The plan is
- loose the bubble juice
- use a arduino pro (the small board above the lance) to control it
- set the sensor in the tip
- add some LEDs in the lance part that flashes and shows when you get close or to close(hit)
- somehow add a 7seg led to use as counter
- put the electronics in the transparent part (so you can see it)
- put the battery in the handle (as counter balance)
- maybe put in some noise maker
Usage - it's a game, you need to get close but can't hit. The closer you are the more points but hit and you loose points big time/get to zero.

So far I only figured out how to use the arduino uno as a oversised usb adapter to program the small arduino pro and got it to flash the built in LED different depending on distance that the proxy sensor give.

As I figure out more (like how to format this) I will update this page.

Update1: Have done some testing and coding and got just about all of it to work. Still need some tuning but I got a led showing points, it counts up when close and counts down when hit.
Got one bright RGB LED to indicate score/hit, plan on add more in parallel.

Version - 0.4 of the code

/*
/*
 * Kinetic Lance
 * See when a sensor is close to the target but not to close or you loose points
 * Copyright: Peter Sjoberg <peters-kl at techwiz.ca>
 * License: GPL
 *
 * v0.1 LCD code - just to test the sensor
 * v0.2 Serial so it can be done on the arduino pro
 * v0.3 4x7seg led code using spi
 * v0.4 check continously and count points
 */

// SPI pins
#define DATA 11
#define CLOCK 13
#define LATCH 8
#define LED 3
#define HIT 2
#define BUTTON 4

// SPI: Standard arduino library
#include <SPI.h>

// from https://github.com/PaulStoffregen/TimerOne
#include <TimerOne.h>

byte LEDpattern[]={
    0b11111100,  // 0
    0b01100000,  // 1
    0b11011010,  // 2
    0b11110010,  // 3
    0b01100110,  // 4
    0b10110110,  // 5
    0b10111110,  // 6
    0b11100000,  // 7
    0b11111110,  // 8
    0b11100110,  // 9
// #+10 => decimal
    0b11111101,  // 0.
    0b01100001,  // 1.
    0b11011011,  // 2.
    0b11110011,  // 3.
    0b01100111,  // 4.
    0b10110111,  // 5.
    0b10111111,  // 6.
    0b11100001,  // 7.
    0b11111111,  // 8.
    0b11100111,  // 9.
//
    0b00000000,   // blank (20)
    0b00000001  // . (21)
};

#define MAXLED 4
static byte LEDBuffer[MAXLED]={20,20,20,20};
static byte LEDassembly[MAXLED]={20,20,20,20};
static byte currentLED=0;
static byte RGBled=0;
#define RED 8
#define GREEN 4
#define BLUE 2

//TODO - intensity for the RGBled
void updateDisplay(){
    digitalWrite(LATCH,LOW);
    SPI.transfer(LEDpattern[LEDBuffer[currentLED]]);
    SPI.transfer(((1<<(3-currentLED))<<4)+RGBled);
    digitalWrite(LATCH,HIGH);
    currentLED++;
    if (currentLED==MAXLED){currentLED=0;}
} // updateDisplay

void setup() {
  Serial.begin(115200);
  Serial.println("kinetic lance");
 
  pinMode(DATA,OUTPUT);
  pinMode(CLOCK,OUTPUT);
  pinMode(LATCH,OUTPUT);

pinMode(HIT,OUTPUT);
  pinMode(LED,OUTPUT);
  pinMode(BUTTON,INPUT_PULLUP);

digitalWrite(DATA,LOW);
  digitalWrite(CLOCK,LOW);
  digitalWrite(LATCH,LOW);

SPI.begin();  // Begin SPI hardware
  SPI.setDataMode(SPI_MODE0);
  SPI.setClockDivider(SPI_CLOCK_DIV128);  // Slow down SPI clock, 32 cause issues,64 works so 128 to give some margin
  SPI.setBitOrder(LSBFIRST);

digitalWrite(LATCH,LOW);
  SPI.transfer(0xff); // All on - to test the display
  SPI.transfer(0xff);
  digitalWrite(LATCH,HIGH);
  delay(2000);

/*
  Serial.println("Testing 7seg LED");
  for (int i=0;i<10;i++){
      Serial.println(i);
      for (int j=128;j>8;j=j>>1){
        digitalWrite(LATCH,LOW);
        SPI.transfer(LEDpattern[i]); // test the display
        SPI.transfer(j);
        digitalWrite(LATCH,HIGH);
        digitalWrite(HIT,HIGH);
        delay(500);
        digitalWrite(HIT,LOW);
        delay(500);
      }
  }
*/

/*
Serial.println("Testing RGB LED");
  for (int j=8;j>0;j=j>>1){
    Serial.println(j);
    digitalWrite(LATCH,LOW);
    SPI.transfer(0); // test the display
    SPI.transfer(j);
    digitalWrite(LATCH,HIGH);
    digitalWrite(HIT,HIGH);
    delay(500);
    digitalWrite(HIT,LOW);
    delay(500);
  }
*/

LEDBuffer[0]=20; // space
  LEDBuffer[1]=20; // space
  LEDBuffer[2]=20; // space
  LEDBuffer[3]=0;
  // Setup timer interrupt to update the LED
  Timer1.initialize(1000); // Run every .001 seconds
  Timer1.attachInterrupt(updateDisplay);

} // setup()

int pointsflag=0,points=0,pointlimit=900,hitflag=0,hitlimit=750;

void loop() {
  static int cnt=0;
  int proxval,buttonval,sleep;
 
  proxval = analogRead (1);

if (digitalRead(BUTTON)==0){ // show adc value
    LEDassembly[0]=proxval/1000;
    LEDassembly[1]=(proxval%1000)/100;
    LEDassembly[2]=(proxval%100)/10;
    LEDassembly[3]=proxval%10;
  } else { // Show hits
    LEDassembly[0]=points/1000;
    LEDassembly[1]=(points%1000)/100;
    LEDassembly[2]=(points%100)/10;
    LEDassembly[3]=points%10;
  }

// replace leading "0" with space
  if (LEDassembly[0]==0){
      LEDassembly[0]=20;
      if (LEDassembly[1]==0){
          LEDassembly[1]=20;
          if (LEDassembly[2]==0){
              LEDassembly[2]=20;
          }
      }
  }

//Figured out what we need to show, update display buffer
  noInterrupts();
  LEDBuffer[0]=LEDassembly[0];
  LEDBuffer[1]=LEDassembly[1];
  LEDBuffer[2]=LEDassembly[2];
  LEDBuffer[3]=LEDassembly[3];
  interrupts();

//Check how close it is
  if (proxval<=hitlimit){    
      if (hitflag==0) {points-=10;if (points<0){points=0;}}
      digitalWrite(HIT,HIGH);
      hitflag=1;
      RGBled=RED;
      delay(100);
  } else if (proxval<=pointlimit){
      if (pointsflag==0) {points++;if (points>9999){points=9999;}}
      digitalWrite(HIT,HIGH);
      pointsflag=1;
      RGBled=GREEN;
      delay(10);
  } else {
      digitalWrite(HIT,LOW);
      hitflag=0;
      pointsflag=0;
      RGBled=0;
  };
  
}

Update2:

Done some more work, created a eagle schematic of what I plan to do and started assembly.