Personal Retrospective

This has been an amazing and challenging adventure. While this is not, by any means, my first experience with making, circuit building or coding, it was still different because I chose to approach it with a different goal in mind. In past experiences, I have approach these things with either an attitude of: I have to do this because it is part of my requirements for degree or certificate I’m working on; or, I have to figure this out to make it work for this other project I am working on. This time, I approached it with the attitude of: This will be something fun and that I want to learn because it interests me. And, of course, along the way, I developed an idea for a project that I intend to try to build, in which I will use some of the skills I further developed during this adventure.

What was the build you are most proud of and why?

This is a tough call. The dice project was a pretty proud moment because I was not able to make it work the last time I tried to build it. However, I think I would ultimately have to choose the potentiometer controlled electric motor as my proudest build. I would choose this one because it is one that I will actually be able to implement into the project that I am wanting to build in the next few weeks.

Where were you when you started and where did you end up?

When I started this adventure, I was already somewhat familiar with making and the Arduino from having gone through this adventure once before. Also, I was somewhat comfortable with circuit building from other courses I have taken in the past and from working on the electrical systems of houses, as well as repairing small electrical and electronic devices. But, it had been a while since I had done much with any of that, so I was in need of a bit of brushing up. As the weeks progressed, I became more comfortable with my skills and finally was able to develop a few items on my own without having to look up stuff on reference sites and maker shares. Of course, none of what I was able to do independently was any of what we were asked to do for the class. After all, if that were the case, I would not have been working in the ZPD.

What did you learn that you didn’t know before?

I learned that there are some things that I know, but don’t recall without pointed reminders.

How did you actually come to learn this new knowledge?

When we were working on the last build, in which I used a photo resistor to control a servo, I knew that the servo had the ability to move to specific points very precisely but the fact would not come to mind when I was trying to decide what to build for this challenge. I kept asking myself what are servos used for? Instead of simply Googling an answer to my question, I searched for video clips of servos in action to see for myself what kinds of functions servos have been tasked with. As soon as I saw a build of the “Useless Box” project, I recalled how a servo works.

What did you learn about yourself?

This wasn’t so much of a learning, rather a reminding: I love working with my hands, building things and making them work. I had gotten so academic in recent years that I had lost sight of those things and was getting into a rut of constantly doing “book work” and not doing anything in these areas that interest me so much. In fact, I recalled that there are times that I enjoy making something that doesn’t serve any purpose other than to allow me to build, thereby relieving some stress. I will definitely be doing more building and making.

In Reviewing My Blog Posts

Given that most of my students have not been very good writers, I would have loved to get such posts from them. There were things I would have corrected on them, simply because I am a “grammar nazi,” at least according to my students and several friends. But, those are things that had to do with the writing, not the presentations of facts and journeys.

Where did you say your challenges were?

My challenges each week were different. I feel like this is a good sign because it says that I didn’t get stuck in the same struggle each week. Rather, I resolved that struggle and leaned from it so that I could attack and conquer the next challenge that came along. It tells me that I was actually learning and growing in my making circuit building and coding skills.

Moving Forward

This has been an awesome adventure. When it started, I was thinking that I might eventually work toward coding apps for phones and tablets. And, I may still do that. However, for the immediate future, I am looking forward to building a “boosted board” project for my son. If I have the materials, I will even try to build two of them. These will not be the usual powered skate boards with remote controls. Rather, I want something that we can ride off-road, in rough terrain. So, these will be built with large tires and rugged components. Also, they will have handle bars to hold on to for stability. I will use my Arduino kit to build and program the controls for the boards. I will incorporate LEDs for power level indication, potentiometers for speed control and possibly even an audio circuit for fun sound effects. That last is still up for debate. I am old enough to enjoy being goofy. But, my son is about to be 11 years old and may soon be moving out of the stage of wanting to be goofy. Oh well, something to be pondered! I hope to have this project completed within the next 2-3 months. Ideally, it would be ready for his birthday, which will be my first goal date. I will try to share some of the build on here as it progresses.

