As you can see in one of my previous posts, I need to have much further understanding of how the tilt sensor works so I can debug when things go beyond my knowledge.

I poked around to find something that simply describes the sensor I’m working with and found bare bones explanation from a teacher at the School of Creative Media in Hong Kong.

I followed the directions there and did succeed in getting my serial monitor to read the correct outputs – so I know the sensor is working.

Serial.print(“Photo 1: “); Serial.print(digitalRead(6), DEC); // Display Out 1st value Serial.print(“; “); Serial.print(“Photo 2: “); Serial.println(digitalRead(7), DEC); // Display Out 2nd value

So my next step is to see if I can continue the circuit to get different LEDs to light up depending on the sensor’s state.

My #42 Tech Ed endorsement is helping me to learning how to use a breadboard with Arduino to make circuits. At first I learned how to make them very simply with Makey Makey and connecting 3 LEDs with a Serial Bus, but I really liked the breadboard because my mind could follow the circuit’s path more intuitively. So I advanced my work into breadboards with Pulse Width Modulation, coding a switch, and sensor.

As I head into choosing what I want to do for my final project, I’ve used this week to explore using Autodesk’s 123D 3D modeling application to recreate and create new circuits. My hope is to integrate this excellent tool with whatever I decide my Final Project to be.

In doing the next part of my assignment, Coding a Sensor, I needed to be sure I was using the correctly rated resistor of 10KΩ. I had two kinds, so I had to figure out which was which. After learning a little on Wikipedia: Electronic Color Code
Resistor Color Coding

I found a Resistor Calculator on HobbyHour.Com that was helpful. The one I had been using is what I need, 10KΩ. I’m having trouble distinguishing the others I have because I can’t really tell the difference between black and blue in the second column to well. If it’s black it’s 500KΩ, but the calculator warns me that is a Non-standard 5% (E24) value! If I use blue it doesn’t warn and says that it’s 560KΩ. That number seems high, but I don’t know enough to know if it’s high or not. Anyway, I have the resistor I need.

I read a little about the Light-Dependent Resistor (LDR) from a resource on bildr.blog:

Simple Light Reading With LDR + Arduino – bildr.blog

“The LDR changes its resistance with light so we can measure that change using one of the Arduino’s analog pins. But to do that we need a fixed resistor (not changing) that we can use for that comparison (We are using a 10K resistor). This is called a voltage divider and divides the 5v between the LDR and the resistor. Then we measure how much voltage is on the LDR using the analog read on your arduino, and we have our reading. The amount of that 5V that each part gets is proportional to its resistance.”

Okay. Got that.

“With the arduino analogRead, at 5V (its max) it would read 1023, and at 0v it read 0. So if the the LDR and the resistor have the same resistance, the 5V is split evenly (2.5V), to each part. (analogRead of 512)

But if the LDR is hit with a ton of light and is reading only 1K of resistance, the 10K resistor is going to soak up 10 times as much of that 5V. So the LDR would only get .45V (analogRead of 92).

And if it is in a dark room, the LDR may be 40K or resistance, so the LDR will soak up 4 times as much of that 5V as the 10K resistor. So the LDR would get 4V (analogRead of 818).”

OK – seems accessible so far…

I was given a tutorial to use to code the Arduino for the photocell, but I’ve grown so accustom to my breadboard that I get lost if the description entails alligator clips and wires. I like the breadboard as it lays things out well for me to contemplate what’s happening more carefully. So I found this tutorial from Adafruit: Using a Photocell.

Breadboard using 2 resistors, one LDR, and one LED. Ravine crossed for the LED.

int photocellPin = 0; // the cell and 10K pulldown are connected to a0
int photocellReading; // the analog reading from the sensor divider
int LEDpin = 11; // connect Red LED to pin 11 (PWM pin)
int LEDbrightness; //
void setup(void) {
// We’ll send debugging information via the Serial monitor
Serial.begin(9600);
}

void loop(void) {
photocellReading = analogRead(photocellPin);

Serial.print(“Analog reading = “);
Serial.println(photocellReading); // the raw analog reading

// LED gets brighter the darker it is at the sensor
// that means we have to -invert- the reading from 0-1023 back to 1023-0
photocellReading = 1023 – photocellReading;
//now we have to map 0-1023 to 0-255 since thats the range analogWrite uses
LEDbrightness = map(photocellReading, 0, 1023, 0, 255);
analogWrite(LEDpin, LEDbrightness);

delay(100);
}

