A few weeks back i was browsing ebay, as i do, and found some ultrasonic distance sensors for about €4 delivered. (I have no direct link as the auction has expired but searching for SR04 will bring up any amount of similar units.) I had no plan for them immediately but I bought some just to have anyway. It was only after they came that it struck me that a way of remotely monitoring the oil level would be  a nice project.

The units are very simple to use. There is 4 pins: 5v, GND, Trigger and Echo. By applying a 10uS pulse to the trigger pin you activate the sensor to take a distance reading. The sensor replies on the echo pin with a pulse that is as long as the time taken for the sound wave to travel to the distant object and return to the sensor. Knowing the speed of sound we can then calculate the distance.

This is the module as it arrives with its 4 pin header soldered in.

For the tank gauge i was planning on permanently installing the sensor so i desoldered the header and soldered in some of my 4 core alarm cable, this stuff is great to have around for projects!

The other end was passed through the side of a project box i had lying around with a knot tied to stop the wire being pulled from the board if someone got a little rough with it once assembled. To install the sensor on the tank i chose to put it on the tank cap, although it leaves it slightly vulnerable when getting the tank filled being able to install it indoors without trying to sit on the tank outside mounting it is a big advantage! With two suitably sized holes drilled the sensor was hotglued into place

And then the project box hotglued over that. The project box is also secured with two screws – its not going anywhere!

And the cap refitted to the tank. The cable is ran across the follows the existing heating pipes (insulated in the background) up into the apartment.

My intention now is to get the sensor connected the network so i can read the data with my existing heating controller without too much trouble. I am still waiting for my ethernet modules to arrive as i’m not wasting one of my (expensive) W5100 boards on this project so for now I have made something slightly lower tech.

Using code i modified from the Tronixstuff site (http://tronixstuff.wordpress.com/2011/11/28/tutorial-parallax-ping-ultrasonic-sensor/) we can read the distance from the sensor to the oil level at display it via serial. Using my old dip stick I measured it at about 87cm so not bad at all! Also displayed is the level expressed as a percentage. Using my stick I estimated the distances for empty and full and hardcoded them.

int empty = 119;
int full = 19;

The distance is then mapped to give the percentage

 level = map(distance, full, empty, 100, 0);

For the display I am temporarily using a cheapo analogue 5v meter. Its driven by using a PWM pin on the arduino and getting the required output voltage  by mapping the distance variable to the PWM range of 0-255. The above serial printout shows the calculated value for the PWM.

gaugeVoltage = map(distance, full, empty, 255, 0);

The complete code is as follows. It’s a bit messy as I copied the code from Tronixstuff out of laziness and added to it as I needed to! For the final install the code will need to be integrated with the current code for turning the heating on and off so a single controller will be doing both.

int trig = 8;
int echo = 9;
int gaugePin = 11;
int empty = 119;
int full = 19;
int distance;
int level;
int gaugeVoltage = 127;
unsigned long pulseduration=0;
void setup()
{
pinMode(trig, OUTPUT);
pinMode(gaugePin, OUTPUT);
pinMode(echo, INPUT);
Serial.begin(9600);
}
void measureDistance()
{

digitalWrite(trig, LOW);
delayMicroseconds(10);

// now send the 10uS pulse out to activate Ping)))
digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW);
// finally, measure the length of the incoming pulse
pulseduration=pulseIn(echo, HIGH);
}
void loop()
{
// get the raw measurement data from Ping)))
measureDistance();

// divide the pulse length by half
pulseduration=pulseduration/2;

//convert to centimetres.
distance = int(pulseduration/29);
level = map(distance, full, empty, 100, 0);
gaugeVoltage = map(distance, full, empty, 255, 0);
// Display on serial monitor
Serial.print("Distance - ");
Serial.print(distance);
Serial.print("cm. Level - ");
Serial.print(level);
Serial.print("% ");
Serial.println(gaugeVoltage);
analogWrite(gaugePin,gaugeVoltage);
delay(500);
}

Hardware wise I needed a way of allowing the tablet to turn on the relay. I couldn’t use bluetooth as the tablet didn’t have it and it would be too unreliable anyway. The next choice for getting an output would be the vibration motor but again, the tablet didn’t have one. All that i was left with was using the speaker output to trigger the heater. To do this i had the software (detailed later) output two tones. Depending on the frequency of this tone we would know if the heating should be on or off. The speaker output is passed into an op-amp used as a comparator to give a nice 5v square wave that is input into an Attiny85 via one of the Boards.ie keyrings/dev boards i had made up. The attiny measures the incoming pulse and decides whether to turn the output on or not. The solid state relay can be directly controlled with an attiny pin. Here you can see the hardware during the prototype stage.