Maker Vision Sharing

Below, you will find my Maker Vision documents and a link to my eMaze presentation. This has been an interesting and challenging creation that I will continue working on as time progresses.

Maker Space Vision: https://drive.google.com/open?id=0B1xySt9cL4pPaVIxYV9NVy1Fb0k

Maker Center design: https://drive.google.com/open?id=0B1xySt9cL4pPTF9wTHNVRDZDRVk

eMaze presentation: https://www.emaze.com/@AWTQWZIC/whs-maker-center

Week 6 - Photo Servo

This week’s adventure was to develop some kind of circuit and code with motors controlled by a sensor. I looked at multiple options, starting with using the temperature sensor to create a servo controlled fan, turning the fan on when the temperature increased too far and turning it off when the temperature dropped sufficiently. However, all of these either required multiple pieces that I didn’t have in my kit or called for multiple Arduinos. So, I switched to looking at the photoresistor as the controlling sensor. I thought about a robotic drummer (with just one stick) and effectively achieved that after a bit of research. I didn’t really have anything that would create a good drumming sound, so just demonstrated the actions. And, I realized that there is another purpose that the same circuit could serve without any change to either circuit or code, only by making a minor change in what the servo activated, physically. I realized that this same circuit would act as a great traffic counter, especially if it was set up with a strong light directed at the photoresistor, then having the servo actuate a physical counter.

Thankfully, this week, the only “issue” I had with the build was finding one that would work like I wanted it to without requiring a bunch of extra stuff that I don’t have. The code and the wiring all worked correctly the first time. I guess it was an omen, because VERY shortly thereafter I developed a tremendous headache that insists on hanging around for a good while. But, it is all good.

Here’s a screenshot of the code I used. It is a very simple code that simply does what is expected of it.

Here is a pic of the circuit. It looks much more complicated than the code! :)

Here’s the schematic I built from.

And, here’s my “Photo Servo” in action.

Final Reflection:

This type of circuit is something I could imagine being used in robotics, especially in an industrial setting. Imagine an industrial robotic arm in an area where humans also work. With a circuit similar to this built into the control of the arm, a simple safety system could be instituted whereby a shadow falling across a photoresistor would pull the arm back to protect the human that created the shadow.

Week 5 - Pot Controlled Electric Motor

This week’s adventure was more of a challenge and more adventurous than previous weeks have been. This week, we were to choose our own circuit to build, then as a challenge, adapt or modify it in some way to make it more useful. At least, that’s how I understood the instructions.

So, with my personal project goal in mind, I chose to first build the electric motor control circuit and understand how it works. Then, when I had that working, after some hair pulling and backtracking, I decided to find a way to use the concept to include a potentiometer to manually control the speed. This, I felt, would give me a better grasp of what I would need to do to achieve a similar effect on the boosted board project I intend to try to build for our son.

Here's my video of Circuit 10 and a bit of explanation of what I did and the troubleshooting I had to go through.

At first, it looked like it was going to be quite simple: just choose one and build it. Unfortunately, after choosing the most likely looking prospect, I found that it would only barely function to adjust speed of the motor within a very narrow range, which did NOT include “off” or zero RPMs. So, I actually had to resort to a “Dummies” site to find a build that would actually work and make the motor run from 0 RPM to full speed, in this case 255 RPM. This build was actually much simpler than any of the others, some of which even included ICs (integrated circuits) which I wanted to try to avoid since the project will ultimately be intended for off-road use in rough terrain. I felt like ICs would be less likely to stand up to the vibrations and stresses of such use.

Here’s a screenshot of the code I used. It is actually very simple compared to some of the others that I looked at.

Here is a pic of the circuit. It actually looks quite simple.

Here’s the schematic I built from. Notice that this is the original, with the change annotated.

So, here is my version of the Pot Controlled Electric Motor in action.

Final Reflection:

This type of circuit is actually quite common in the real world. There are motors in nearly all appliances. Some of them (i.e. refrigerators, dishwashers, etc) are controlled exclusively through set program parameters while others (i.e. blenders, food processors, etc) are at least partially manually controlled. As I have mentioned previously, I intend to make use of this circuit to control the motor of the boosted board project that I want to build for our son. As it is intended to be an off-road, rough terrain vehicle, I prefer to stick to physical components that are more likely to withstand the abuse of off-roading, so no ICs.

Week 4 - Electronic Dice

This week, we were supposed to build a circuit that digitally simulates rolling a die. The last time I attempted this, I was able to get the thing working, but not correctly. It would show some numbers perfectly, but others (4, if I remember correctly) would display random LEDs. This time, I started out with that in mind. For my first step, I decided to find an online tutorial demonstrating how to achieve the desired results. I found several, including some that used an LED numerical display. Unfortunately, I don’t have that numeric display. So, I eliminated those immediately. Then, I settled on one that the maker seemed very confident about. As it turns out, that confidence was either unfounded, or the instructions presented were too confusing. So, I found another tutorial that seemed more put together, and actually had a schematic that I could work from. I bypassed nearly all the instructions and pictures, and focused almost entirely on the schematic. Built the circuit, downloaded and verified the code, uploaded said code to my Arduino and had an LED that wouldn’t light up. But, it was a simple matter of wire tracing. I quickly discovered that I had two leads running to 1 LED and none to the one at the opposite end of that string of LEDs. I moved that wire and, voila! It worked perfectly. The saying: “The more you do it, the easier it gets!” is true, especially in something like this.

The code I used for this (without comments) is below:

i nt pinLeds1 = 10;
int pinLeds2 = 9;
int pinLeds3 = 7;
int pinLed4 = 8;
int buttonPin = 6;
int buttonState;
long ran;
int time = 2000;

void setup ()
{
  pinMode (pinLeds1, OUTPUT);
  pinMode (pinLeds2, OUTPUT);
  pinMode (pinLeds3, OUTPUT);
  pinMode (pinLed4, OUTPUT);
  pinMode (buttonPin, INPUT);
  randomSeed(analogRead(0));
}

void loop()
{
  buttonState = digitalRead(buttonPin);
  if (buttonState == HIGH){
    ran = random(1, 7);
    if (ran == 1){
      digitalWrite (pinLed4, HIGH);
      delay (time);
    }
    if (ran == 2){
      digitalWrite (pinLeds1, HIGH);
      delay (time);
    }
    if (ran == 3){
      digitalWrite (pinLeds3, HIGH);
      digitalWrite (pinLed4, HIGH);
      delay (time);
    }
    if (ran == 4){
      digitalWrite (pinLeds1, HIGH);
      digitalWrite (pinLeds3, HIGH);
      delay (time);
    }
    if (ran == 5){
      digitalWrite (pinLeds1, HIGH);
      digitalWrite (pinLeds3, HIGH);
      digitalWrite (pinLed4, HIGH);
      delay (time);
   }
   if (ran == 6){
      digitalWrite (pinLeds1, HIGH);
      digitalWrite (pinLeds2, HIGH);
      digitalWrite (pinLeds3, HIGH);
      delay (time);
   }
  }
  digitalWrite (pinLeds1, LOW);
  digitalWrite (pinLeds2, LOW);
  digitalWrite (pinLeds3, LOW);
  digitalWrite (pinLed4, LOW);
}

The circuit, itself, can be seen in the photo below. I found that the 2 most difficult parts of this week were: 1) keeping the wires from pushing the LEDs out of alignment or covering them up, and 2) finding a tutorial or instructional for this circuit that actually worked and was easy enough to follow.

The schematic that I used to build the above circuit is found below.

And, here is the build in action.

