Physical Computing Blog

Java and Arduino Game

2009-05-19T12:18:00.006-04:00

For this project, we are suppose to make arduino talk to another machine (another arduino, computer, etc) through the use of sensors. I made a simple game where the player will have to dodge the flying red monsters and stay safe.

In order to achieve the criteria specified by our professor, I made the arduino to get physical value through an IR sensor and pass it to the computer by using serial communication. I made a costume event handler where an event will be thrown every time the value of the variable which holds the IR sensor's value changes. So basically when the user interacts with the IR sensor, the arduino gets the value from the IR sensor and passes the appropriate value to the SensorGuy object. Once the value is received by SensorGuy, it converts the value to char from byte and then calls the appropriate method in the SensorEvent object. Once the value changes in the SensorEvent object, it creates a SensorObject object and passes the object to all the classes who have registered to be notified.

In this game, the main GUI is the DodgeMaster object. This object registers itself to the SensorEvent when it is being created and implements the SensorListener interface which has the necessary methods to be created. When the SensorEvent notifies the change in value of the sensor, the main GUI receives the value and this value in turn determines the behavior of the player. The overall working of the project is shown in the UML diagram below:

The codes necessary for the working of this project is given below:

1. SensorListener.java, which is an event interface.


/**
* This class is the interface which has to be implemented by any classes
* who want to get events from the SensorEvent class.
* @author kinley tshering
*/

public interface SensorListener 
{
    public void valueRecieved( SensorEvent event );
}

2. SensorEvent.java, the event object.


/**
* This class is the event objectwhich has to be created every time
* an event is fired by the SensorEvent object. 
* @author kinley tshering
*/

import java.util.EventObject;

public class SensorEvent extends EventObject {
    private char sensor;

    public SensorEvent( Object source, char _sensor ) {
        super( source );
        sensor = _sensor;
    }
    public int getSensor() {
        return sensor;
    }

}

3. SensorObject.java, the event source object.


/**
* This class is the event sourcewhich which will generate events every time
* the value of the sensor changes. 
* @author kinley tshering
*/

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class SensorObject {

    private static char sensorValue = 0;
    private List _listeners = new ArrayList();
    public synchronized void receiveValue(char _senValue) {
 //get sensor value and fire events
 sensorValue = _senValue;
 fireEvent();
    }

    public synchronized void addSensorListener( SensorListener sl ) {
        _listeners.add( sl );
    }

    public synchronized void removeSensorListener( SensorListener sl ) {
        _listeners.remove( sl );
    }

    private synchronized void fireEvent() {
        SensorEvent sen = new SensorEvent( this, sensorValue );
        Iterator listeners = _listeners.iterator();
        while( listeners.hasNext() ) {
            ( (SensorListener) listeners.next() ).valueRecieved( sen );
        }
    }
}

4. SensorGuy.java, this class bridges the arduino and java together by using the serial communication to receive data.


/**
* This class gets the sensor value from arduino and notifies the event source.
* this code is adopted from the java sample provided by arduino on arduino site.
* @author kinley tshering
*/

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import java.io.InputStream;
import java.io.OutputStream;
import processing.app.Preferences;

public class SensorGuy extends Thread{

    static InputStream input;
    static OutputStream output;
    SensorObject sen;

    public SensorGuy(SensorObject _sen)  {
  sen = _sen;
 }

 public void run() {
  try {
  Preferences.init();

  CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier(
    Preferences.get("serial.port"));

  SerialPort port = (SerialPort)portId.open("serial madness", 4000);
        input = port.getInputStream();
        output = port.getOutputStream();
        port.setSerialPortParams(
         Preferences.getInteger("serial.debug_rate"),
         SerialPort.DATABITS_8,
         SerialPort.STOPBITS_1,
         SerialPort.PARITY_NONE);
  while(true){
   while (input.available()>0)  {
    //System.out.print((char)(input.read()));
    char value = (char)input.read();
    sen.receiveValue(value);
   }
  }
 }
 catch(Exception exc)  {
  System.err.println("ERROR: we're sorry, cannot execute further");
 }
 }

}

5. DodgeMaster.java, the main GUI of the game where the results of the user interaction is shown on the screen using Frames and 2D graphics.


import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

/*
 * DodgeMaster.java
 */

/**
 * @author Kinley Tshering
 * @adopted from a code sample from programmers Heaven...
 */
public class DodgeMaster extends JFrame implements ActionListener, SensorListener {

    /** Creates new form DodgeMaster */
    public DodgeMaster() {
        initComponents();
    }