The 5v power adapter from the old heating setup is reused to power the attiny board and I used 4 core alarm wire to send 5v to the tablet mounted on the wall , it also has the ground and speaker output connections. The alarm wire passes through the back of the tablet and the wires soldered directly to points on the board. This means the tablet is constantly on charge, it has been live for six weeks now without any problems.

The user interface for the controller was made in app inventor. From the main screen we have a number of different features

• An indicator to show whether the heating is on or not
• A button to manually turn the heating on
• The current/next heating time
• The current weather graphic
• The current weather text (tapping will cycle between today, tonight and tomorrows weather)
• The current temp

Tapping the weather icon will bring up detailed weather information.

Also on the main screen are AA and camera icons. The camera icon will bring up and image from the wifi camera mounted in our daughters bedroom, she’s 3 so needs quite a lot of  ”tucking in” at night so it’d nice to be able to check on her while passing the timer.

The AA button will display the traffic conditions relevant to our commutes if any are available. There wasn’t anything exciting when i had taken this pic (typically!)

The weather text for the main screen is parsed from the met eireann site. The icons and detailed weather are parsed from Meteo Europ although this is formatted and parsed by a script on this server as it was easier than doing it from within the android. Similarly the AA report comes from the AA Roadwatch site and is parsed on the server. These were done using PHP the same way as i posted about before.

This app is actually nothing more than a front end for the awesomely powerful Tasker App. Tasker is used to check the google calendar and handles the downloading of the images from the camera. The heating app just checks the contents of a file written by tasker to know if the heating should be on. Tasker was also used to make the app that pops up set the heating on manually. What this app does is creates a new calendar entry for the specified amount of hours. The best thing is that by installing this app on any android phone with permissions to write to this calendar the heating can be turned on remotely from anywhere.

Ideally I’d love to get in somewhere small where I can get stuck in, and I find myself drawn to learning PCB layout and design but I am open to anything relevant and interesting. I’m based in the east, so I would be looking for Dublin/Wicklow/Wexford/Carlow area. I’m a mature student with a wife and 3 year old so moving away for 6 months currently isn’t an option.

I have an engineering science degree in electronics and this placement is part of my electronic and computer engineering masters.

If  anyone knows of any companies willing to take on someone I’d love to hear about them. I can be emailed at blog@chet.ie

Thanks!

Inside theres a single sided PCB with 12 SMD RGB LED’s on. The LED’s are grouped into four groups of three LED’s in series. Each group using its own set of resistors for each colour. The 12v input passes through a diode to protect against reverse polarity. A 7805 regulator is used to provide the 5v needed for the IR receiver and the unmarked 8 pin control IC. The PWM output from the controller for each colour passes through a 2k2 resistor into a sot-23 J3Y NPN transistor which controls the 12V supply to the LED’s

The pinout for the IC is below, the unused pin is tied to GND so i’m not sure which is the actual ground pin. If anyone has any idea what the IC is let me know.

To read the IR codes it used an arduino with Ken Shirriffs IR library connected to the output of the IR receiver.

The remote used the NEC protocol which is very common for these cheapo slim remote controls.

The codes are in the table below, matching the layout of the remote itself.

So far i haven’t done anything further with it as i haven’t decided what to do. The easiest way to add control to it is to use the remote codes that we now know and send them with an arduino or similar. I think what i will probably do is replace the existing IC with an attiny85, the pinout is different but you can solder wires to the pads and put the attiny elsewhere. To keep the existing IR remote the arduino library would need modifying to work with the attiny and to match the functions it would be necessary to put an oscilloscope of the output pins and measure the PWN duty cycle to get the same colours. With the unused pin you could add bluetooth and/or USB serial control easily.

I’ll post if i ever decide what to do with it!

A popular method of controlling a switch with a microcontroller is to replace it with a transistor. As i didn’t want to interfere with the normal operation of the switch i traced back the pads on the switch to two vias on the PCB which allowed me to solder some thin wires in to attach the transistor to. To test i brought out GND and the base wire and reassembled. Running some simple code to toggle the switch let me cycle through the times and turn it off as expected.