• Which coding concepts were introduced by coding the sensor (photocell)?

 a) ≠coding, but learning about resistors/ohms was helpful.

 b) Using variables again in a new form:
Serial.print(“Analog reading = “);
Serial.println(photocellReading);
LEDbrightness = map(photocellReading, 0, 1023, 0, 255);
analogWrite(LEDpin, LEDbrightness);

• Describe the computational thinking that you are practicing when creating/coding with the sensor (photocell):

Now that we are bringing in analog readings into the mix I’m having to keep two different levels of thinking in mind at the same time. I’m struggling with that a little now.

To further extend my understanding (and my disequilibrium) around coding switches I have taken a project from the book I mentioned previously, Introduction to Arduino: A piece of cake!, by Alan G. Smith, September 30, 2011, that uses two buttons, one LED, a resistor, and code that uses Pulse Width Modulation (PWM). I’ve seen the PWM before in another exercise and this project has helped reinforce the notion.

Breadboard with one LED, two switches, one resistor. +/- are wired into right column.

const int kPinButton1 = 2;
const int kPinButton2 = 3;
const int kPinLed = 9;

void setup() {
pinMode(kPinButton1, INPUT);
pinMode(kPinButton2, INPUT);
pinMode(kPinLed, OUTPUT);
digitalWrite(kPinButton1, HIGH);
digitalWrite(kPinButton2, HIGH);

int ledBrightness = 128;
void loop()
{
if(digitalRead(kPinButton1) == LOW){
ledBrightness–;
}
else if(digitalRead(kPinButton2) == LOW){
ledBrightness++;
}

ledBrightness = constrain(ledBrightness, 0, 255);
analogWrite(kPinLed, ledBrightness);
delay(20);
}

• Which coding concepts were introduced by coding two switches?

Just adding another switch wouldn’t have been too interesting without using PWM to differentiate between the use of the two switches. What makes this project interesting is introducing ‘– and ++’ to make the LED brighter and dimmer.

ledBrightness = constrain(ledBrightness, 0, 255); “guarantees the value of ledBrightness will be between 0 and 255 (including 0 and 255)”

analogWrite(kPinLed, ledBrightness); “uses analogWrite to tell Arduino to perform PWM on that pin with the set value.”

delay(20); “delays for 20 milliseconds so that we won’t make adjustments faster than 50 times in a second. (You can adjust this to find where you think the best response is to your pressing the buttons.) The reason we do this is that people are much slower than the Arduino. If we didn’t do this, then this program would appear that pressing the first button turns the LED off and pressing the second button turns it on.”

• Describe the computational thinking that you are practicing when creating/coding two switches:

Change of state through a variable. Taking human factors in mind when programming – without the delay the LED would look like it’s just turning off.

My teacher has asked these two questions –

• Which coding concepts were introduced by coding a switch?

• Describe the computational thinking that you are practicing when creating/coding a switch:

I used a new (to me) book that I’m finding very handy to set up two types of switches, Introduction to Arduino: A piece of cake!, by Alan G. Smith, September 30, 2011.

The first is a simple one button switch:

Breadboard with one LED, one switch, one resistor. +/- are wired into right column.

const int Button1 = 2;
const int Led = 9;

void setup()
{
pinMode(Button1, INPUT);
digitalWrite(Button1, HIGH);
pinMode(Led, OUTPUT);
}

void loop()
{
if(digitalRead(Button1) == LOW){
digitalWrite(Led, HIGH);
}
else{
digitalWrite(Led, LOW);
}
}

• Which coding concepts were introduced by coding a switch?

Two things here:
1) HIGH = ‘On’ | high voltage & LOW = ‘Pressed ‘ | low voltage.
2) if/else statements

• Describe the computational thinking that you are practicing when creating/coding a switch:

I will be the first to admit that my brain isn’t ‘wired’ for the computational thinking that coding requires, it neither comes naturally or easily and it takes many iterations in different forms for me to start to take on concepts and show understanding.

It isn’t easy for me to divorce the physical thing that I see, the button being up or “HIGH” to the electronic reality of the circuit. It is when the button is down that the circuit is complete and ground is connected to pin 2. When it is not pushed down the circuit is from the +5V through the resistor and the Arduino sees the +5V. (HIGH). Again, I will need to this type of thing a few more times before it really takes hold.

I’m working on understanding if/else statements.

From the book: “An if statement can have an else clause which handles what should be done if the if statement isn’t true.”

If the button is pressed then turn on the LED. If not (else) keep the LED off.