    private void initComponents() {
  //start the Timer event
        timer1 = new javax.swing.Timer(timer, this);
        timer1.start();

  senObj = new SensorObject();
  senObj.addSensorListener(this);

  //start the Thread
  test = new SensorGuy(senObj);
  test.start();

        this.setIconImage(carImage);
        jPanel1 = new javax.swing.JPanel();

        setResizable(false);
        addKeyListener(new java.awt.event.KeyAdapter() {

            public void keyPressed(java.awt.event.KeyEvent evt) {
                formKeyPressed(evt);
            }
        });

        addWindowListener(new java.awt.event.WindowAdapter() {

            public void windowClosing(java.awt.event.WindowEvent evt) {
                exitForm(evt);
            }
        });

        getContentPane().add(jPanel1, java.awt.BorderLayout.CENTER);

        pack();
    }

 //implementation of ActionListener
    public void actionPerformed(ActionEvent e) {
        //get graphics
        g = jPanel1.getGraphics();
        //draw road
        drawBackground(backX, backY, backWidth, backHeight);
        //draw enemy car
        for (int i = 0; i < enemyY.length; i++) {
            //move cars vertically
            enemyY[i] += enemySpeed[i] - playerSpeed;

            if(enemyY[i] > formDimension[2] + enemyplayerHeight)  {
    enemyY[i] = - enemyplayerHeight;
    enemyX[i] = ran.nextInt(formDimension[3]);
   }

            drawEnemy(enemyX[i], enemyY[i], enemyplayerWidth, enemyplayerHeight, i);
        }
        //draw the player
        drawPlayer(playerX, playerY, playerWidth, playerHeight);
        //watch for collisions
        crashes();
        //draw teh panel and other infnormation
        drawPanel();
    }

 //implementation of SensorListener
 public void valueRecieved( SensorEvent event )  {
  char key = (char) event.getSensor();
  if (key == '1' && playerX > formDimension[0]) {
      playerX -= 2;
  }
  else if (key == '2' && playerX < formDimension[2] + formDimension[0] - playerWidth) {
      playerX += 2;
        }
        else {}
 }

 //implementation of keyBoardListener (Adapter).
    private void formKeyPressed(java.awt.event.KeyEvent evt) {
        // 32 - space bar
        keyCode = evt.getKeyCode();

        if (keyCode == 32) {
            newGame();
            timer1.start();
        }
    else {}
    }

    /** Exit the Application */
    private void exitForm(java.awt.event.WindowEvent evt) {
        System.exit(0);
    }

    public static void main(String args[]) {
        new CarRace().setVisible(true);
    }

    public Dimension getPreferredSize() {
        return frameSize;
    }

    private void drawPlayer(int a, int b, int c, int d) {
        backY += playerSpeed;
        if (backY > formDimension[3]) {
            backY = 10;
        }
        //draw sikilmish image on the car blyad!!!
        g.drawImage(carImage, a, b, c, d, null);
    }

    private void drawBackground(int a, int b, int c, int d) {
        //draw the road
        g.setColor(Color.gray);
        g.fillRect(formDimension[0], formDimension[1], formDimension[2], formDimension[3]);
        //draw the stripes on the road
        g.setColor(roadColor);
    }

    private void drawEnemy(int a, int b, int c, int d, int e) {
        g.drawImage(enemyImage, a, b, c, d, null);
    }

    private void crashes() {
        //check collision between enemy car and the player
        for (int i = 0; i < enemyY.length; i++) {
            if (enemyX[i] > playerX - (enemyplayerWidth - 10) && enemyX[i] < (playerX + 
                playerWidth - 10) && enemyY[i] > playerY - (enemyplayerHeight - 10) &&
                enemyY[i] < playerY + (playerWidth + 10)) {
                timer1.stop() ;
                g.setColor(panelColor);
                g.drawString("Sorry! You had a collision. Try Again!!", panelX, panelY);
                timeLeft = 2000;
            }
        }
        //check the collision among the enemy cars
        for (int i = 0; i < enemyY.length; i++) {
            for (int z = 0; z <= 4; z++) {
                if (z != i && enemyX[z] > enemyX[i] - enemyplayerWidth && enemyX[z] <
                   enemyX[i] + enemyplayerWidth && enemyY[z] > enemyY[i] - enemyplayerHeight && 
                   enemyY[z] < enemyY[i] + enemyplayerWidth) {
                    enemyX[i] = enemyX[z] + enemyplayerWidth;
                }
            }
        }
    }

