The Refit is coming along

The last few days have been spent refitting and re-wiring the robot to accomodate the EZBV4 controller and the Arduino's and new power supply.

The robot is now 12V powered from one battery mounted below the main deck between the front wheels.  From there the power is routed to a fuse, and a switch and then to a DC-DC converter which provides 6V to another switch and is then routed to the EZBV4 and the Arduino's for computer power.  The 12V power is routed to the two motor controllers to control the steering motor and the drive motor.

Not the neatest wiring, but I am clearing it up as I go...

The EZBV4 controller wired to the motor controllers.

The original Hero Jr. Speaker mount.

Rewired the back panel for the 12v switch, the 6v switch, a USB port and the battery charging port.

Drive Motor

Drive motor controller.  Steering Motor and control in the background.

I have the original distance sensor, light sensor, IR sensor.

Original keypad and LED matrix.  All are being used in the new build.

Getting ready to put the rest of the skins on...

Hero Jr. Gets an Overhaul of all Wiring, Controls and gets Speech Recognition

I have been inactive for a while while rethinking the controls in the Hero Jr. Robot.
The large servo I had to turn the wheel was problematic in that it jittered when standing still under power and had a hard time with the load even though it was rated at a much higher capacity than that of the robot's weight.
I also had a few issues with the drive motor controllers.
So, in the end, I replaced them both, again.
Now, I have rewired the robot to meet the requirements of both motor controllers, and have a 12v battery system in place with a DC-DC 6v converter to power the function controllers.
Also, since adding an EZBV4 controller, I now have speech recognition enabled.
I am happy to say the basic motor controls are working, and here is a short video of that functionality.
I will detail all wiring and controls a little later this week.

There are still some commands that are not defined, but the vocabulary will grow.  I will also most likely change the voice level and add a nicer microphone.

I also have created a web app that will allow the control of the robot from my cell phone...more on that later as well.

Experimenting with the Arduino C Code

Sunday, March 20th, 2016

Today I am experimenting with the Arduino C Code to see what limitations I might have on creating libraries for different routines within the robot.

I wanted to create a few simple routines to report the status of different functions while the robot is active and also when in a self-test mode.

The first thing I created was an SOS mode where I can flash and L.E.D. (Light Emitting Diode) in the Morse Code for S.O.S. (the Distress Signal).  The S.O.S. was first introduced by Germany in 1905 as a distress signal adapted for Maritime Shipping.  Being German in origin, I doubt it actually stands for Save Our Ship, but that was a common English adaptation of the meaning.  It was likely adopted simply because the SOS are fast, easy, Morse Code symbols to generate (dot, dot, dot, dash, dash, dash, dot, dot, dot).

If you want to know more about Morse Code, there is plenty of information on Google.

So, getting an LED. to flash with an Arduino is not a difficult chore.  In fact, they have a blink program in the examples library that will make one flash if you just want a test program.  That is usually the most common program run.

What I wanted was a way to store a library of symbols and call them in code so that I used very little actual program space.

To make an LED blink, all you really need to do is connect one via a small breadboard with a resistor between ground and you are all set. Power the pin connected to your signal on the LED High and it will light up.  Most Arduino's have a built in LED on Pin 13, so I used that for this first test.

Looking at the code, we will set the Signal Pin to 13 with:

int _sp(13);

So, now the variable _sp means 'Use Pin 13' in the program.

Then in the Setup portion of the program, we make sure to set this pin to be an OUTPUT.  That means we will either give it 5 Volts or take the 5 Volts away.

  pinMode(_sp, OUTPUT);

Now that we have a variable describing what pin to give power to, we just need to tell the Arduino board when we want to give it power and in what kind of a pattern.  By setting the pin 13 High and Low we can give the 5 Volts or set it to 0 Volts (take the 5 Volts away).  This also means turning the LED ON (High, or +5 Volts) and turning the LED OFF (Low, or 0 Volts).  We can use a Delay in between these to leave the LED on or off for a certain amount of time.
Using a Delay command with a time in milliseconds (1000 milliseconds is equal to 1 second) will give the dots or dashes needed to have 3 short flashes and 3 long flashes and 3 short flashes again.

The first version of the program I came up with to test this theory was the following.

/*
 SOS Flash
 This is an experiment with pulse for an LED
 The aFlash will be turned into a library call.
 The SOS will be turned into a library call.
*/

// Set the signal pin that has the L.E.D
int _sp(13);