While deciding what to do next i was experimenting with the controller and trying to see if there was any information being passed from the (marked) UART on the board. I think i overstressed the ribbon cable attaching the two PCB’s at this point and caused a short somewhere as the controller died on me and i couldn’t find a fault or come up with any easy solution to make it work.

Typically this was just coming up on the weekend and it was getting cold! As a quick fix i installed a mains switch for the heating but it quickly became clear that that was not going to work as a long term solution. The original controller was nothing more than a relay connecting the live of the mains to the heating boiler, nothing too complicated about replicating that right?

I knew my brother had a spare solid state relay which simplified switching the mains as i could run that directly from a 5v output. I dug into stash of bits to use and came out with an arduino nano, a bluetooth serial module, an i2c real time clock module and an i2c 16×02 lcd.

The most awkward thing to code was a menu system for setting the heating times, so i didn’t I hardcoded the times and put in a manual override via bluetooth. I picked up a double gang box and blanker in the local hardware and mounted the LCD in it. As soon as my wife seen it she told me i wasn’t allowed “put that jumble sale of a thing on the wall” :/ I quite liked the homemade look!

To power the controller i took apart an old USB charger and mounted that in a second two gang box in the hall cupboard. I kept the usb connection as i already had the male connector from testing the USB boost modules In this pic you can see the mains come in and go back out via the solid state relay and also the 5v power supply going out by the thin red and black wires. The white wire is from the controller to the relay.

The controller itself was mounted on the inside of the door for easy access but where my wife didn’t have to look at it!

Over the next few days i tweaked the software to add extra features, the hardest to get working correctly was the +1/2/3 hour modes, especially as i had to wait around to see if it was definitely working! Here is a screenshot from the final android (app inventor) app, it uses my usual method of sending single bytes to perform each action. Along with sending serial commands the controller also outputs it current on/off status which is read by the phone and changes the state of the large power icon in the middle which allows you to quickly connect and check if the heating is on or not.

Here is the complete arduino code for the controller

/*
Chet.ie Heating Controller Sketch
*/

/*
Mode codes:
a - auto (timer)
f - manual off
o - manual on
1 - on for one hour, then auto
2 - on for two hours, then auto
3 - on for 3 hours, then auto
*/
#include <SoftwareSerial.h>
#include "Wire.h"
#include <LiquidCrystal_I2C.h>

#define DS1307_I2C_ADDRESS 0x68
#define FIRSTON 4
#define FIRSTOFF 9
#define SECONDON 16
#define SECONDOFF 22

SoftwareSerial mySerial(10, 11); // RX, TX

boolean heatingOn = false;
int mode = 'a';
int ethstatus = 0;
int relayPin = 13;
int offHour, offMin = 0;
int usePlustime = 0;
int lastmode = 0;
LiquidCrystal_I2C lcd(0x27,16,2); // set the LCD address to 0x27 for a 16 chars and 2 line display
// Convert normal decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
return ( (val/10*16) + (val%10) );
}

// Convert binary coded decimal to normal decimal numbers
byte bcdToDec(byte val)
{
return ( (val/16*10) + (val%16) );
}

// Gets the date and time from the ds1307
void getDateDs1307(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
// Reset the register pointer
Wire.beginTransmission(DS1307_I2C_ADDRESS);
Wire.write(0);
Wire.endTransmission();

Wire.requestFrom(DS1307_I2C_ADDRESS, 7);

// A few of these need masks because certain bits are control bits
*second = bcdToDec(Wire.read() & 0x7f);
*minute = bcdToDec(Wire.read());
*hour = bcdToDec(Wire.read() & 0x3f); // Need to change this if 12 hour am/pm
*dayOfWeek = bcdToDec(Wire.read());
*dayOfMonth = bcdToDec(Wire.read());
*month = bcdToDec(Wire.read());
*year = bcdToDec(Wire.read());
}

