Temperature & Humidity monitoring

Started to build a temp & humidity monitoring system. Yes, it's a ton of them out there already but I didn't make them so they don't count.

The requirements are multiple (more than standard 3) remote temp and humidity sensors that can be inside or outside. A central console connected to computer that receive the data and can log it somewhere.

Starting with remote sensor part I now figured out the parts needed, put them together and done some coding for it.
For initial round I'm going with all off the shelf stuff. Arduino pro mini as the brain, DHT22 as sensor and the dime a dussin 315MHz transmitters from ebay. Did find a case in a local store that seems to be perfect for the remote sensors at least.

Box to be filled

Since I want to run this off 2xAA batteries I also need a booster (the sensor requires at least 3.3v).

Remote Sensor

Coding is simplified by using VirtualWire lib and DHT22 lib. Was going to use jeelib for power saving sleep but for unknown reason jeelib doesn't like the other two (any one of them seems to work, strange) so I ended up grabbing some pieces from internet to make the arduino power down completely for 8 seconds wake up long enough to see that it's not yet time to send and keep sleeping.
Need to remove the power led but with that one still installed I'm down to 3.5mA during sleep and about 22mA when sending data.

Coding I done so far has defined a protocol that is <27 bytes (VirtualWire lib default limit) and still contain all I think I currently need.
Protocol:

• 1 byte: Type of transmitter, 1=temp/humidity, 2=water level, 3-127=reserved for future use
• 1 byte: Protocol format, depends on sensor but format 2 follows (1 is missing mV)
• 4 byte = unit no of the device, basically a random 64bit number (don't think I need the 128bit uuid)
• 2 byte = Sequence number so receiving side know it's same msg
• 2 byte = vcc in mV
• 2 byte = batt mV
• 1 byte DHT22 status of the data
• 2 byte temp*10
• 2 byte humidity*10
• 2 checksum - 2 bytes

I know length is missing but the first two bytes does define format and with that length can be added if the size is dynamic.
Vcc is calculated reading internal 1.1v ref
batt is a separate wire from before the booster

On the receiving side I got it to receive data, separate the different sensors and show a csv or human readable output on the serial port.

Receiver

My current issue is current and presentation.
The remote sensor is taking to much power for to long, considering changing so it only sends the data once and only if status is ok. If that transmission is lost we get it next round.

On the receiving side I'm wondering how to best present the info (besides serial output). The csv output is pretty simple

#Unitno,unitId,msgCnt,vcc mV,batt mV,stat,temp c,humid %
0,13C76FE0,11,4693,4092,0,22.60,42.60
1,2585C230,63,5051,2152,0,21.00,43.30
1,2585C230,65,5096,2076,0,21.00,43.30
0,13C76FE0,12,4693,4092,0,22.60,42.40

No time since then I would need a rtc somewhere and the time is when it's coming so the receiving app can time stamp itself.
I could add a 4x20 lcd but with more than 4 sensors it gets hard to present anything useful.
Thinking of sending it to an raspberry pi where I add it to a database and then have a website that can do the presentation.

One more thing to figure out is distance, how far away can a sensor be and what can be done to increase the range.


Update1: Managed to put it all inside the box

But I think I may have to find another sensor/add 1 battery, the stepup- converter is killing my battery even when idle.

Update2:
Done some testing and decided that the stepup converter must go. Running it on 5V means higher current to start with and the converter does use some power also. I have removed the power LED in the arduino so now it's only on when sending. I also improved the sleep part so it's doing a full power down and let the watchdog start it up every 8 seconds, so time between transmissions need to be a multiple of 8sec.
Some numbers measured with a cheap multimeter.
The battery lifetime is based on 2400mAh batteries, a sampling of about 4 sec (have to check on why so long) and with a rest of 72sec:

Running on 5v from booster, mA after booster:

Active: 15-18ma
Rest: 0.58mA
Batterylife: N/A (70 days - but not really relevant since that's after booster)

mA before boster:

Active: 42-44mA
Rest: 1.49mA
Batterylife: 27 days

Power usage during using 3xAA and no step-up

Active, 3-4 sec, 11mA
Resting - 78sec, .46-.47 mA
Batterylife: 98 days

So if I run on 2 batteries it takes 3x more power during rest than if I run on 3 batteries and no booster (partly because it's then running on 3.6v instead of 5v) and that means 3.6 times longer between battery replacements. While the arduino can run of 2 batteries the sensor requires at least 3.3V so I need 3x.


Version - 0.4 of the remote sensor code, still need a lot of cleanup but it works
 /* /* * RemoteSensor, transmit temp, humidity and some more info * v0.1 - basic transmit, no unitId * v0.2 - unitId in eeprom, better protocol, transmit 4 times, debug mode * v0.3 - Added battery level info * v0.4 - added power sleep mode */ #include <dht.h> #include <VirtualWire.h> #include <EEPROM.h> dht DHT; #define DHT22_PIN 7 #define DHT22_POWER_PIN 12 #define STATUS_PIN 13 #define TRANSMIT_PIN 4 #define DEBUG_PIN 9 #define RESET_PIN 8 long unitId; boolean DEBUG = false; //Powersave stuff // Extracted from http://www.fiz-ix.com/2012/11/low-power-arduino-using-the-watchdog-timer/ // and http://donalmorrissey.blogspot.ca/2010/04/sleeping-arduino-part-5-wake-up-via.html #include <avr/sleep.h> #include <avr/power.h> #include <avr/wdt.h> // This variable is made volatile because it is changed inside // an interrupt function volatile int sleep_count = 0; // Keep track of how many sleep cycles have been completed. int sleep_total = 0; // cycles before end sleep /*************************************************** * Enable the watchdog ***************************************************/ void watchdogOn() { // Clear the reset flag, the WDRF bit (bit 3) of MCUSR. MCUSR &= ~(1 << WDRF); //MCUSR = MCUSR & B11110111; // Set the WDCE bit (bit 4) and the WDE bit (bit 3) // of WDTCSR. The WDCE bit must be set in order to // change WDE or the watchdog prescalers. Setting the // WDCE bit will allow updtaes to the prescalers and // WDE for 4 clock cycles then it will be reset by // hardware. WDTCSR |= (1 << WDCE) | (1 << WDE); // Set the watchdog timeout prescaler value to 1024 K // which will yeild a time-out interval of about 8.0 s. WDTCSR = 1 << WDP0 | 1 << WDP3; /* 8.0 seconds */ /* Enable the WD interrupt (note no reset). */ WDTCSR |= _BV(WDIE); //WDTCSR = WDTCSR | B01000000; //??? MCUSR = MCUSR & B11110111; } /*************************************************** * Enters the arduino into sleep mode. ***************************************************/ void goToSleep() { // The ATmega328 has five different sleep states. // See the ATmega 328 datasheet for more information. // SLEEP_MODE_IDLE -the least power savings // SLEEP_MODE_ADC // SLEEP_MODE_PWR_SAVE // SLEEP_MODE_STANDBY // SLEEP_MODE_PWR_DOWN -the most power savings // I am using the deepest sleep mode from which a // watchdog timer interrupt can wake the ATMega328 set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Set sleep mode. sleep_enable(); // Enable sleep mode. sleep_bod_disable(); // Disable brownout detection sleep_mode(); // Enter sleep mode. // After waking from watchdog interrupt the code continues // to execute from this point. sleep_disable(); // Disable sleep mode after waking. /* Re-enable the peripherals. */ // power_all_enable(); } //goToSleep /*************************************************** * Watchdog Interrupt Service. This * is executed when watchdog timed out. * ***************************************************/ ISR(WDT_vect) { sleep_count ++; // keep track of how many sleep cycles have been completed. } //ISR /*************************************************** * Read input voltage ***************************************************/ long readVcc() { long result; // Read 1.1V reference against AVcc ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); delay(2); // Wait for Vref to settle ADCSRA |= _BV(ADSC); // Convert while (bit_is_set(ADCSRA, ADSC)); result = ADCL; result |= ADCH << 8; result = 1126400L / result; // Back-calculate AVcc in mV return result; } // readVcc /*************************************************** * Disable ADC when not needed ***************************************************/ void adcDisable() { // Disable the ADC by setting the ADEN bit (bit 7) of the // ADCSRA register to zero. ADCSRA = ADCSRA & B01111111; // Disable the analog comparator by setting the ACD bit // (bit 7) of the ACSR register to one. ACSR = B10000000; // Disable digital input buffers on all analog input pins // by setting bits 0-5 of the DIDR0 register to one. // Of course, only do this if you are not using the analog // inputs for your project. DIDR0 = DIDR0 | B00111111; } //adcDisable /*************************************************** * Enable ADC when needed ***************************************************/ void adcEnable() { // Enable the ADC by setting the ADEN bit (bit 7) of the // ADCSRA register to one. ADCSRA = ADCSRA | B10000000; // Enable the analog comparator by setting the ACD bit // (bit 7) of the ACSR register to zero. ACSR = ACSR & B01111111; // Disable digital input buffers on all analog input pins // by setting bits 0-5 of the DIDR0 register to one. // Of course, only do this if you are not using the analog // inputs for your project. DIDR0 = DIDR0 & B00111110; // only enable adc0 } // adcEnable /*************************************************** * Disable as much as possible before going to sleep ***************************************************/ void prepForSleep() { //Shut off ADC, TWI, SPI, Timer0, Timer1 digitalWrite(DHT22_POWER_PIN, LOW); // power_adc_disable(); // power_twi_disable(); // power_spi_disable(); // power_usart0_disable(); // power_timer0_disable(); //Needed for delay_ms // power_timer1_disable(); //Needed for transmit // power_timer2_disable(); //Needed for asynchronous 32kHz operation power_all_disable(); } // prepForSleep /*************************************************** * Enable functions needed ***************************************************/ void wakeup() { digitalWrite(DHT22_POWER_PIN, HIGH); // adcEnable(); power_adc_enable(); // for batt voltage if (DEBUG) power_usart0_enable(); power_timer0_enable(); //Needed for delay_ms power_timer1_enable(); //Needed for transmit } // wakeup /*************************************************** * Setup everything ***************************************************/ void setup() { long notunitId; int i; Serial.begin(115200); Serial.println("Temp/Humidity remote sensor"); Serial.println(); Serial.print( "Voltage: " ); Serial.print( readVcc(), DEC ); Serial.println("mV"); Serial.print( "Batt voltage: " ); Serial.print( readVcc() / 1024 * analogRead(0), DEC ); // Serial.print( "(" ); // Serial.print( analogRead(0), DEC ); // Serial.print( ")" ); Serial.println("mV"); watchdogOn(); // Initialise the IO and ISR vw_set_tx_pin(TRANSMIT_PIN); // vw_set_rx_pin(RECEIVE_PIN); // vw_set_ptt_pin(TRANSMIT_EN_PIN); // vw_set_ptt_inverted(true); // Required for DR3100 vw_setup(4800); // Bits per sec pinMode(STATUS_PIN, OUTPUT); digitalWrite(STATUS_PIN, LOW); pinMode(DHT22_POWER_PIN, OUTPUT); pinMode(DEBUG_PIN, INPUT_PULLUP); pinMode(RESET_PIN, INPUT_PULLUP); /* Serial.print("EEprom values: "); for(i=0;i<8;i++){ Serial.print(EEPROM.read(i),HEX);Serial.print(' '); } Serial.println(); */ unitId = (long)EEPROM.read(0) << 24 | (long)EEPROM.read(1) << 16 | (long)EEPROM.read(2) << 8 | (long)EEPROM.read(3); notunitId = (long)EEPROM.read(4) << 24 | (long)EEPROM.read(5) << 16 | (long)EEPROM.read(6) << 8 | (long)EEPROM.read(7); if (digitalRead(RESET_PIN) == LOW) { Serial.println("Force generation of a new unitId"); unitId = notunitId = 4711; } if (unitId == -notunitId) { Serial.print("unitId from eeprom: "); Serial.print(unitId, HEX); } else { randomSeed(analogRead(7)*analogRead(6)*analogRead(5) + micros()); unitId = random(); notunitId = -unitId; EEPROM.write(0, unitId >> 24 & 0xFF); EEPROM.write(1, unitId >> 16 & 0xFF); EEPROM.write(2, unitId >> 8 & 0xFF); EEPROM.write(3, unitId & 0xFF); EEPROM.write(4, notunitId >> 24 & 0xFF); EEPROM.write(5, notunitId >> 16 & 0xFF); EEPROM.write(6, notunitId >> 8 & 0xFF); EEPROM.write(7, notunitId & 0xFF); Serial.print("Generated new unitId: "); Serial.print(unitId, HEX); } Serial.println(); // if (digitalRead(DEBUG_PIN) == LOW) { if (digitalRead(DEBUG_PIN) == HIGH) { DEBUG = true; Serial.println("Debug mode detected, transmitting in faster"); sleep_total = 24 / 8; //Must be a multiple of 8 (watchdog timer) } else { DEBUG = false; sleep_total = 72 / 8; //Must be a multiple of 8 (watchdog timer) } Serial.print("SleepTime="); Serial.println(sleep_total); if (DEBUG) { Serial.println("Sensor model,status,Humidity (%),Temperature (C),Time (ms),mV VCC"); } } // setup void loop() { static byte msgA[VW_MAX_MESSAGE_LEN]; //array of bytes to send, lib max is VW_MAX_MESSAGE_LEN bytes static unsigned int msgCnt = 0; //simple counter so receiver knows when it's part of same burst unsigned int chksum, mV, battmV; byte cnt, i; uint32_t start, stop; int chk; // Get ready to take a measurement wakeup(); // READ DATA digitalWrite(STATUS_PIN, HIGH); // Read the temp from the sensor chk = DHT.read22(DHT22_PIN); if (DEBUG) { Serial.print("DHT22, \t"); switch (chk) { case DHTLIB_OK: Serial.print("OK,\t"); break; case DHTLIB_ERROR_CHECKSUM: Serial.print("Checksum error,\t"); break; case DHTLIB_ERROR_TIMEOUT: Serial.print("Time out error,\t"); break; default: Serial.print("Unknown error,\t"); break; } } // if (chk != DHTLIB_ERROR_CHECKSUM) { // No point wasting energy on sending bad data if (chk == DHTLIB_OK) { // No point wasting energy on sending bad data chksum = 0; cnt = 0; msgCnt++; msgA[cnt++] = 1; chksum += msgA[cnt - 1]; // Sensor type=1=temperature/humid msgA[cnt++] = 2; chksum += msgA[cnt - 1]; // Protocol format=2 msgA[cnt++] = unitId >> 24; chksum += msgA[cnt - 1]; msgA[cnt++] = unitId >> 16 & 0xff; chksum += msgA[cnt - 1]; msgA[cnt++] = unitId >> 8 & 0xff; chksum += msgA[cnt - 1]; msgA[cnt++] = unitId & 0xff; chksum += msgA[cnt - 1]; msgA[cnt++] = msgCnt >> 8; chksum += msgA[cnt - 1]; msgA[cnt++] = msgCnt & 0xff; chksum += msgA[cnt - 1]; mV = readVcc(); // input power battmV = mV / 1024 * analogRead(0); // Battery power, separate wire before regulator, must be less than vcc! msgA[cnt++] = mV >> 8; chksum += msgA[cnt - 1]; msgA[cnt++] = mV & 0xff; chksum += msgA[cnt - 1]; msgA[cnt++] = battmV >> 8; chksum += msgA[cnt - 1]; msgA[cnt++] = battmV & 0xff; chksum += msgA[cnt - 1]; msgA[cnt++] = chk; chksum += msgA[cnt - 1]; // send status also msgA[cnt++] = (int)(DHT.temperature * 10) >> 8; chksum += msgA[cnt - 1]; msgA[cnt++] = (int)(DHT.temperature * 10) & 0xff; chksum += msgA[cnt - 1]; msgA[cnt++] = (int)(DHT.humidity * 10) >> 8; chksum += msgA[cnt - 1]; msgA[cnt++] = (int)(DHT.humidity * 10) & 0xff; chksum += msgA[cnt - 1]; msgA[cnt++] = chksum >> 8; // suppose to have built in checksum, still adding one here in case some other library is used msgA[cnt++] = chksum & 0xff; // Serial.println("Sending data"); // send 3 times back 2 back for (i = 0; i < 3; i++) { vw_send((uint8_t *)msgA, cnt); vw_wait_tx(); delay(random(20) * 100); } } // if status isn't checksum err digitalWrite(STATUS_PIN, LOW); // DISPLAY DATA stop = micros(); if (DEBUG) { Serial.print(DHT.humidity, 1); Serial.print(",\t"); Serial.print(DHT.temperature, 1); Serial.print(",\t"); Serial.print((stop - start) / 1000); Serial.print(",\t"); Serial.print(mV); Serial.print(",\t"); Serial.print(battmV); Serial.println(); Serial.print("Bytes sent: "); for (i = 0; i < cnt; i++) { if (msgA[i] < 16) Serial.print('0'); Serial.print(msgA[i], HEX); Serial.print(' '); } Serial.println(); // Serial.print("Sleeping "); // Serial.print(SleepTime); // Serial.println(" seconds"); } // if (chk == DHTLIB_ERROR_CHECKSUM) { // delay(2500); // need to wait at least 2 sec before trying again // } else { Serial.flush(); //to allow serial to finish printing digitalWrite(STATUS_PIN, LOW); //Kill stuff to save power prepForSleep(); digitalWrite(DHT22_POWER_PIN, HIGH); // Serial.print("Start sleeping ");Serial.print(SleepTime);Serial.println(" seconds"); sleep_count = 0; // Start at 0 cycles while (sleep_count <= sleep_total) { if (sleep_count + 1 == sleep_total) { //getting close, warm up the sensor digitalWrite(DHT22_POWER_PIN, HIGH); } goToSleep(); // The watchdog will increase sleep_count } // } digitalWrite(STATUS_PIN, HIGH); start = micros(); }

Clock system

It's a clock challange open to make the ultimate clock that I joined (please go there and vote). Since it been a while I feel it's time to write down something about what I'm up to in regards to it.
I looked around a lot trying to figure out some new way to present the time but it's not that easy. I was thinking on things like a bookshelf, Domino 9, gear clock, rolling ball, Propeller clock and many many more but whatever I thought about it was already done a thousand times.
I talked to a friend for ideas and he suggested to attack the backend instead. The plan is to make a clock that is modularized. It has a base with the smarts in it. Then you plug in a presentation module on top to show the time. In the base you have holes/slots where you can plug in modules for atomic clock, GPS time, ntp over wifi (both receiving and broadcasting), your smartphone, radio, audio and so on.
The units communicate over i2c/spi bus with some defined protocol so that you can plug in things and it just discovers it and starts using it.
Now the first version will be some 3D printed base with modules that plug together. For display it can be a simple 7SEG display or analog clock that is just put on top.

Light following robot

I joined the Ottawa Hacker Challange where you get a mystery sensor and this time it was a light sensor that need to be used.
For some time I wanted to make a simple robot and after watching lots of line following robots I now decided to make a light following robot.
I got a basic chassis

and the plan is to put two servos on top with the light sensor on. They then sweep around, find the brightest direction and go towards the light. With that I can have a light source hanging in front of it and it will follow it, at least that's the plan.
I added some hardware to read the encoder wheels

 to be able to control the direction and a I2C based LCD to show some numbers.

Got it to partly work but the motors are so weak and unbalanced that when I go full speed on one and 60% on the other it still can't go straight and when I go below 60% it stops completely.
While pondering  on what to do I passed by a thrift store and found a simple radio controlled hummer that I bought for $10.

The default function is binary, it's full speed forward or back and full tilt left or right so it's limited but I'm not interested in that part, I did go for the chassis. A single motor that I can control the speed on, replace the full tilt servo with one I can control with better precision. Add the sensors and so on and I have something that might work.
So far I only managed to rip out the provided electronics and put in my servo but I'm not sure if it's strong enough.

Update1:
Added the controller and got it to move around. It is moving a little at 25% and is to fast at 100%.
Steering works but is somewhat limited, no more then 20 degrees left and right (=total of 40) but it was like that before I changed it so it's not my mod that caused it.

What's left now is to figure out how to mount all parts and some programming. May need to add some kind of remote control to stop/start it or it will drive around at some predefined speed all the time.

Kinetic Lance - completed version

Now when it's completed I do a new follow up on my previous post on how what to make with a proximity sensor.


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).


After working on it for a while I have now managed to get everything together and working. Did some minor changes but over all it works better than expected.

From the top - component list
* Lance from the $$ store
* Long breadboard
* 2xAAA battery holder (inside the handle)
* on/off switch
* DC-DC Booster to convert 2.4V to 5V
* Arduino Pro 5V 328 16MHz
* 2x74HC595 shift register
* 1xULN2803 driver
* 5 RGB LEDs
* 4x7SEG display, Common Cathod
* Buzzer to make some noise
* 9x66.5 ohm resistors (58-100 probably works fine)
* 1x10K ohm resistor
* 5x330ohm resistor
* tcrt5000 sensor
* some wires

The Schematic for it, the battery and dc-dc is missing and using common anode RGB LEDs could been better (use driver IC instead of shift register) but now i had common cathode ones at home so that's what I used:

After figuring out where to put everything and solder all the wires the assembly was done.

The programming was next step and after changing around things I managed to get it to work the way I want it - here is a short demo

The code contains interrupt timer controlled driver for the digits using SPI to send it to the shift registers, just load an array with the numbers you want to display and forget about it. I'm happy with the way that part of the code worked out and will probably use it else were if I need it some other time.
The rest is just some logic to count points and make the RGB LEDs flash.


Version - 0.5 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 * v0.5 new board, more RGB LEDs, buzzer */ // SPI pins #define DATA 11 #define CLOCK 13 #define LATCH 8 // #define BUTTON A3 // What pin a button is on #define SENSOR 0 // what analog port the sensor is on #define BUZZER 10 // make some noise #define COLON 2 #define APOS 3 //What pin the RGB leds are on, only one should be on at any given time byte RGBleds[]={4,5,6,7,9}; // 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 NO7SEG 4 volatile byte LEDBuffer[NO7SEG]={20,20,20,20}; volatile byte LEDassembly[NO7SEG]={20,20,20,20}; volatile byte currentLED=0; volatile byte RGBled=0; volatile byte currentRGB=0; volatile long beepend; volatile boolean beepon=false; volatile boolean debug=false; #define RED 8 #define GREEN 4 #define BLUE 2 #define BLACK 0 #define WALK 300 #define NORGBs 5 byte RGBassembly[NORGBs]={0,0,0,0,0}; byte RGBBuffer[NORGBs]={0,0,0,0,0}; //volatile byte RGBBuffer[NORGBs]={RED,GREEN,BLUE,GREEN,RED}; //volatile byte RGBBuffer[NORGBs]={RED,RED,RED,RED,RED}; //volatile byte RGBBuffer[NORGBs]={GREEN,GREEN,GREEN,GREEN,GREEN}; //volatile byte RGBBuffer[NORGBs]={BLUE,BLUE,BLUE,BLUE,BLUE}; int mode=BLACK,nextmode,walkspeed=100; byte currWalkRGB=0,walkdir=1; long endmode,nextwalk; //TODO - intensity for the RGBled //Handle all RGB leds void updateDisplay(){ digitalWrite(RGBleds[currentRGB],HIGH); // Kill whatever is currently showing currentRGB++; // move on to next RGB LED if (currentRGB==NORGBs){currentRGB=0;} // If to far, start over currentLED++; //Move on to next digit if (currentLED==NO7SEG){currentLED=0;} // If to far, start over //Update the 4x7SEG display + what color to show on the RGB digitalWrite(LATCH,LOW); SPI.transfer(((1<<(3-currentLED))<<4)+RGBBuffer[currentRGB]); SPI.transfer(LEDpattern[LEDBuffer[currentLED]]); digitalWrite(LATCH,HIGH); //Turn on the RGB digitalWrite(RGBleds[currentRGB],LOW); } // updateDisplay /*****************************************************************/ void setup() { Serial.begin(115200); Serial.println("kinetic lance"); pinMode(DATA,OUTPUT); pinMode(CLOCK,OUTPUT); pinMode(LATCH,OUTPUT); pinMode(BUZZER,OUTPUT); digitalWrite(BUZZER,LOW); 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); for (int i=0;i<5;i++){ pinMode(RGBleds[i],OUTPUT); digitalWrite(RGBleds[i],HIGH); } //Make some startup noise digitalWrite(BUZZER,HIGH); delay(100); digitalWrite(BUZZER,LOW); delay(100); digitalWrite(BUZZER,HIGH); delay(100); digitalWrite(BUZZER,LOW); delay(100); digitalWrite(BUZZER,HIGH); delay(100); digitalWrite(BUZZER,LOW); //Show off the LEDs for (int j=0;j<2;j++){ for (int i=0;i<5;i++){ digitalWrite(RGBleds[i],LOW);delay(100);digitalWrite(RGBleds[i],HIGH); } for (int i=4;i>=0;i--){ digitalWrite(RGBleds[i],LOW);delay(100);digitalWrite(RGBleds[i],HIGH); } } //To start in debug mode - cover the sensor at power on if (analogRead(SENSOR)<200){debug=true;} LEDBuffer[0]=20; // space LEDBuffer[1]=20; // space LEDBuffer[2]=20; // space LEDBuffer[3]=0; // mode=WALK; // Setup timer interrupt to update the LED Timer1.initialize(2000); // Run every .002 seconds Timer1.attachInterrupt(updateDisplay); } // setup() /*****************************************************************/ void loop() { int proxval,buttonval,sleep,i; static int pointsflag=0,points=0,pointlimit=400,hitflag=0,hitlimit=50; proxval = analogRead (SENSOR); if (digitalRead(BUTTON)==0 || debug){ // 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(); Timer1.stop(); LEDBuffer[0]=LEDassembly[0]; LEDBuffer[1]=LEDassembly[1]; LEDBuffer[2]=LEDassembly[2]; LEDBuffer[3]=LEDassembly[3]; Timer1.resume(); // interrupts(); //Need to make pattern so it can be on/off specific time if (beepon) { if (millis()>beepend){ digitalWrite(BUZZER,LOW); beepon=false; } } //Flash the RGB LEDs switch (mode) { case BLUE: if (millis()>endmode){ mode=nextmode; }else{ for (i=0;i<NORGBs;i++) RGBBuffer[i]=BLUE; } break; case GREEN: if (millis()>endmode){ mode=nextmode; }else{ for (i=0;i<NORGBs;i++) RGBBuffer[i]=GREEN; } break; case RED: if (millis()>endmode){ mode=nextmode; }else{ for (i=0;i<NORGBs;i++) RGBBuffer[i]=RED; } break; case BLACK: // if (millis()>endmode){ // mode=nextmode; // }else{ for (i=0;i<NORGBs;i++) RGBBuffer[i]=BLACK; // } break; case WALK: if (millis()>nextwalk){ if (walkdir==1){ currWalkRGB++; if (currWalkRGB==NORGBs-1)walkdir=-1; }else{ currWalkRGB--; if (currWalkRGB==0)walkdir=1; } nextwalk=millis()+walkspeed; for (i=0;i<NORGBs;i++){ if (i==currWalkRGB){ RGBBuffer[i]=BLUE; }else{ RGBBuffer[i]=BLACK; } } } break; } // switch //Check how close it is if (proxval<=hitlimit){ // It's a hit - remove some points if (hitflag==0) {points-=10;if (points<0){points=0;}} // digitalWrite(COLON,HIGH); hitflag=1; if (!debug) digitalWrite(BUZZER,HIGH); beepend=millis()+1500; beepon=true; endmode=millis()+1500; nextmode=WALK; walkspeed=200; mode=RED; // delay(100); } else if (proxval<=pointlimit && hitflag==0){ if (pointsflag==0) {points++;if (points>9999){points=9999;}} if (!debug) digitalWrite(BUZZER,HIGH); beepend=millis()+100; beepon=true; pointsflag=1; // RGBled=GREEN; endmode=millis()+500; nextmode=WALK; walkspeed=200; mode=GREEN; delay(10); } else { // digitalWrite(COLON,LOW); if (millis()>endmode){ hitflag=0; pointsflag=0; nextmode=WALK; endmode=millis()+1000; mode=WALK; walkspeed=200-((1024-proxval)/4); } }; } // loop

(photo credit to my shy friend)

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.

Got 2xAAA in the handle

Note the light inside on the Buck-up and arduino

Backside of the board