// the setup function runs once when you press reset or power the robot up.
void setup() {
// initialize signal pin as an output.
  pinMode(_sp, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {

//Do an SOS (...---...)
 _SOS();

}


void _SOS() {
/* Three short, Three long, Three short
 *  that is the SOS Signal (...---...)
 */
 int x;
 int y;
 for( x = 0; x < 3; x++) {
  for( y = 0; y < 3; y++) {
   if(x == 1) {
    _aFlash(800);
   }
   else {
    _aFlash(250);
   }
  } //End Y Loop
  delay(1000);
 } //End X Loop
 delay(2000);
}

//Sub for a flash with delay time between high and low as variable.
int _aFlash(int _dTime) {
     digitalWrite(_sp, HIGH);
     delay(_dTime);
     digitalWrite(_sp, LOW);
     delay(_dTime);
     return 0;
}


If you read through this, it is not really too complicated.
After setting _sp to pin 13 and setting pin 13 as an output, we use the Loop to call our _SOS program.

// the loop function runs over and over again forever
void loop() {

//Do an SOS (...---...)
 _SOS();

}

Next we have to define that _SOS function in the program.  I am using it as a function type void since it will not return any values back to the program when it is called.

void _SOS() {
/* Three short, Three long, Three short
 *  that is the SOS Signal (...---...)
 */

The first thing in this function is to set two variables as integers using:

 int x;
 int y;

These are going to be our counters for the function so that we can control how many times to flash the LED and how many times we want to flash it either long or short.

Next we have 2 loops that will set up the flashes.

 for( x = 0; x < 3; x++) {
  for( y = 0; y < 3; y++) {
   if(x == 1) {
    _aFlash(800);
   }
   else {
    _aFlash(250);
   }
  } //End Y Loop
  delay(1000);
 } //End X Loop

The first one with X starts by setting X to 0, then while X is less than 3, increase X by 1

for( x = 0; x < 3; x++) {

This means that on the first run though, X is now 0...

The next statement says to start Y at 0, and while Y is less than 3, increase Y by 1
  for( y = 0; y < 3; y++) {
So, Y is now 0 also.

Then we check to see if X is equal to 1
 if(x == 1) {
And since it is actually 0, that means that we go to the Else line (if X was equal to 1 we would go to the next line...but now we get to skip over that and to the the Else line.

The Else line calls a function called aFlash with a value of 250.  The aFlash program is a little further down and looks like this:

//Sub for a flash with delay time between high and low as variable.
int _aFlash(int _dTime) {
     digitalWrite(_sp, HIGH);
     delay(_dTime);
     digitalWrite(_sp, LOW);
     delay(_dTime);
     return 0;

This sub declares that it will return an Integer if it returns anything at all and has an Argument (which means it requires you to give it a value when it is called) and the argument is a variable called dTime which is really the amount of the delay time we want to hold the LED either ON or OFF for.
Now, since we called _aFlash(250) we used the (250) as the argument to supply the variable dTime with a value of 250 (which is a delay time that I mentioned earlier was in milliseconds...so 250 milliseconds or 1/4 of one second...really fast!).

The function _aFlash then performs a digitalWrite on the _sp pin (pin 13, remember) and sets it to HIGH...this turns ON the LED.
Then it delays for 250 milliseconds, then does a digitalWrite on the _sp pin again and sets it LOW which turns it OFF, and keeps it off for 250 milliseconds.

The function in this case does not need to return anything back to our _SOS function so we set the return to 0 (which is actually an integer as we originally called _aFlash as returning an integer).

We jump back to _SOS now after we have flashed the LED on and off really quick, and we then loop back to Y, which is now getting the Y++ so now it is 1.
Since there is no condition for Y, only X and X is still 0, we just call _aFlash again with the same 250 ms delay time and flash the light fast a second time.  Then do a Y++ to make Y 2, which is still less than 3 so we call _aFlash again and flash the LED fast one more time...that is the first three fast blinks because now we do Y++ again and so Y would be 3  and that would end this loop since the For statement says to only loop while Y is Less than 3.

Now we delay for 1000 milliseconds (which you might remember is 1 second) and then we return to X. Now X gets the X++ and X is now equal to 1.

In the loop, if X is equal to 1 we are going to drop back to Y again and run through the Y loop again 3 time, calling aFlash again, but now with a longer delay time of
800 milliseconds.  This means that the LED will go ON, stay on for almost a full second (instead of 1/4 of a second like the first 3 times) and then go OFF, and stay off for almost a full second.  This will give us the 3 LONG blinks, and then do a X++ again to set X to 2.  Since X is now 2, which is less than 3 we will hit the Y loop again and since X is not equal to 1 anymore the delay time goes back to 250ms or 1/4 of a second for the 3 loops through Y, giving us 3 fast blinks.  Then we update X with X++ and now it is equal to 3, which ends our X loop and so we drop out to the line after the X loop which gives us a delay of 2000 which means that we will do nothing for 2 seconds, and then we will go back to the start of the void loop() function and start the whole process over again doing 3 fast blinks, 3 long blinks then 3 fast blinks again...forever.

This code will actually get shortened a little but externalizing the _aFlash() function and the _SOS() functions into header files that will become part of a library of headers we can use for the robot which means we will actually just call them at the beginning of the program and then we can have less code in the main loop.

More on that tomorrow...enough for tonight.  Here is a short, dark video of the small Arduino board running the program.

In the next day or so, I will show how to externalize some of the functions so that the code is able to be called over and over again without having to list the whole function each time you want to use that piece of code.

Bad Soldering...

Monday, March 14th, 2016

It has been busy here and I have not had much time for the robot the last few days.
Tonight, I had a few minutes and decided that even though I am tired, I would try and solder up a few things on a small circuit board.  It turned out to be a mistake.  After the first hole, the flux heated up and ran down the board and the solder just melted together on some contacts.



This messed up my board beyond repair and I put the soldering iron away.  Bad luck for me.

I think I am going to keep designing the circuit in Fritzing and then make a board of my own so that I can solder to traces instead of on these small boards...but I still might have to make a prototype on one of these to make sure the circuit works.

Tomorrow, I will connect up a few components and try again!

Revised Steering...again.

Wednesday, March 9th, 2016

So, after trying all combinations of sensors for the steering limits (Hall Effect, Micro-switches, and hard stops with current shut off), I did not have a good solution yet.
I decided that since the limits were one issue, and holding the wheel straight while running was another issue, I would go back to trying a servo motor.  But, not just any servo motor...a 1/4 scale gigantic torque-ridden beast that might be able to do the job!  I got the idea watching a video of a couple guys that built a 1/4 scale model airplane out of aluminum and flew it!  I thought if the servos could deal with that, they should be able to push the wheel on my 18 pound robot back and forth.
Scouring the web, I found a place that had not only the giant servo, but nice aluminum mounting brackets...out came the credit card.

After getting my package in the mail, I set about removing all the components I had recently and very carefully fit together (for the second time) and when I got back down to the bare chassis, I drilled holes and mounted my new servo.  After mounting it, I had to make a 3/8" dowel with a hole through it for the connection to the steering plate below.  The hole was so that a set screw could be mounted to keep the whole thing from slipping when under pressure while turning.

I got the whole system mounted up and then connected the H-bridge back on again because that was going to power the drive wheel like it was originally supposed to.

Here is how the whole thing looks now.



Once everything was mounted, I placed the EZ_Robot controller inside to see how everything would fit.  I think the EZ-Robot Micro-controller will handle the steering of the robot and the interface to my cell phone and computer.  That seems like the easiest way to work it out at the moment.
I will use an Arduino Mega up top to power all the head sensors, the keypad and LED's.  I will also use Arduinos for the arms to control them and synchronize everything through a few drivers and libraries I am making for the Arduinos.

My goal now is to try and get this robot rolling by the end of the weekend so that I can start working on my circuit boards for the sensors and then get the arms together.

I am starting to feel more ideas in my head and I want to keep working while they are all still making some sense to me.



The two collars above are holding a 3/8" shaft with set screws travelling through it to keep it from slipping while the wheel is turning.

Setbacks and Updates!

Tuesday, March 8th, 2016

Well, I had a few setbacks in the last few days.  It seems that the test setup I had with the Arduino and the breadboard mounted on a plate with power lugs was my issue.  I had the Arduino board set up so that it touched the metal base mounting plate and it shorted out the Arduino...but not completely!

I noticed that when connecting sensors on Friday and Saturday, that I was not getting good, consistent readings.  By Saturday afternoon, after much testing I thought for sure the sensors were just junk...so I ordered a few more and decided to wait and see what happened with the new ones.

The new sensors arrived, and while testing I was getting the same readings!  I could connect to the Arduino, upload to it, but its output was all useless!  This made me switch to another Arduino board and hook up the sensor again and I still got garbage output...with the new sensors and new Arduino board!  So, I waited for more sensors to arrive and when they did, I got good readings...for about 30 minutes...then something went wrong.  Back to garbage on output.

I went through some basic testing only to find out that I had some outputs touching the base plate which shorted the Arduino and the sensors and caused all my problems.

To fix this, I drilled holes in the metal base plate and used acrylic standoff mounts to place the Arduino about 1/4" above the plate and secured it with a few screws into the standoffs.

No more shorting and the tests will now continue!

I ordered a few more sensors for sound and for a real time clock setup and will test those later this week when they arrive.

In the mean time, I am digging out the arm components so that I can mount the servo's in them.

More on this later!

Speech! The Robot Gets a Voice!

Tuesday, March 1st, 2016

Today was another busy day, but I took a little time at lunch and then a little more after work to hook up the Emic2 speech chip and see if I could program some voice into the robot.
The reason I picked the Emic2 was because I can feed it strings and it will speak whatever I type with very little fuss.
There are a few other speech chips available, and I actually have the original Hero Jr. speech chip, but it has such limited capability compared to the newer technology, that I thought I would give this one a try.

The installation of the chip is pretty simple, there are really only 4 wires.  You have +5V and Ground to power the chip, then Sin and Sout where you pass the serial in and serial out commands from the microprocessor.  Since I am using Arduino boards as my processors, I grabbed an Arduino Mega and plugged in the 4 wires, found an old speaker and connected the 2 wires from that to the Speaker + and - leads.  There is also a headphone jack where you can plug in an external speaker as well.

After a short bit of coding, I had the Emic2 speaking and running his demos in English and in Spanish!  Then he sings a song...

Once I finish learning the speech commands, I will make a speech library of phrases and place them on an SD card and have those phrases available to be read in response to other commands.  I will likely number the responses and then make an array of (n) units and each time I need a phrase, I can command emicSerial.print(n); and it will call the phrase I need.
Other speech can be live as it is parsed from the voice recognition...which I will get to later on.


The code I used is below.
/*
  This program provides a simple demonstration of the Emic 2 Text-to-Speech
  Module. Please refer to the product manual for full details of system 
  functionality and capabilities.  You can program this chip in a variety
  of ways and they have examples for Parallax, and Arduino.

*/

// include the SoftwareSerial library so we can use it to talk to the Emic 2 module
#include <SoftwareSerial.h>

#define rxPin 50     // Serial input (connects to Emic 2 SOUT)
#define txPin 51     // Serial output (connects to Emic 2 SIN)
#define ledPin 13    // Most Arduino boards have an on-board LED on this pin

// set up a new serial port
SoftwareSerial emicSerial =  SoftwareSerial(rxPin, txPin);


void setup()  // Set up code called once on start-up
{
  // define pin modes
  pinMode(ledPin, OUTPUT);
  pinMode(rxPin, INPUT);
  pinMode(txPin, OUTPUT);
  
  // set the data rate for the SoftwareSerial port
  emicSerial.begin(9600);

  digitalWrite(ledPin, LOW);  // turn LED off
  
  /*
    When the Emic 2 powers on, it takes about 3 seconds for it to successfully
    intialize. It then sends a ":" character to indicate it's ready to accept
    commands. If the Emic 2 is already initialized, a CR will also cause it
    to send a ":"
  */
  emicSerial.print('\n');             // Send a CR in case the system is already up
  while (emicSerial.read() != ':');   // When the Emic 2 has initialized and is ready, it will send a single ':' character, so wait here until we receive it
  delay(10);                          // Short delay
  emicSerial.flush();                 // Flush the receive buffer
}

void loop()  // Main code, to run repeatedly
{
  // Speak some text
  //emicSerial.print("N1\n");      //Change the Voice Tone here...1-9 are valid voices.
  emicSerial.print("V15\n");
  emicSerial.print('S');
   // Send the desired string to convert to speech
  emicSerial.print("Holy Crap spackel!");
  emicSerial.print("Hello. I would like to demonstrate some of my features."); 
  emicSerial.print("Now that I can talk, I might not shut up!");
  emicSerial.print('\n');
  digitalWrite(ledPin, HIGH);         // Turn on LED while Emic is outputting audio
  while (emicSerial.read() != ':');   // Wait here until the Emic 2 responds with a ":" indicating it's ready to accept the next command
  digitalWrite(ledPin, LOW);
    
  delay(500);    // 1/2 second delay
    
  // Run 3 demos...
  emicSerial.print("D0\n");           // Demo 1 in english.
  digitalWrite(ledPin, HIGH);         // Turn on LED while Emic is outputting audio
  while (emicSerial.read() != ':');   // Wait here until the Emic 2 responds with a ":" indicating it's ready to accept the next command
  digitalWrite(ledPin, LOW);
  emicSerial.print("D2\n");           // Demo 2 in spanish.
  digitalWrite(ledPin, HIGH);
  while (emicSerial.read() != ':');
  digitalWrite(ledPin, LOW);
  emicSerial.print("D1\n");           // Demo 3 is Emic singing 'Daisy'
  digitalWrite(ledPin, HIGH);
  while (emicSerial.read() != ':');
  digitalWrite(ledPin, LOW);


 // Below is a loop to keep the Emic from repeating over and over...basically it just flashes the led on and off...
  while(1)      // Demonstration complete!
  {
    delay(500);
    digitalWrite(ledPin, HIGH);
    delay(500);              
    digitalWrite(ledPin, LOW);
  }
}

Printed Circuit Boards

Monday, Feb. 29th, 2016

I had lots of work today so it was hard to work on the robot.  I did, however, start to design a circuit board for the head unit to connect all these sensor outputs to in order to interface with the Arduino board and also the original connectors on the sensors.

Here is what I have so far:



The large connector at the top is the 25 pin male connector for the header that has the LED's and the keypad wiring in it.  The J2 and J3 are to get the keypad wires to the Arduino.  J4 is a header to connect the LED's to the Arduino and J5 and J6 are for the Light Detector and the Motion Detector.

I will have a few more connections on this board before I can make it.  The Sonar that was originally in the Hero robot is a Polaroid 6500 series model that is not made anymore and to use it for long range I need an interface board and a few IC's.  I will have to work that circuit out from the original one and see what I can come up with.

Also, I want to add a sound sensor and a newer sonar sensor into the robot without compromising the original looks too much so I will add the connections for those to this board.  I ordered a sound sensor and I have in my parts box a few SR04 ultrasonic sensors that I can work with for the lower part of the robot to have some sensors for not bumping into anything lower than the head.
I might actually go with a few of those ultrasonic sensors so that I have a 'surround' method of detecting which objects are closest or furthest from the robot for the purposes of navigation.

I have also seen temperature and humidity sensors and a new kind of passive infrared sensor that I will also most likely mount on the robot.

That will take up most of the sensors, and then I will move on to the arms...which should prove quite challenging, since the original Hero Jr. robot did not have any arms and the one for the Hero One robot was not very articulate.  My idea is to have arms with an elbow and a wrist joint and small grippers on the end.  But more on that later.

That is all for tonight...there will be more when I receive a few parts in the mail.

Using the Light Sensor

Sunday, Feb. 28th, 2016

It is Sunday morning, and I could not sleep so I popped out of bed, made some coffee, and started thinking about mounting the head of the robot.  Then I realized that I completely forgot a couple of sensors.  One is the light sensor mounted on the front.



Here you can see the little light sensor opening just below the sonar sensor (more on that one later).

So, the light sensor is really a photocell, or light detecting type of resistor.  It should be simple to hook up as there are only 2 wires.  The easiest way to deal with this type of sensor is to connect one end to 5V and the other to Analog 0 and a resistor then to ground.

  Here is a layout of an Arduino board with the LDR connected to A0, ground, and 5V.  By the way the tool I used for this diagram is called Fritzing and you can download it from the web (http://fritzing.org/home/) and use it to make wiring diagrams, and eventually to make circuit boards from.  Making a schematic diagram is also in Fritzing and so I made one up like the one below.

  So, armed with the diagram, I hooked up my board and created a little code to read the values from A0 and try to detect light.  The results were good, and so now the Light Detector is available.  I will connect it to the same board as the keypad, LED's, Motion Sensor, etc.  This will be a sensor board connected on top of the Arduino Mega as a shield.  But more on that later.

Here is the LDR connected to my Mega.

  And with a little bit of code, I can detect either light or dark.  I used ambient light for the standard (dark) and then shone a flashlight into the sensor for light.



Having used a smaller resistor in the circuit, ambient light is 0 and bright light goes up to about 127 on the values.  This is a pretty standard scale that we can use and it can be varied by changing the resistor in the circuit to use different values.

Here is the test code for the LDR in the circuit above:
/* Hero Jr. Light Sensor
   This is a simple light sensor test
   of the LDR mounted on the front of
   the robot.
   GSS 2/28/2016
*/

int LDR = 0;                  //analog pin to which LDR is connected, here we set it to 0 so it means A0
int LDRValue = 0;             //that’s a variable to store LDR values
int light_sensitivity = 10;   //This is the approx value of light surrounding your LDR

void setup()
  {
    Serial.begin(9600);      //start the serial monitor with 9600 buad
    pinMode(13, OUTPUT);     //we mostly use 13 because there is already a built in yellow LED in arduino which shows output when 13 pin is enabled
  }

void loop()
  {
    LDRValue = analogRead(LDR);     //reads the ldr’s value through LDR 
     delay(50);                      //This is the speed by which LDR sends value to arduino

    if (LDRValue > light_sensitivity) 
      {
        //It saw light, so do something.
        Serial.println("Bright Light! Bright Light!");
        Serial.println(LDRValue);
        digitalWrite(13, HIGH);
      }
    else
      {
        //It is dark, do something else.
        Serial.println("Sure is dark in here...");
        Serial.println(LDRValue);
        digitalWrite(13, LOW);
      }
  }

Back to work! L.E.D. Testing and Motion Sensor

Saturday, Feb. 27th, 2016

I was out of town for a few days working at a customer's location.  This gave me some time to think about the issues of the robot steering and also how to make the L.E.D. panel by the buttons work.

So, today being Saturday, and me not really having anything pressing to work on, I started on the LED testing.  I also found that the Motion Sensor was mounted up there and so I took that out and tested it too.

The panel where the keypad is also contains a row of 8 red LED's and one green LED.  The green one is for power on, so that one will be fairly easy to work with.  The other 8 however will have to be tied to different functions and used when necessary.  They have to be in a matrix like the keypad (kind of) and so I got started with a test routine to see if I could make them work.



After some testing with the meter, I determined that they were all on one ground line and I separated the signal lines for each of them so that I could put them into an array of sorts in the code.  To make an LED work, you have to tie one end to a pullup resistor to make sure it has only the voltage necessary to work and not so much that you will burn it out, but it is a diode so you have to put them in the right order.

I made a series of connections on a small breadboard to make sure the ideas would all work out.  If they do, then I can solder all the connections to a small circuit board and place it inside the robot's head.

   I was able to connect everything on this little breadboard with 8 1k Ohm resistors to test up the lights.  In the picture you can see the 1st red light is on.  That was encouraging so I wrote some more code and got all of them to work.  You can see that in the video below.

How about that cyclon pattern with the LED's?!

So, having the LED's working, I decided to test the motion sensor.  This sensor came with the Hero Jr. robot and was made somewhere between 1982-1984.  I mention that to say that it might not be up to the standards of the current technology and I will probably mount other sensors on the robot later after the original work properly.

 This is a pretty good shot of the Colorado Electro-Optics OSM motion sensor.

The good thing about the sensor is that there are really only 3 connections.  Power, ground, and the signal line.  In this case I used a digital signal line since there was one provided.  There seems to be a connection for an analog sensor as well, and I might try testing that at some point to see if I can gauge distance with it, but there are much more efficient sonar ranging sensors now that I think sticking with the digital on/off one was easier to replicate the original functionality.  I checked the circuit board and wiring on the original and that is what it used.

I connected the 3 wires and then created a little code to see if I could get it to detect motion when I passed my hand over it or just moved about.

You can see from the shot on the right above that on the computer, it detected motion!

So, today being pretty successful, I will post the code for the two projects here that I used to test with and then go see about designing a circuit board for the LED's possibly for tomorrow's project.  Once those are done, I might be able to mount the control Arduino in the head and mount the head back on the robot!

Code for the LED Testing:

/* This is a test for the LED's on the front panel of the Hero Jr. Robot.

   The pins will all be connected from the main board where they are mounted

   to a small perfboard with some 1k Ohm resistors and then routed to the

   Arduino on pins 22-36 (even).

   GSS 2/27/2016

*/

int led0 = 22;

int led1 = 24;

int led2 = 26;

int led3 = 28;

int led4 = 30;

int led5 = 32;

int led6 = 34;

int led7 = 36;

int state0 = 1;

int state1 = 1;

int state2 = 1;

int state3 = 1;

int state4 = 1;

int state5 = 1;

int state6 = 1;

int state7 = 1;

int state;

void setup() {

  // put your setup code here, to run once:

Serial.begin(9600);

   pinMode(led0, OUTPUT);

   pinMode(led1, OUTPUT);

   pinMode(led2, OUTPUT);

   pinMode(led3, OUTPUT);

   pinMode(led4, OUTPUT);

   pinMode(led5, OUTPUT);

   pinMode(led6, OUTPUT);

   pinMode(led7, OUTPUT);

}

void loop() {

  // put your main code here, to run repeatedly:

  Serial.println("LED Test...");

  testLEDs();

  delay(4000);

  Serial.println("Cylon LED testing...");

  cylon(6);

}

void led(int number1) {

switch (number1) {

  case 0:

  state0 = !state0;

    digitalWrite(led0, state0);

    break;

  case 1:

  state1 = !state1;

    digitalWrite(led1, state1);

    break;

  case 2:

  state2 = !state2;

    digitalWrite(led2, state2);

    break;

  case 3:

  state3 = !state3;

    digitalWrite(led3, state3);

    break;

  case 4:

  state4 = !state4;

    digitalWrite(led4, state4);

    break;

  case 5:

  state5 = !state5;

    digitalWrite(led5, state5);

    break;

  case 6:

  state6 = !state6;

    digitalWrite(led6, state6);

    break;

  case 7:

  state7 = !state7;

    digitalWrite(led7, state7);

    break;

  }

}

void cylon(int times) {

   digitalWrite(led0, 1);

   digitalWrite(led1, 1);

   digitalWrite(led2, 1);

   digitalWrite(led3, 1);

   digitalWrite(led4, 1);

   digitalWrite(led5, 1);

   digitalWrite(led6, 1);

   digitalWrite(led7, 1);

   for (int i = 1; i < times; i++){

     digitalWrite(led0, 0);

    delay(100);

    digitalWrite(led0, 1);

    digitalWrite(led1, 0);

    delay(100);

    digitalWrite(led1, 1);

    digitalWrite(led2, 0);

    delay(100);

    digitalWrite(led2, 1);

    digitalWrite(led3, 0);

    delay(100);

    digitalWrite(led3, 1);

    digitalWrite(led4, 0);

    delay(100);

    digitalWrite(led4, 1);

    digitalWrite(led5, 0);

    delay(100);

    digitalWrite(led5, 1);

    digitalWrite(led6, 0);

    delay(100);

    digitalWrite(led6, 1);

    digitalWrite(led7, 0);

    delay(100);

    digitalWrite(led7, 1);

    digitalWrite(led6, 0);

    delay(100);

    digitalWrite(led6, 1);

    digitalWrite(led5, 0);

    delay(100);

    digitalWrite(led5, 1);

    digitalWrite(led4, 0);

    delay(100);

    digitalWrite(led4, 1);

    digitalWrite(led3, 0);

    delay(100);

    digitalWrite(led3, 1);

    digitalWrite(led2, 0);

    delay(100);

    digitalWrite(led2, 1);

    digitalWrite(led1, 0);

    delay(100);

    digitalWrite(led1, 1);

    

   }

   digitalWrite(led0, state0);

   digitalWrite(led1, state1);

   digitalWrite(led2, state2);

   digitalWrite(led3, state3);

   digitalWrite(led4, state4);

   digitalWrite(led5, state5);

   digitalWrite(led6, state6);

   digitalWrite(led7, state7);

   //Serial.println(">");

}

void testLEDs () {

  Serial.println("Test L E Ds");

   digitalWrite(led0, state0);

   digitalWrite(led1, state1);

   digitalWrite(led2, state2);

   digitalWrite(led3, state3);

   digitalWrite(led4, state4);

   digitalWrite(led5, state5);

   digitalWrite(led6, state6);

   digitalWrite(led7, state7);

// #1

  digitalWrite(led0, 1);

  delay(1000);

  digitalWrite(led0, 0);

  delay(1000);

  digitalWrite(led0, state0);

// #2

  digitalWrite(led1, 1);

  delay(1000);

  digitalWrite(led1, 0);

  delay(1000);

  digitalWrite(led1, state0);

// #3

  digitalWrite(led2, 1);

  delay(1000);

  digitalWrite(led2, 0);

  delay(1000);

  digitalWrite(led2, state0);

// #4

  digitalWrite(led3, 1);

  delay(1000);

  digitalWrite(led3, 0);

  delay(1000);

  digitalWrite(led3, state0);

// #5

  digitalWrite(led4, 1);

  delay(1000);

  digitalWrite(led4, 0);

  delay(1000);

  digitalWrite(led4, state0);

// #6 

  digitalWrite(led5, 1);

  delay(1000);

  digitalWrite(led5, 0);

  delay(1000);

  digitalWrite(led5, state0);

// #7

  digitalWrite(led6, 1);

  delay(1000);

  digitalWrite(led6, 0);

  delay(1000);

  digitalWrite(led6, state0);

// #8

  digitalWrite(led7, 1);

  delay(1000);

  digitalWrite(led7, 0);

  delay(1000);

  digitalWrite(led7, state0);

}

Code for the Motion Sensor Testing:

/*

  Digital Read Testing

 Reads a digital input on pin 3, prints the result to the serial monitor

 This example code is in the public domain.

 GSS 2/27/2016

*/

int ledPin = 13;

// the setup routine runs once when you press reset:

void setup() {

  // initialize serial communication at 9600 bits per second:

  Serial.begin(9600);

  pinMode(ledPin, OUTPUT);  

  // make sure the LED is not on by default.

  digitalWrite(ledPin, LOW);

}

// the loop routine runs over and over again forever:

void loop() {

   // if the digital value is high, turn on the LED and notify the serial monitor:

   // the value will be high if motion is detected...

   if (digitalRead(3) == HIGH) {

     digitalWrite(ledPin, HIGH);    // turn on the yellow LED

     Serial.println("I detect motion...");

    }

   else {

     // if no motion is detected...

     digitalWrite(ledPin, LOW);     // turn off the yellow LED

     Serial.println("...");

   }

  delay(1);        // delay in between reads for stability

}

Figured out the Keypad

Monday Feb. 22nd, 2016

I did not have a lot of time to work on the robot today, but I did figure out how to make the keypad work.
On the 'head' of the robot is a keypad and several LED's.



On the back of the head I found a board with all the connections on it tied to the keypad and the LED's.



There is some wiring on the back that runs to the microphone and the sonar sensor, but I will decipher those another day.  I pulled out the keypad board and set about testing with a meter to see what I could figure out about this board.



I was able to figure out that the keypad was a pretty simple grid of 4 rows and 4 columns tied together from little disc's on the back of each key on the rubber keypad cover.  When you press a button, then the little disc makes contact with the row and column of the key pressed and you get a closed contact.
I wired the rows and columns together on an Arduino board using pins 4,5,6,7 for the rows and 8,9,10,11 for the columns, using 8 pins for the keypad in total.



After making the connections, I fired up Visual Studio and created a quick program to test the keypad output based on the examples in the keypad library for Arduino.



The output worked perfectly!  I was able to trap the keypad presses the first time through.
The code to run a keypad is not very complicated, you set the row and column pins and build a small array of the keys and then create a keypad object that traps the keypress.  In the end of the program, I used a switch statement to see if certain keys were pressed and then light the LED on the Arduino. The code I used is shown below.

/*  Keypadtest for Hero Jr. Robot
 *
 *  Demonstrates the simplest use of the  keypad library.
 *
 *  The first step is to connect your keypad to the
 *  Arduino  using the pin numbers listed below in
 *  rowPins[] and colPins[]. If you want to use different
 *  pins then  you  can  change  the  numbers below to
 *  match your setup.
 *
 */
#include <Keypad.h>

const byte ROWS = 4; // Four rows
const byte COLS = 4; // four columns
// Define the Keymap

char keys[ROWS][COLS] = {
  {'C','D','E','F'},
  {'8','9','A','B'},
  {'4','5','6','7'},
  {'0','1','2','3'}
};

// Connect keypad ROW0, ROW1, ROW2 and ROW3 to these Arduino pins.
byte rowPins[ROWS] = { 4, 5, 6, 7 };
// Connect keypad COL0, COL1 and COL2 to these Arduino pins.
byte colPins[COLS] = { 8, 9, 10, 11 };

// Create the Keypad
Keypad kpd = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

#define ledpin 13

void setup()
{
  pinMode(ledpin,OUTPUT);
  digitalWrite(ledpin, LOW);
  Serial.begin(9600);
}

void loop()
{
  char key = kpd.getKey();
  if(key)  // Check for a valid key.
  {
    switch (key)
    {
      case '2':
        digitalWrite(ledpin, HIGH);
        break;
      case 'C':
        digitalWrite(ledpin, LOW);
        break;
      default:
        Serial.println("You Pressed Key: " );
        Serial.println(key);
    }
  }
}