void lcdOutput(byte second,
byte minute,
byte hour,
byte dayOfWeek,
byte dayOfMonth,
byte month,
byte year)
{
lcd.setCursor(0,0);
if(mode=='o'){
lcd.print("on ");
}
else if(mode=='f'){
lcd.print("off ");
}
else if(mode=='1'){
lcd.print(" +1 ");
}
else if(mode=='2'){
lcd.print(" +2 ");
}
else if(mode=='3'){
lcd.print(" +3 ");
}
else {
lcd.print("Aut ");
}

if (hour<10)
{
lcd.print(" ");
}
lcd.print(hour, DEC);
lcd.print(":");
if (minute<10)
{
lcd.print("0");
}
lcd.print(minute, DEC);
lcd.print(":");
if (second<10)
{
lcd.print("0");
}
lcd.print(second, DEC);
lcd.print(" ");
if(heatingOn == true)
{
lcd.print("ON ");
}
else
{
lcd.print("OFF");
}
lcd.setCursor(0,1);

if(usePlustime){
lcd.print(" ON UNTIL ");
if (offHour<10)
{
lcd.print("0");
}
lcd.print(offHour, DEC);
lcd.print(":");
if (offMin<10)
{
lcd.print("0");
}
lcd.print(offMin, DEC);
lcd.print(" ");
}
else{
lcd.print(" ");

switch(dayOfWeek){
case 1:
lcd.print("Sun");
break;
case 2:
lcd.print("Mon");
break;
case 3:
lcd.print("Tue");
break;
case 4:
lcd.print("Wed");
break;
case 5:
lcd.print("Thu");
break;
case 6:
lcd.print("Fri");
break;
case 7:
lcd.print("Sat");
break;
}

lcd.print(" ");
lcd.print(dayOfMonth, DEC);
lcd.print("/");
lcd.print(month, DEC);
lcd.print("/20");
lcd.print(year, DEC);
}
}

void setup()
{
pinMode(relayPin, OUTPUT);
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
Wire.begin();
mySerial.begin(9600);
lcd.init(); // initialize the lcd
lcd.backlight();
lcd.setCursor(0,0);
lcd.print(" www.Chet.ie"); // print text and move cursor to start of next line
lcd.setCursor(0,1);
lcd.print("Heating Control");
delay(5000);
lcd.clear(); // clear LCD screen
}

void loop()
{

if (mySerial.available() > 0)
{
// get incoming byte:
mode = mySerial.read();
}
byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;
getDateDs1307(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);

if((usePlustime == 1)&&(hour == offHour)&&(minute == offMin))
{
usePlustime = 0; //not using plus time anymore
mode=lastmode; //switch back to auto mode
}

if((mode=='a')){
usePlustime = 0;
lastmode=mode;
if((hour>=FIRSTON)&&(hour<FIRSTOFF)){
heatingOn = true;
}
else if((hour>=SECONDON)&&(hour<SECONDOFF)){
heatingOn = true;
}
else{
heatingOn=false;
}
}

else if((mode=='o')){
usePlustime = 0;
heatingOn=1;
lastmode=mode;
}

else if((mode=='f')){
usePlustime = 0;
heatingOn=0;
lastmode=mode;
}

else if((mode=='1')&& (lastmode!='1')){
offHour = (hour+1);
offMin = minute;
usePlustime = 1;
heatingOn=1;
lastmode=mode;
}

else if((mode=='2')&& (lastmode!='2')){
offHour = (hour+2);
offMin = minute;
usePlustime = 1;
heatingOn = 1;
lastmode=mode;
}
else if((mode=='3')&& (lastmode!='3')){
offHour = (hour+3);
offMin = minute;
usePlustime = 1;
heatingOn = 1;
lastmode=mode;
}

if(offHour>=24){
offHour=offHour-24;
}

lcdOutput(second, minute, hour, dayOfWeek, dayOfMonth, month, year); // print to LCD screen
mySerial.println(heatingOn);
if(heatingOn == true)
{
digitalWrite(relayPin, HIGH);
}
else if(heatingOn == false)
{
digitalWrite(relayPin, LOW);
}
delay(1000);
}

 

The android APK can be downloaded here:

This has been replaced now (v2 post coming soon) and due to my phone dying i have no pics of the internals, it was only temperarily put together on a breadboard anyway. If you have any questions on the wiring jut ask in the comments.

The phone requests server/file.php?registration=<reg number> Where the registration number is first read into the variable ‘reg’

$reg = $_REQUEST['registration'];

The content is requested and then saved into ‘html’ using file_get_contents()

$html = file_get_contents('https://www.cartell.ie/ssl/servlet/beginStarLookup?registration='.$reg);

At this point we have the entire HTML response from the website stored (think of it as the “view source” content that you would see) in html.

To extract the relevant information we need to find a string of text in the source which identifies the start of the code containing the information we want, its best to try and ensure this code is unique in the file to save on any issues. In the case of the cartell script the start of the data table is easily and uniquely identified by the use of the vehicle-description class. We mark this as our start point.

$start = strpos($html,'<table class="vehicle-description">');