    private void drawPanel() {
        g.setColor(panelColor);
        if (timeLeft > 0) {
            timeLeft--;
        } else {
   //next level, increase the timer speed (speed of attacking cars)
            g.drawString("Well Done!! Good Luck With the next level.", panelX, panelY + 20);
            level++;
            timer-=10;
            timeLeft = 1000;

        }
        g.drawString("Level " + level, 150, 150);
        g.drawString("Time Left: " + timeLeft, 150, 130);
    }
    //craete a new game
    private void newGame() {
        //drivers car parameters
        playerX = formDimension[2] / 2;
        playerY = formDimension[3] - playerHeight - 50;
        playerSpeed = 0;
        //enemy car parameters
        timeLeft = 2000;
        //road parameters
        backX = 300;
        backY = -backHeight;
        keyCode = 0;
    }

    private javax.swing.JPanel jPanel1;
    private javax.swing.Timer timer1;
    private final int[] formDimension = { 0, 0, 500, 710};
    private Graphics g = null;

    //drivers car parameters
    private final int playerWidth = 40;
    private final int playerHeight = 80;
    private int playerX = Math.round(formDimension[2] / 2);
    private int playerY = formDimension[3] - playerHeight - 50;
    private int playerSpeed = 0;
    private final int maxplayerSpeed = 100;
    private final int minplayerSpeed = 5;
    private int timeLeft = 1000;
    private final Image carImage = Toolkit.getDefaultToolkit().getImage("player.gif");

    //enemy car parameters
    private int enemyplayerWidth = 40;
    private int enemyplayerHeight = 80;
    private final int defaultEnemyplayerWidth = 40;
    private final int defaultEnemyplayerHeight = 80;
    private int[] defaultEnemyX = { 400, 200, 250, 300, 350, 150};
    private int[] enemyX = { 400, 200, 250, 300, 350, 150};
    private final int defaultEnemyplayerY = formDimension[1] + enemyplayerHeight - 50;
    private int[] enemyY = { defaultEnemyplayerY, defaultEnemyplayerY, defaultEnemyplayerY,
                           defaultEnemyplayerY, defaultEnemyplayerY, defaultEnemyplayerY};
    private final int[] enemySpeed = { 18, 10, 25, 15, 30, 20};
    private final Image enemyImage = Toolkit.getDefaultToolkit().getImage("ememy.gif");

    //road parameters
    private final int backWidth = 10;
    private final int backHeight = 40;
    private int backX = 300;
    private int backY = -backHeight;
    private final int stripesDelay = 200;
    private final Color roadColor = new Color(255, 255, 255);

    //panel parameters
    private final Color panelColor = new Color(255, 255, 255);
    private final int panelX = formDimension[2] - 150;
    private final int panelY = formDimension[3] - 50;
    private int keyCode = 0;
    private Dimension frameSize = new Dimension(formDimension[2], formDimension[3] + 20);
    private int timer = 100;
    private Random ran = new Random();
    private int level = 0;
    private SensorObject senObj;
    private SensorGuy test;
}

6. GetSensorValue.pde, the code which is to be loaded onto arduino board.


/**
 * this code gets the value from the IR sensors and passes it to the
 * serial port.
 * @author Kinley Tshering
 */

int irPin1 = 1;   //pin for sensor 1
int irPin2 = 3;   //pin for sensor 2
int sensor1Value = 0;
int sensor2Value = 0;

void setup() {
  Serial.begin(9600); // Set serial out if we want debugging
}

void loop() {
  sensor1Value = analogRead(irPin1);
  sensor2Value = analogRead(irPin2);
  
  if(sensor1Value > 150)  {
      Serial.println('1', BYTE);
   }
   if(sensor2Value > 150)  {
      Serial.println('2' , BYTE);
   }
   delayMicroseconds(100);
}

Follow the following steps in order to compile and run the game.

1. go to a command prompt.
2. cd to your arduino directory (i.e. type "cd \arduino")
3. Issue the following command:

copy run.bat testrun.bat

4. Issue the following command to edit the new file.

notepad testrun.bat

Once open, make the following changes:
a. add . to the beginning of the classpath (thats a period)

set CLASSPATH=.;java\lib\rt.jar;etc...

b. change JAVA_HOME\java processing.app.Base

to:

 rem JAVA_HOME\java processing.app.Base

c. on a new line after rem JAVA_HOME\java processing.app.Base

add:

%1 %2 %3

5. save and exit testrun.bat

6. Run the following commands:


testrun jikes SensorObject.java
testrun jikes SensorEvent.java
testrun jikes SensorListener.java
testrun jikes SensorGuy.java
testrun jikes DodgeMaster.java

7. Run the following command:

testrun java DodgeMaster

If you have followed all the procedures correctly, your game should is running now.

Connecting Arduino and Java using Serial Communications in Windows Environment

2009-04-28T04:26:00.026-04:00

“Arduino is an open-source electronics prototyping platform based on flexible, easy-to-use hardware and software.” The board can be loaded with programs simple programs developed using Arduino programming language – which is based on wiring – and Arduino IDE – based on processing, which in turn is based on Java. Arduino is mainly used for designing interactive prototypes and has the capability to be communicate with software (e.g. Flash, Java, Processing, etc) running on a computer using serial communication.
In this tutorial, I will be using Silveira Neto's tutorial as a reference and as mentioned in the title, I'll focus only to Windows environment.

Step 1: Install Arduino IDE

If you haven't installed the Arduino IDE yet, download the IDE from here. This is the latest version of Arduino as of April, 2009.

Step 2: Setup Arduino
Connect the Arduino board to a serial port on your computer using a USB. Start the Arduino program and copy the following code.


void setup(){
Serial.begin(9600);
}

void loop(){
Serial.println("Hello Java, Hi Arduino");
delay(1000);
}

This simple program basically sets up a serial communication at boud rate of 9600 and send the String “Hello Java, Hi Arduino"every 1000 milliseconds.

Upload the program onto the board by clicking the button which is marked red below. If you get any errors at this stage, check you have selected the right COM port to which your Arduino board is connected. Change the COM port by going to Tools → Serial Port on the menu bar.

Step 3: Install RXTX Library

We will be using RXTX library to for serial communication. Check if the Arduino IDE you downloaded have two important files which you will need to create a serial communication: rxtxSerial.dll, which will be in the main folder, and a jar file called RXTXcomm.jar, which will be in the lib folder. If those files are missing, download then from here.

Step 4: Create a new NetBeans project

NetBeans is a open-source IDE by Sun Microsystems. The NetBeans Platform allows applications to be developed from a set of modular software components called modules. A module is a Java archive file that contains Java classes written to interact with the NetBeans Open APIs and a manifest file that identifies it as a module. If you don't have one yet, download from here.

Create a new project at File → New Project and choose at Java at Categories and Java Application at Projects.

Chose a name for your project. In the following screenshot, the name of project is ArduinoJava

Click Finish.

Step 5: Adding external Libraries to NetBeans and setting up the working Directory

On NetBeans the Projects tab, right-click your project and choose Properties.

On the Project Properties window select the Libraries on the Categories panel and click the Add JAR/Folder button. Find where you placed your Arduino IDE installation. Inside this directory there’s a lib directory will some JAR files. Select all them and click OK.

Now, we will be using the Arduino IDE configuration for our program. So, in order to do so, the program need to know the location of configuration files. This can be achieved by assigning the current working directory to the directory of Arduino IDE. In the Project Properties window select Run at Categories panel. At Working Directory click in the Browse button and select the directory of your Arduino IDE.

Close the Project Properties window.

Step 6: Writing codes and running the program.

Copy the codes given below to the Main.java file (which is the a default file created by NetBeans with a simple class declaration and the main method.)

/*
* This class will get the input from arduino board and output
* the data to the scanner
* Code adopted from Silveira Neto
*/

package arduinojava;

import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import java.io.InputStream;
import java.io.OutputStream;
import processing.app.Preferences;

/**
*
* @author kinley tshering
*/
public class Main {

static InputStream input;
static OutputStream output;
static CommPortIdentifier portId;
static SerialPort port;

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
  //code application logic here

     Preferences.init();
     System.out.println("Using port: " + Preferences.get("serial.port"));
    try {
            portId = CommPortIdentifier.getPortIdentifier(
                   Preferences.get("serial.port"));

          //port = (SerialPort)portId.open("serial talk", 4000);
          port = (SerialPort)portId.open("", 4500);
          input = port.getInputStream();
          output = port.getOutputStream();
           port.setSerialPortParams(Preferences.getInteger("serial.debug_rate"),
                  SerialPort.DATABITS_8,
                  SerialPort.STOPBITS_1,
                  SerialPort.PARITY_NONE);

          while(true){
                      while(input.available() > 0) {
                                   System.out.print((char)(input.read()));
                       }
           }
  }
  catch(gnu.io.NoSuchPortException nsp)  {
       System.err.println("ERROR: " + nsp.getMessage());
   }
  catch(gnu.io.UnsupportedCommOperationException usp)  {
       System.err.println("ERROR: " + usp.getMessage());
   }
   catch(gnu.io.PortInUseException pie)  {
       System.err.println("ERROR: Port " + port + " is already in use\nCLose the port and restart.");
   }
   catch(java.io.IOException ioe) {
       System.err.println("IO ERROR: " + ioe.getMessage() );
   }
   catch(Exception exe) {
       System.err.println("ERROR: Unexpected error occured \n" + exe.getMessage() );
    }
}

}