This week’s build was, at first, a bit difficult to find in the real world. However, once I stopped thinking of purely physical aspects and considered digital applications, as well as those that use a numeric display, I realized that this is something that is used in many different areas with some modifications. For example, we play a game called Farkle. In the physical world, we use physical dice. However, we have recently discovered digital versions of the game which use various forms of digital dice. Also, our refrigerator uses a similar circuit and coding to display temperatures and other settings. The difference with the refrigerator is that it is not displaying random numbers (we hope), but uses data from sensors in the appliance to tell the numeric displays what areas to light up. I think there may be a way to use this challenge build with some modifications to display the speed on my “boosted board” project that I want to build.

Week 3 - Circuits Getting More Complex

This week’s project was to create 2 circuits, then combine them in some way to make one working circuit. I chose to start with circuit 4’s chasing lights option and have the 8 yellow LEDs chase up to the RGB which would then light up in sequence and after the 8 yellow LEDs and turn back off in reverse order followed by the 8 yellow LEDs. It was a success, except that for some reason the green portion of the RGB wasn’t very easy to see and none of the RGB elements would light up very brightly.

The following are shots of my codes from all 3 circuits. I have also attached PDF files of each code. The screenshots only show a small portion of the code, so I decided to include the files for reference purposes.

Code for All 3 Circuits is Available Here

Here is a picture of each of the circuits as they were built on the Arduino breadboard. They are in order: Circuit 3, Circuit 4, Challenge circuit.

The schematics (following the same order) are pictured below:

And, finally, the video, demonstrating each of the circuits in action.

This project was a great challenge to me. It reminded of several things that I had not originally recalled about combining code. As many of you have probably figured out, it is not as simple as simple tacking one set of code onto another set. You have to take each section (declarations, routines, etc.) and put the code from each of those sections into the proper portion of the code you are adding on to, as well as ensuring that all variables are properly defined, not in conflict, proper pins/ports are addressed, and so on. It didn’t take me long to remember that lesson that was such a thorny issue to work through last time. In fact, if I remember correctly, I gave up on combining the code sections last time and just wrote a whole new set of code for this project. It was at that point that I realized exactly how things are laid out within the code itself.

Where would you find things like these circuits in the real world? The RGB circuit can be found in status lights on many different pieces of equipment. For example, my cordless Weedeater has status lights on the charger to indicate the condition of the battery. If the charge is between 90 and 100%, the LED lights up green. If it is 60-89%, it lights up orange. If it is below 50%, it lights up red. This is the same sort of circuit but with different inputs that determine which color element lights up. I have seen similar lights on cardboard presses to indicate when it is in operation, in error state, or safe to open the door. The chasing LEDs are found in Christmas lights, lights around dance floors, and directional lights such as the emergency beacons on police vehicles and ambulances. Oh yeah, I just remembered a common chasing LED setup: the brake lights on many modern motorcycles and some cars use LEDs that chase around the edge of the enclosure for higher visibility than the standard steady-burning lights provide. Watch the video below for a sample of these type of brake lights.

Week 2 - Circuit 2 - Potentiometer

This week’s project involved building another simple circuit that was, basically, an upgrade to last week’s circuit. This circuit created a blinking LED, but included the ability to control blink rate via a potentiometer otherwise known as a variable resistor. The code I used for that circuit can be seen in the screenshot below.

This is a picture of the circuit itself.

Here’s a picture of my schematic for the circuit.

Below is my video of the project, with my usual commentary.

Here’s my vlog commentary about this challenge, how I worked through it, and my final reflection. There wasn’t much difficulty this week, at least not with the circuit itself. For those who don’t want to watch the video, I’ll include a text explanation below the video.

Notice! The text below is a rough transcript of the content of the video above. You are welcome to peruse both or just one.

So, this week’s challenge, at first sounded like it would be more challenging than last week’s. However, after studying the schematic in the Arduino guide, I realized that it was just an extension or upgrade of last week’s circuit. Once I realized this, everything having to do with the circuit was much easier than anticipated. One difficulty I had with the circuit was that it simply did not want to work. I checked everything and could find nothing wrong. Instead of trying to trace out wires for a 4^th time, I decided to go ahead and pull it all apart and re-build the circuit from scratch, triple checking the orientation of the potentiometer. It all worked great.