The end is is simply the next closing of the table tag, </table> 

$end = strpos($html,'</table>',$start) + 8;

By default we will be marking the position of the start of the searched string, if we want to also include this string we can move the position forward by adding the integer number of characters in the string, in our case this is 8, hence the ‘+8′ in the code. This may or may not be necessary, depending on what you wish to do.

With the start and end positions in hand we can extract the code which we need.

$table = substr($html,$start,$end-$start);

Finally we print out the resulting code using the echo command.

echo $table;

The complete code for this script is:

<?php

$reg = $_REQUEST['registration'];

$html = file_get_contents('https://www.cartell.ie/ssl/servlet/beginStarLookup?registration='.$reg);

$start = strpos($html,'<table class="vehicle-description">');

$end = strpos($html,'</table>',$start) + 8;

$table = substr($html,$start,$end-$start);

echo $table;

?>

Optionally we can run a find and replace on this to change anything we like by using the str_replace() function.

$table = str_replace('<replace this>','<with this>',$table);

So there you have it, like i said, it’s simple but can prove very useful for extraction data for apps or other projects.

My brother has a solar panel on the roof of his house which is used to charge a 12v battery which runs the equipment in his attic, the routers etc. There is a proper solar regulator/battery charger which keeps the battery topped up. The problem is that when the sun isn’t shining (which happens a lot here!) the battery drains and eventually the voltage drops. He had bought a switch mode power supply that would take over from the solar regulator but he wasn’t sure how to wire it up to work as he wanted, which was to have the power supply on only when it was need so there would be no power wasted.

This is what i came up with for him.

At the heart of it ia an ATmel attiny85, this measures the output of the battery through a voltage divider (to keep the attiny input voltage below 5v) If it drops below a certain value, say 11.5v, it will turn on a solid state relay which controls the mains feed to the 12v power supply. Once the battery voltage reaches an acceptable level the relay is switched off and the external devices continue to be powered from the battery. The battery and power supply are isolated from one another using two diodes to prevent current from flowing backwards into the power source not being used. I used MUR1560 diodes with a voltage drop of 0.4v as they are what i had to hand. While this means the output is 0.4v lower than we need both the power supply and battery charger can be adjusted to a higher voltage so the final output will be as required. Also onboard is a 7805 voltage regulator which powers the attiny85.

The attiny is running the arduino bootloader and the code is posted below.

int onVoltage = 11500; //define min allowed voltage (mV) - switch psu on
int offVoltage = 11800; //define voltage to turn psu off (mV)
int timeDelay = 5000; //define delay between checks (ms)

int rangeTop = 15681; //measured input when voltage divider voltage is 5000mV

int voltageinPin = 3; //attiny85 pin 2, connected to voltage divider
int relayPin = 2; //attiny85 pin 5, connected to relay

int voltagein = 0; //initialise variable to hold read voltage

void setup()
{

pinMode(relayPin, OUTPUT);

}

void loop()
{

voltagein = map(analogRead(voltageinPin),0, 1023, 0, rangeTop); //map pin value from 0 to max voltage

if(voltagein <= onVoltage){

digitalWrite(relayPin, HIGH); //turn relay on

}

else if(voltagein > offVoltage){

digitalWrite(relayPin, LOW); //turn relay off

}

delay(timeDelay);

}

Due to the tolerances of the resistors it is best to measure the input voltage and adjusting it until the voltage divider gives an output of 5v. You can set your voltage divider to give yourself a large margin here, for mine the largest input voltage we can take is over 15v, this keeps the actual pin input voltage well below the 5v maximum. While you might loose some precision here its not needed anyway.

Power comsumption was 20mW, half of which was from the voltage divider and then there is also wasted energy in the diodes so there is room to improve if needs be, in this case it was perfectly adequate!

Here is the details from the ebay auction:

To test the module i used my iTead OverLoad dummy load. This allows you to set a current and it will vary the load to maintain the current passing into it.

Here is the setup below. The OverLoad is powered from my Atten power supply(crocodile clips) with the output taken direct at the USB connector output. The output voltage is measured by my Philips PM2521 bench multimeter using the banana plug leads in the pic.

There was 3 things i wanted to test.

• How much current we could get with an outputof 5V
• How high of a voltage we can get out at the max rated 700mA
• The efficiency