Compile the code by going to Run → Built Main Project or press F11 key. After the code compiles, run the program by going to Run → Run Main Project or press F6 key. If you followed every step correctly, you will see “ Hello Java, Hi Arduino” printed every 1000 milliseconds (one second).

Step 7: Go ahead and do whatever you like.

Smart House Prototype

2009-04-22T11:09:00.009-04:00

For this project, I am supposed to control motors/fan by using Arduino. I have built a prototype of a smart house. This prototype if made practical will be able to prevent unnecessary energy wastage. The lights will turn on only when there is some person inside the room/house and the fan/AC will turn on when the room temperature reaches some limit and will turn off once the room temperature falls below certain level.

In order to achieve the above mentioned functions, I used an IR sensor to keep track of objects and a thermistor to measure the change in temperature. In order to prevent unnecessary waste of power, I used a PNP transistor which will act as a switch for the fan/AC. In doing so, I made it sure that the circuit will be completed only when the temperature reaches the critical level. Once the temperature reaches a critical level, I sent a digital signal to the base of PNP transistor which will result in the flow of current between emitter and collector of the transistor.

The main controlling component of the system is the Arduino system. The micro-controller board is loaded with the program written below in arduino language. The code is provided below:


/*
* SmartHouse(Project III: Physical Computing)
*
* Analog input: One IR sensor, One Thermistor
* Digital output: Fan controlled by NPN transistor, LED
* 
* @author Kinley Tshering
* @instructor Prof. Harris
*/
int transistorPin = 3;   // to transistor base
int ledPin = 5;               // to LED
int presence = 0;          //value obtained from the IR distance sensor
int heat = 0;                  //value obtained from thermistors

//set up the system
void setup() {
   //instantiate the serial communication at 96000 baud rate
  Serial.begin(9600);
 // set  the transistor pin as output
 pinMode(transistorPin, OUTPUT);
 // set  the LED pin as output
 pinMode(ledPin, OUTPUT);
}


void loop() {

 //read the value of IR sensor
 presence = analogRead(3);

 //read the value of Thermistor
 heat = analogRead(2);

 //digitalWrite(ledPin, LOW);

 if(presence > 150) {
   digitalWrite(ledPin, LOW);
 
   if(heat > 40) {
       digitalWrite(transistorPin,  HIGH);
       delay(10);
       digitalWrite(transistorPin, LOW);
       delay(10);
   }

 }

 else {
   digitalWrite(ledPin, HIGH);
 }

}

The connections and set up is shown below:

MarcoPolo

2009-04-12T06:18:00.007-04:00

This is the second project for this course. We have to turn an existing physical behavior into an interactive experience using a person's clothing or worn accessories. The electronic enhancements will have to be achieved through the use of transistors or Integrated circuit (IC).

For this project, I decided to make a simple device (a system of sensors and speakers) to help the blind people to commute. I think I will really name it MarcoPolo – as suggested by few of my classmates. Well, basically I have a system which is a collection of sensors, speakers, and transistors which are all centrally controlled by a micro-controller (Arduino). When the person wearing the device is approaches a solid object, – about 0.5 meters – the Infrared distance sensor will activate the transistor's base, which in turn will supply power to the speaker. Upon hearing the signal from the speaker, the person can avoid hitting any solid objects.

The code written in processing is provided below:


/*
* MarcoPolo(Project II: Physical Computing)
*
* Analog input: Two IR distance sensors
* Analog output: Speaker controlled by transistor
*
* @author Kinley Tshering
* @instructor Prof. Harris
*/

int speakerOut = 9; //the speaker pin
int irPin1 = 0;   //pin for sensor 1
int irPin2 = 1;   //pin for sensor 2
int sensor1Value = 0; //variable to store the value from first sensor 
int sensor2Value = 0; //variable to store the value from second sensor 

void setup() {
  pinMode(speakerOut, OUTPUT);  ///make the speaker pin as output.
  Serial.begin(9600); // Set serial out if we want debugging
}