The real challenge I had this week came before I got to that part of the project, however. I had not used my Arduino since before this summer. So, I did not have my original IDE software installed and had to download the newest version when we started this class. Apparently, Arduino has made some changes to their code library format requirements. When I downloaded the USK Guide Code library, the new IDE did not like it. It kept insisting that it was invalid. I checked online to see if others have had the same problem. They had! And, the fix was what I had thought about doing before I went and checked for a solution. What I read was: remove the library and all associated files from the IDE program folder and place them somewhere else, independent of the Arduino files. I did this, reset the Arduino itself, uploaded the code to the Arduino. No more invalid library error code.

The extension challenges were interesting and somewhat of a challenge, but not enough to cause me real difficulty. That will come with some of the later circuits.

Where do we find potentiometers in real life? They are everywhere. Volume controls, light dimmer controls, electric motor speed controls, etc. There is a particular application that I am going to try out for myself in the next few months. Our son will not ride a bicycle. He just sits on it and pushes it around. Recently, I discovered boosted boards. They are essentially extra long, motorized skate boards with remote controls. I thought about buying one for our son and adding a handle bar to compensate for his lack of coordination, but then found out the price. WAY OUT OF OUR BUDGET!!!! But, I figure I can build one with some of the electric motors and other parts we have lying around. I plan to use a potentiometer, attached to one of the handle bar grips, to control the speed of the motor. This way, the whole project would cost very little, would be safer than a regular boosted board, and would give our son the motivation to get out and move more, In fact, I might just set it up with really large wheels so that he can ride it off road, instead of needing to get out in the street.

Week 1 - Circuit 1 - Blinking LED

This week’s project was a very basic circuit and code to run that circuit. The purpose of the circuit and code was to create a blinking LED that would turn on for 1 second, then turn off for 1 second and repeat until it was turned off.
The code for this Arduino circuit was as simple as the circuit itself. That is to say, about as simple as it can get. The screenshot below is my version of that code. It is almost identical to the sample code, because there was really no need to make any changes other than cleaning up a few extra spaces.

Here is a picture of the circuit, including the Arduino and Breadboard. As you can see from the image, the circuit was very simple. But, as you might also notice, I made it slightly more complex than necessary for the sake of standardization. I could have eliminated the second white (-) wire by simply connecting the resistor directly from the circuit to the negative power strip on the breadboard. However, I know that other circuits will be too complex to allow for such direct connections, so I chose to get into the habit of connecting this way, instead.

This is the schematic of the circuit. Again, it’s very simple and straightforward.

This is my video of the cirucuit and some of my steps in creating it, as well as the extensions I did. I hope to have better lighting for future videos. This one was somewhat spur of the moment as I had some difficulties, at first, getting the Arduino and my laptop to talk to each other. I’ll explain that more, below.

Struggles with this week’s challenge: The first and biggest challenge I had was getting my Arduino and laptop to play nicely with each other. I had typed out my code, verified it, and saved it. Then, once I had my circuit built on the breadboard, I hooked up my Arduino to my laptop and attempted to upload my code to the Arduino. The IDE said that the Arduino was connected and recognized. However, at the very end of attempting to upload the code, I was presented with an error saying that the computer could not open the device. I tried multiple troubleshooting steps, including re-installing the drivers for the Arduino, with no success. I was beginning to think something had happened to my Arduino since the last time I used it, even though it seems impossible since it is stored in a hard case out of reach of children and animals. Finally, I found something online that suggested checking to see if the ports were correctly identified. When I checked them, they all looked to be correct, but I went ahead and reset them, anyway. Voila! It worked.


One of the biggest things I learned through this challenge is to step back, take a breath and approach from a new angle. Even when things appear to be perfect, and it’s something you’ve done a million times, there can still be something you’re not seeing just because you are too close to the subject.