Firstly, with no load the output voltage measured 5.5V at the max input of 4.4V. I lowered the input voltage all the way down and even at 0.2V it still showed 5.4V at the output. Only at 0.1V did it drop to 4.1V. Interesting but a bit useless with no load on it!

To measure the current with an output of 5V it was a case of setting the input voltage and adjusting the load until we had an output of 5V for all input voltages. Did we manage to get 700mA? No, but we got close. At 4.4V input we managed 670mA at 5V. At the other end of the scale with an input of 1v we managed 30mA at 5V.

The data is plotted below.

Now i wanted to see what voltage output could be got while maintaining 700mA output. This was simply a case of setting the OverLoad to 700mA and dropping the input voltage while recording the output voltage. For the 4.4V input there was an output of 4.89 volts which is within USB specs of 5V+/- 0.25V. However once we reach an input below 4.2V we fail below USB specs. I didn’t bother going below 2.5V input which gave an output of 2.1V.

Again, the data is plotted below.

The efficiency is calculated as Pout/Pin where Pin is the input power = input voltage x input current and Pout is output power = output voltage x output current.

The max efficiency was when the input voltage was highest which gave us a 84% efficiency rate, the lowest seen was 64%

Overall then its not a bad little module provided you’re not chasing high currents from it. One thing i didn’t check at the time was how noisey the output was, i will have to do that in the future.

As i knew running an arduino from 4.5V was on the low side i went looking for a dc-dc boost to up the voltage to something more useful. What i found was a module used for charging USB devices from voltages down as far as 3V. These are rated at 700mA so more than enough for what we’re running off them. The actual output voltage is 5.5V which is in the acceptable range for the arduino.

Having unsoldered the USB connector i added it to the car, powering only the arduino and i’m pleased to say it works perfectly. Even holding the motors in still (so at full load) the arduino doesn’t reset – result!

Also to note in the above picture is the jumper on the RX line, this is because you can’t program the arduino with a serial device attached so it’s used to disconnect the bluetooth module.

The android app side of things still needs tweaking and i hope to get to that soon.

The quality of the car is actually pretty nice so i was quite happy with it, the controller is a bit crappy but that isn’t important. Inside the car the circuit board has no COB (Chip On Board, the black blob you see on cheap mass produced electronic stuff) and its all through hole components, both of which make it a lot easier for hacking!

At the front there is a motor to control the steering, either fully on or off. At the back there is one motor driving the wheels, the rear motor has a choke to suppress rf interference, this is needed as you don’t want your controller not working as the motor spins up!

Flipping the board over we have one IC, a RX-2-G which is a reciever chip for this type of application although very little info is available on it from the usual sources. To the left of the chip is the circuity associated with the antenna. The TO-92 package transistors make up two H-bridge circuits, each using six transistors. H-bridges are used in motor control as the allow easy swapping of polarities on the motors so they can go backwards/forwards.

As i had no intention of keeping the controller, i didn’t need the RX-2-G but i did want to use the H-bridges so it was easies to desolder the clip and leave everything else in place. Tracing back the pins to the H-bridges i soldered wires onto the four pins the drive them. To control the motors all that is needed is to apply power to one of the pins for forwards, backwards, left and right.

Not forgetting my original dreams of having lights i disassembled the headlights, drilled them out and put some 5mm LEDs in. As space is a bit tight i soldered the resistors in line with LED’s and covered everything in heatshrink.

The car takes three AA batteries, giving a total of 4.5 volts. The arduino board i’m putting in is a 5 volt 16MHz nano which can work at 4.5 volts just fine. As mentioned space is tight so i had to remove all the presoldered headers from the arduino and the bluetooth module, fun! Excluding power and ground, six arduino pins are used, four for motor control, one for the lights and one for serial comms with the bluetooth module (we’re only receiving data, not sending too) Here it is with both boards in place.

After getting the arduino coded and phone app done (these will be covered in another post) the first test proved unsuccessful. When trying to steer the wheels or move the bluetooth module was turning off. It turned out that the inrush current of the motor was causing the voltage to drop lower than the module could take, but just for a split second. To combat this i soldered a 1000uF cap (the biggest i have) across the batteries to try smooth out the voltage and it worked, the module isn’t resetting now. I found a nice little home for it beside the front motor.

However when trying to move the forwards or backwards i.e. use the main motor the arduino is dropping out for a split second so obviously the voltage is still going that bit too low. Some further investigation is needed into just how low its dropping and what is needed to keep it up. I’ll update with any news.

Here is two pics showing a sneak at the app and the lights on and off.