// Set length of pause between notes
int pause = 0;
// Loop variable to increase Rest length
int rest_count = 100; 

// Initialize core variables
int tone = 0;
long duration  = 50000;


// Pulse the speaker to play a tone for a particular duration
void playTone() {
  long elapsed_time = 0;
  if (tone > 0) { 
    while (elapsed_time <>

       digitalWrite(speakerOut,HIGH);
      delayMicroseconds(tone / 2);

      // DOWN
      digitalWrite(speakerOut, LOW);
      delayMicroseconds(tone / 2);

      // Keep track of how long we pulsed
      elapsed_time += (tone);
    }
  }
  else { // Rest beat; loop times delay
    for (int j = 0; j <>
      delayMicroseconds(duration);  
    }                                
  }  
}


void loop() {
  sensor1Value = analogRead(irPin1);
   sensor2Value = analogRead(irPin2);
  
  if(sensor1Value > 150 || sensor2Value > 150)  {  //check for values
      tone = 1000;
   }
   else {
    tone = 0;  
   }

   playTone();
   delayMicroseconds(1000);
}

[Note: The detailed working (including setup) and demonstration is provided in the video which I still being uploaded by Google. ]

Project I

2009-03-18T00:18:00.005-04:00

It has only been one week (two classes of two hours each to be precise) and we have to submit the first project on the third day. In the first project, we are supposed to use Arduino inputs to control LEDs. The LED should be controlled both by a digital input as well as an analog control system.
For my project, I chose to control a series of LEDs by a switch and a Light Dependant Resistor
(LDR). The switch is the main control system – the system will work only when the switch is on) – and the time interval between the blinking of LEDs is controlled by the LDR. LDRs can sense the surrounding temperature and give a value to the program that calls it.

//The program reads the analog value from pin 3.
input = analogRead(3);

So basically the three components (LED series, LDR and circuit switch) are independent of each other. They are all connected to the Arduino which controls and makes them work in one final system.

The code - written in processing - is given below:

/*
* Blink (Project I: Physical Computing)
*
* Digital input: switch.
* Analog input: LDR (Light Dependant Resistor)
* Digitial output: 4 LEDs(Light Emiting Diodes)
* (green, yellow and red LEDs).
* @author Kinley Tshering
* @instructor Prof. Harris
*/

// the first LED to be lit/the LED which is lit currently
int currentPin = 2;

// the direction of light
boolean increase = true;

// interval between the light
float intv = 150.0;

// variable to store the value obtained from the LDR
int ldr;

// the pin which has the switch.
int switchPin = 12;

void setup(){
Serial.begin(9600);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(switchPin,ldr);
}

void loop(){ //loop through it

// if the circuit is complete around the swtich......
//light up the LCDs adjust the direction of light in the LEDs
if (digitalRead(switchPin) == HIGH){

//if the currentPin is 5 (i.e the largest value of LED),
//set increase to false
if (currentPin == 5){
increase = false;
}
//else make the increase to true.
else if (currentPin == 2){
increase = true;
}

if (increase){
currentPin++; //increment the LED to be lit
}
else{
currentPin--; //Decrement the LED to be lit
}

// turn the LED off
digitalWrite(currentPin, LOW);

// Set the delayRate based on the LDR
setInterval();

// and wait that long...
delay(intv);

// turn the LCD on.
digitalWrite(currentPin, HIGH);

} else { //the switch is off
}
}

void setInterval(){
//makes sure that the minimum value is 100.
//get the value(0 to 1023) from the LDR which is in pin 3.
ldr = 100 + analogRead(3) / 10;
intv = (float)ldr;
Serial.println(ldr);
}

Introduction

2009-03-17T15:51:00.002-04:00

I have created this blog for a class I am taking this quarter - Physical Computing. It is required for me to update my blog regularly about the progress of assignments, projects and in-class discussions.

Physical Computing (a.k.a Embedded Computing) is a branch of computing in which interactive physical systems are developed using hardware and software that can sense and respond to the analog (the actual world we are living in) world. So, sensors - senors which can sense touch, motion, light, temperature, humidity, etc - are the main component of physical computing.

Actually embedded systems are everywhere nowadays. You stay in a room for about five minutes without moving and the light turns off. You go to a mall and as soon as you are near the door, the door automatically opens itself for you. Those systems are all using sensors which which senses the action and responds accordingly.

I will be posting about my projects and assignments - design diagrams, codes, explanations, etc - using images and videos wherever possible. As of now, bye.