Project Super Crawler

Planning a head, GPS locator

2010-07-22T16:12:00.000-07:00

We have kept talking about a GPS locator on Super Crawler, so the robot can reach a point on the map using this locator. For this purpose we need to have a GPS locator installed on the robot telling our navigation program where the robot actually is on the map. But how can Super Crawler receive the coordinates ? Manual input(a semi numpad on the robot) ? Wireless communication to a WiFi unit connected to our navigation system / micro-controller ?

Today we were discussing this at the Robotica Osloensis lab and we came up with an idea that needs more time and research to find out if it is possible. We know current GPS locators in the market can have buddy units. Meaning they can know about the position of another GPS locator(at least the same brand), of-course this is possible if the other unit is willing to share its location. This means there should be a protocol/API on the system that we can use to receive the destination coordinates from the GPS sattelite. . For this purpose first we need a sender(another GPS locator which sends the information). This way, we would face one difficulty :

If our purpose is to use the GPS sattelite API/Protocols to let our system know where it should move, we need a locator ourself(at the lab). The locator would send the correct data if we are standing at the target position, but if we do not want to be at destination, we should hack the client(GPS locator), so it would send the coordinates we would want it to & not its current location(the lab).

Our plan ahead is to first give the final destination to the robot & would wait up to Super Crawler finds it way there. As a 2nd test-case we would like to test giving the navigation system a virtual path(series of locations on the map) so it would make its way up to each point on the map and then the next up to the end of the path. Anyway this is going to be cool as it gives us the chance to collect lots of statistical data out of adding this feature to Super Crawler. These statistical data can be current speed of the Super Crawler, the traversed path & even a report on Super Crawler website about the current location and the traversed map ... I have a lot in my head about these stuffs but I know one thing for now. This project is just getting cooler & cooler :-) We are now looking into some opensource technologies that help us for developing this feature for Super Crawler :

GeoServer : An open-source server written in Java which lets users to share and edit geospatial data. Designed for interoperability, it publishes data from any major spatial data source using open standards. GeoServer has evolved to become an easy method of connecting existing information to Virtual Globes such as Google Earth and NASA World Wind as well as to web-based maps such as OpenLayers, Google Maps and Bing Maps.
GeoWebCache : A product that seeks to break down the limitations of tile caching.
OpenLayers : An open source JavaScript library for displaying map data in web browsers.

Report 8 | #21st of July 2010

2010-07-21T01:11:00.000-07:00

This is the current design that the whole design team is agreeing on. We have also received the blue-prints from the company we are going to order our belts from & have customized our design to the belts we are going to get from them.

Report 7, Line Follower code

2010-07-20T15:36:00.000-07:00

Now we have coded our test chassis to follow a black line on the ground. We are facing some problems following the line on uneven fields but we are working on it ... Our test subject drives around the Robotica lab & stops when it reaches a red line or an obstacle on the way. Film & photos will soon be posted here ...

Our next step is to code our test chassis to drive around & detects objects on its way and the smart enough to drive around them. For this purpose we have bough 4 reflex detectors to have around our chassis. More updates on the way ... Click on read more for the source code in Semi C++ Arduino programing language.


int pin_7 = 7;
int sens_r = 0;
int sens_l = 1;
int velocityPin = 5;
int velocity;


boolean motorEnable = false;


//MOTOR#2 -> LEFT & RIGHT
//MOTOR#1 -> FORWARD & BACKWARD
//OUTPUT PINS
byte IN1M1 = 2;//IN1 Motor1
byte IN2M1 = 4;//IN2 Motor1
byte IN1M2 = 11;//IN1 Motor2
byte IN2M2 = 9;//IN2 Motor2
byte ENM1 = 5;//enable signal Motor1
byte ENM2 = 10;//enable signal Motor2
byte PWMM1 = 3; //PWM Motor1
byte PWMM2 = 8; //PWM Motor2
byte ledPin =  13;    // LED connected to digital pin 13

int rightSensor, leftSensor;
int order = 0;
void setup(){

  pinMode(pin_7, INPUT);
  pinMode(sens_r, INPUT);
  pinMode(sens_l, INPUT); 
  pinMode(velocityPin, INPUT);
  pinMode(IN1M1, OUTPUT);  //  MOTOR1 IN1
  pinMode(IN2M1, OUTPUT);  //  MOTOR1 IN2 
  pinMode(IN1M2, OUTPUT);  //  MOTOR2 IN1 
  pinMode(IN2M2, OUTPUT);  //  MOTOR2 IN2
  pinMode(ENM1, OUTPUT);  //  MOTOR1 Enable
  pinMode(ENM2, OUTPUT);  //  MOTOR2 Enable
  pinMode(PWMM1, OUTPUT);  //  MOTOR 1 PWM
  pinMode(PWMM2, OUTPUT);  //  MOTOR 2 PWM
  pinMode(ledPin, OUTPUT); //  LED

  digitalWrite(ENM1, HIGH);
  Serial.begin(115200);
  order = 0;


}

void loop(){
  //Value_ = digitalRead(pin_7);
  velocity = analogRead(velocityPin)/4;
  rightSensor = analogRead(sens_r);
  leftSensor = analogRead(sens_l);
  digitalWrite(IN1M1, LOW);
  digitalWrite(IN2M1, HIGH);
  analogWrite(PWMM1, velocity);
  digitalWrite(ledPin, HIGH); 
  /*Serial.print("Right sensor is :");
  Serial.println(rightSensor);
  Serial.print("Left sensor is :");
  Serial.println(leftSensor);*/
//  Serial.print("Velocity is :");
//  Serial.println(velocity);
  //delay(200);
  if(rightSensor >220 && leftSensor > 220){
        analogWrite(PWMM1, velocity+70);
        order = 3;
  }
  else if ((rightSensor < 60) && (leftSensor < 60)){
    makeItStraight();
//    Serial.println("*** BOTH ON BLACK ***");
  }
  else if ((rightSensor < 60) && (leftSensor > 60)){//RIGHT BLACK
//    Serial.print("Left sensor is ON WHITE");
//    Serial.println(leftSensor);
    order = 2;
  }
  else if ((rightSensor > 60) && (leftSensor < 60)){//LEFT BLACK
//    Serial.print("Right sensor is ON WHITE");
//    Serial.println(rightSensor);
    order = 3;
  }
  else if ((rightSensor > 60) && (leftSensor > 60)){//ALL WHITE
    makeItStraight();
//    Serial.println("*** BOTH ON WHITE ***");
    /*Serial.println("Both sensors are highter than 200 -> the values are :");
    Serial.print("Left sensor is :");   
    Serial.println(rightSensor);
    Serial.print("Right sensor is : ");
    Serial.println(leftSensor);
   
    //order = 4;*/
  }
  comm();
  order = 0;
//  delay(50);
}

//***********************************

void comm()
{
    switch(order)
    {
    case 4://Forward, F pressed
//       Serial.println( "F pressed" );
       digitalWrite(IN1M1, LOW);
       digitalWrite(IN2M1, HIGH);
       digitalWrite(ENM1, HIGH);
       //digitalWrite(PWMM1,HIGH);
       analogWrite(PWMM1, velocity);
       digitalWrite(ledPin, HIGH);
       break;
     
    case 1://Back, B pressed
//       Serial.println( "B pressed" );     
       digitalWrite(IN1M1, HIGH);
       digitalWrite(IN2M1, LOW);
       digitalWrite(ENM1, HIGH);
       analogWrite(PWMM1, velocity);
       //digitalWrite(PWMM1,HIGH);
       digitalWrite(ledPin, HIGH);
       break;
     
    case 2://Right, R pressed
//       Serial.println( "R pressed" );
       digitalWrite(IN1M2, HIGH);
       digitalWrite(IN2M2, LOW);
       digitalWrite(ENM2, HIGH);
       analogWrite(PWMM2, 200);   
       digitalWrite(ledPin, HIGH);   
       break;     
     
    case 3://Left, L pressed
//       Serial.println( "L pressed" );
       digitalWrite(IN1M2, LOW);
       digitalWrite(IN2M2, HIGH);
       digitalWrite(ENM2, HIGH);
       analogWrite(PWMM2, 200);
       digitalWrite(ledPin, HIGH);   
       break;
    }
}

//***************** COMM     *****************************
//********************************************************
//***************** STOPCAR ******************************
void stopCar(){
  digitalWrite(13, LOW);
  digitalWrite(ENM1, LOW);
  digitalWrite(ENM2, LOW);
  order = 0 ;
  Serial.println( "Reseting the system");
  //delay(500);
}//end of stop
//************* STOPCAR ******************************
//****************************************************
//************* makeItStraight ***********************
void makeItStraight(){
  digitalWrite(ENM2, HIGH);
  digitalWrite(IN1M2, LOW);
  digitalWrite(IN2M2, LOW); 
  digitalWrite(ENM2, LOW);
  Serial.println( "Straighting the wheels");
  //delay(500);
}//end of stop

Report 6, Design phase

2010-07-17T15:32:00.000-07:00

Design phase :
We already have made a fast prototype in cardboard as reported before and now came up with different designs in 3D. Regarding the belts we have two scenarios which are based on the Robin group decision on printing our belt design or not.
1 - Our first scenario is that the Robin group would print out our belt design.
2 - The other scenario is to buy belts from the market.

Now we are waiting for Mats Høvin to come back from his holidays & see if we can get his approval to print out our own belt design ? At the same time we are ready for the other scenario which is to buy a product. We are looking around for the available belts in the market :

More updates on the way ...

Report 5 | #8th of July 2010, Fast prototyping of our design in cartong

2010-07-08T15:42:00.000-07:00

we have made this as a fast prototype of our design ...

Published with Blogger-droid v1.4.4

Re: Report 4 | #4th of July 2010

2010-07-04T02:09:00.000-07:00

This is the code that we have used for remote controlling our car with help of Arduino board. We have used a infrared receiver on the car, connected to Analog input of Arudino sending in the Analog signal. We have analysed the way the receiver is giving out feedback signals on the analog input according to the buttons being pressed on the remote control. According to our analysis we have a state machine which sets the state of the program and then a function called "comm" which actually sends the order to the DC motors according to the states.

[code]
int pin_7 = 7;

boolean motorEnable = false;

//OUTPUT PINS
byte IN1M1 = 2;//IN1 Motor1
byte IN2M1 = 4;//IN2 Motor1
byte IN1M2 = 11;//IN1 Motor2
byte IN2M2 = 12;//IN2 Motor2
byte ENM1 = 5;//enable signal Motor1
byte ENM2 = 10;//enable signal Motor2
byte PWMM1 = 3; //PWM Motor1
byte PWMM2 = 9; //PWM Motor2
byte ledPin = 13; // LED connected to digital pin 13

int Value_;
int count[2];
int i = -1;
int old_Value=1;
boolean chk=false;
int order = 0;
int sum = 0;
int stopCounter = 0;

void setup(){

pinMode(pin_7, INPUT);
pinMode(IN1M1, OUTPUT); // MOTOR1 IN1
pinMode(IN2M1, OUTPUT); // MOTOR1 IN2
pinMode(IN1M2, OUTPUT); // MOTOR2 IN1
pinMode(IN2M2, OUTPUT); // MOTOR2 IN2
pinMode(ENM1, OUTPUT); // MOTOR1 Enable
pinMode(ENM2, OUTPUT); // MOTOR2 Enable
pinMode(PWMM1, OUTPUT); // MOTOR 1 PWM
pinMode(PWMM2, OUTPUT); // MOTOR 2 PWM
pinMode(ledPin, OUTPUT); // LED
Serial.begin(115200);
order = 0;

}

void loop(){

Value_ = digitalRead(pin_7);

if(i != 2){

if(Value_ - old_Value == -1){
chk=true;
i++;
}
if (chk == true) count[i]++;

if(Value_ - old_Value == 1){
chk=false;
}
}
if(i==2 && Value_ - old_Value == 1 ){
i=-1;
Serial.println(count[0]);
Serial.println(count[1]);
Serial.println(".......");

if ((count[0] < 100) && (count[1] > 400)){
order = 1;
sum = 50;
Serial.println("setting 1");
Serial.println(".......");
}
else if (abs(count[0] - count[1]) < 15){ order = 4; sum = 50; Serial.println("setting 4"); Serial.println("......."); } else if ((count[0] > 160) && (count[1] > 230)){
order = 2;
Serial.println("setting 2");
Serial.println(".......");
}
else if ((count[0] < 100) && (count[1] < 270)){
order = 3;
Serial.println("setting 3");
Serial.println(".......");
}
else{
Serial.println("NONE");
Serial.print("*order is : ");
Serial.println(order);
Serial.println(".......");
}
comm();
count[0]=0;
count[1]=0;
chk=false;
}

old_Value = Value_;
if (Value_ == 1 && old_Value == 1)
stopCounter++;
else
stopCounter = 0;
if (stopCounter == 5000){
stopCar();
/*Serial.print("*** STOPPING THE CAR ");
Serial.println(".......");*/

}

}

//***********************************

void comm()
{
switch(order)
{

case 4://Forward, F pressed
Serial.println( "F pressed" );
digitalWrite(IN1M1, LOW);
digitalWrite(IN2M1, HIGH);
digitalWrite(ENM1, HIGH);
//digitalWrite(PWMM1,HIGH);
analogWrite(PWMM1, 70);
digitalWrite(ledPin, HIGH);
break;

case 1://Back, B pressed
Serial.println( "B pressed" );
digitalWrite(IN1M1, HIGH);
digitalWrite(IN2M1, LOW);
digitalWrite(ENM1, HIGH);
analogWrite(PWMM1, 70);
//digitalWrite(PWMM1,HIGH);
digitalWrite(ledPin, HIGH);
break;

case 2://Right, R pressed
//Serial.println( "R pressed" );
digitalWrite(IN1M2, HIGH);
digitalWrite(IN2M2, LOW);
digitalWrite(ENM2, HIGH);
analogWrite(PWMM2, 200);
digitalWrite(ledPin, HIGH);
delay(100);
digitalWrite(ENM2, LOW);
break;

case 3://Left, L pressed
//Serial.println( "L pressed" );
digitalWrite(IN1M2, LOW);
digitalWrite(IN2M2, HIGH);
digitalWrite(ENM2, HIGH);
analogWrite(PWMM2, 200);
digitalWrite(ledPin, HIGH);
delay(100);
digitalWrite(ENM2, LOW);
break;
}
}

//***************** COMM *****************************
//********************************************************
//***************** STOPCAR ******************************
void stopCar(){
digitalWrite(13, LOW);
digitalWrite(ENM1, LOW);
digitalWrite(ENM2, LOW);
//Serial.print( "Reseting the system");
}//end of stop
[/code]

Report 3 | #4th of July 2010

2010-07-04T02:06:00.000-07:00

The code that controls our test chassis from Java GUI that we have designed at the summer project team of Robotica Oslonesis. Special thanks to [b]Ehab[/b] who did most of the job in designing the GUI/debugging and making the moves as smooth as possible :-) We believe our code still is not perfect and we are going to keep working on it ...

The code is consist of 3 classes(Main, Frame & arudinoCom)

Download the files ...

Main.java
[code]
public class Main {

static arduinoCom myArduino;

public static void main(String[] args){

Frame main = new Frame();

}//end of frame
}
[/code]

[b]Frame.java[/b]
[code]
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;

class Frame extends JFrame implements MouseListener, KeyListener {

JButton ButtonF, ButtonB, ButtonR, ButtonL, ButtonS;
JLabel x, Aspeed, Dspeed;
int speed;
boolean exit;
JPanel baby;

arduinoCom myArduino;

public Frame()
{
speed = 0;
setTitle("Vehicle Control Window");
setSize(500,600);
setBackground(Color.BLACK);
exit=false;

addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
exit = true;
System.exit(0);
}
} );
start();
}

public void ButtonFmousePressed(MouseEvent e){
myArduino.sendData('F');

/*int x = e.getButton();
int y = e.getButton() ;

System.out.println(x);
System.out.println(y);
if (x>199 && x<301 && y>349 && y<451) myArduino.sendData('F'); else if (x>200 && x<302 && y>450 && y<552) myArduino.sendData('B'); else if (x>99 && x<201 && y>450 && y<552) myArduino.sendData('L'); else if(x>300 && x<403 && y>450 && y<552) myArduino.sendData('R'); */ } public void ButtonBmousePressed(MouseEvent e){ myArduino.sendData('B'); } public void ButtonRmousePressed(MouseEvent e){ myArduino.sendData('R'); } public void ButtonLmousePressed(MouseEvent e){ myArduino.sendData('L'); } public void ButtonFmouseReleased(MouseEvent e) { myArduino.sendData('r'); /* int x = e.getXOnScreen(); int y = e.getYOnScreen(); if (x>199 && x<301 && y>349 && y<451) myArduino.sendData('r'); else if (x>200 && x<302 && y>450 && y<552) myArduino.sendData('r'); else if (x>99 && x<201 && y>450 && y<552) myArduino.sendData('L'); else if(x>300 && x<403 && y>450 && y<552)
myArduino.sendData('R');

*/
}

public void mouseClicked(MouseEvent e){
}
public void mouseEntered(MouseEvent e){
}
public void mouseExited(MouseEvent e){
}
public void mousePressed(MouseEvent e){
}
public void mouseReleased(MouseEvent e){
}

public void keyPressed(KeyEvent e){

System.out.println(e.getKeyChar() + " djgdub");

}
public void keyReleased(KeyEvent e){

}
public void keyTyped(KeyEvent e){
}

public void ButtonBmouseReleased(MouseEvent e) {

myArduino.sendData('r');
}

public void start(){

myArduino = new arduinoCom();
myArduino.start("COM7", 9600);

baby = new JPanel(new GridLayout());
baby.setBackground(Color.BLACK);
baby.setFocusable(true);

x = new JLabel("Controls");
x.setVerticalAlignment(SwingConstants.TOP);
//x.setHorizontalAlignment(SwingConstants.RIGHT);
x.setLocation(140, 10);
x.setFont(new Font("GENEVA", Font.BOLD, 20));
x.setForeground(Color.WHITE);

Dspeed = new JLabel("Desired Speed");
Dspeed.setFont(new Font("SansSerif", Font.BOLD, 16));
Dspeed.setVerticalAlignment(SwingConstants.CENTER);
Dspeed.setHorizontalAlignment(SwingConstants.LEFT);
Dspeed.setLocation(10, 200);
Dspeed.setForeground(Color.WHITE);

Aspeed = new JLabel("Actual Speed");
Aspeed.setFont(new Font("SansSerif", Font.BOLD, 16));
Aspeed.setVerticalAlignment(SwingConstants.CENTER);
Aspeed.setHorizontalAlignment(SwingConstants.RIGHT);
Aspeed.setLocation(300, 200);
Aspeed.setForeground(Color.WHITE);

ButtonF = new JButton("Forward");
ButtonF.setFont(new Font("SansSerif", Font.BOLD, 14));
ButtonF.setLocation(200,350);
ButtonF.setSize(100,100);
ButtonF.setFocusable(false);

ButtonB = new JButton("Reverse");
ButtonB.setFont(new Font("SansSerif", Font.BOLD, 14));
ButtonB.setLocation(201,451);
ButtonB.setSize(100,100);
ButtonB.setFocusable(false);

ButtonR = new JButton("Right");
ButtonR.setFont(new Font("SansSerif", Font.BOLD, 14));
ButtonR.setLocation(302,451);
ButtonR.setSize(100,100);
ButtonR.setFocusable(false);

ButtonL = new JButton("Left");
ButtonL.setFont(new Font("SansSerif", Font.BOLD, 14));
ButtonL.setLocation(100,451);
ButtonL.setSize(100,100);
ButtonL.setFocusable(false);

ButtonF.addMouseListener(new MouseAdapter(){
public void mousePressed(MouseEvent e){
ButtonFmousePressed(e);
}
public void mouseReleased(MouseEvent e){
ButtonFmouseReleased(e);
}
});

ButtonB.addMouseListener(new MouseAdapter(){
public void mousePressed(MouseEvent e){
ButtonBmousePressed(e);
}
public void mouseReleased(MouseEvent e){
ButtonBmouseReleased(e);
}
});

ButtonL.addMouseListener(new MouseAdapter(){
public void mousePressed(MouseEvent e){
ButtonLmousePressed(e);
}
});

ButtonR.addMouseListener(new MouseAdapter(){
public void mousePressed(MouseEvent e){
ButtonRmousePressed(e);
}
});

/*

ButtonF.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {
System.out.println(e.getSource());
//myArduino.sendData('F');
}
});
ButtonL.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {
ButtonL.setForeground(Color.RED);
myArduino.sendData('L');
}
});
ButtonB.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {
ButtonB.setForeground(Color.RED);
myArduino.sendData('B');
}
});
ButtonR.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {
ButtonR.setForeground(Color.RED);
myArduino.sendData('R');
}
});
*/
addMouseListener(this);

baby.addKeyListener(new KeyListener() {

@Override
public void keyTyped(KeyEvent e) {
// TODO Auto-generated method stub

}

@Override
public void keyReleased(KeyEvent e) {
myArduino.sendData('r');

}

@Override
public void keyPressed(KeyEvent e) {
int x = e.getKeyCode();
if (x==37)
myArduino.sendData('L');
else if(x==38)
myArduino.sendData('F');
else if(x==39)
myArduino.sendData('R');
else if(x==40)
myArduino.sendData('B');

}
});

add(ButtonF);
add(ButtonB);
add(ButtonR);
add(ButtonL);
getContentPane().add(baby);
baby.add(x);
baby.add(Aspeed);
baby.add(Dspeed);

//this.repaint();
this.setVisible(true);

while(exit != true){
//update current speed
this.repaint();
}
}

}
[/code]

[b]arduinoCom.java[/b]
[code]//This class:
// - Starts up the communication with the Arduino.
// - Reads the data coming in from the Arduino and
// converts that data in to a useful form.
// - Closes communication with the Arduino.

//Code builds upon this great example:
//http://www.csc.kth.se/utbildning/kth/kurser/DH2400/interak06/SerialWork.java
//The addition being the conversion from incoming characters to numbers.

//Load Libraries
import java.io.*;
import java.util.TooManyListenersException;

//Load RXTX Library
import gnu.io.*;

class arduinoCom implements SerialPortEventListener
{

//Used to in the process of converting the read in characters-
//-first in to a string and then into a number.
String rawStr="";

//Declare serial port variable
SerialPort mySerialPort;

//Declare input steam
InputStream in;
OutputStream out;

boolean stop=false;

//This open's the communcations port with the arduino
public void start(String portName,int baudRate)
{

stop=false;
try
{
//Finds and opens the port
CommPortIdentifier portId = CommPortIdentifier.getPortIdentifier("COM7");
mySerialPort = (SerialPort)portId.open("my_java_serial" + "COM7", 2000);
System.out.println("Serial port found and opened");

//configure the port
try
{
mySerialPort.setSerialPortParams(baudRate,
mySerialPort.DATABITS_8,
mySerialPort.STOPBITS_1,
mySerialPort.PARITY_NONE);
System.out.println("Serial port params set: "+baudRate);
}
catch (UnsupportedCommOperationException e)
{
System.out.println("Probably an unsupported Speed");
}

//establish stream for reading from the port
try
{
in = mySerialPort.getInputStream();
out = mySerialPort.getOutputStream();
}
catch (IOException e)
{
System.out.println("couldn't get streams");
}

// we could read from "in" in a separate thread, but the API gives us events
try
{
mySerialPort.addEventListener(this);
mySerialPort.notifyOnDataAvailable(true);
System.out.println("Event listener added");
}
catch (TooManyListenersException e)
{
System.out.println("couldn't add listener");
}
}
catch (Exception e)
{
System.out.println("Port in Use: "+e);
}
}

//Used to close the serial port
public void closeSerialPort()
{
try
{
in.close();
stop=true;
mySerialPort.close();
System.out.println("Serial port closed");

}
catch (Exception e)
{
System.out.println(e);
}
}

//Method sends a character
public void sendData(char ch)
{
try
{
System.out.println("We are in sendData");
out.write('V');
out.write('4');
out.write('0');
out.write('#');
out.write(ch);
}
catch (Exception e)
{
System.out.println(e);
}
}

/*
This method reads the characters sent by the arduino
The Arduino output looks like this:

128.43A153.25B0.84C242.62D0.63E128.43A153.25B0.84C242.62D0.63E128.43A153.25B0.84C242.62D0.63E

The method below divides this continuous stream of characters send by the Arduino into values
The letter after the numbers plus decimal point identifies the numbers and decimal point that
preceded it.

So:

128.43A: value = 128.43 with identifier A (A in this case is real power)

Lets go through this in further detail:

Program recieves characters one after the other like this:
ch = 1 - isDigit(ch) = true and so it is added to the string rawStr
ch = 2 - isDigit(ch) = true and so it is added to the string rawStr
ch = 8 - isDigit(ch) = true and so it is added to the string rawStr
ch = . - isDigit(ch) = false but we check if ch='.' and if so it is added to the string rawStr
ch = 4 - isDigit(ch) = true and so it is added to the string rawStr
ch = 3 - isDigit(ch) = true and so it is added to the string rawStr
ch = A - isDigit(ch) = false but - isLetter(ch) = true and so we then convert the rawStr that is now "128.43" to a double with double value = Double.parseDouble(rawStr);
Now we have a value with an identifier and we then print the value to terminal but we could just as well
if (ch=='A') realPower = value;

The last thing we do is reset rawStr="" and then the above process is repeated.

*/
public void serialEvent(SerialPortEvent event)
{

//Reads in data while data is available
while (event.getEventType()== SerialPortEvent.DATA_AVAILABLE)
{
try
{
//-------------------------------------------------------------------

//Read in the available character
//System.out.println("Inside SerialPortEvetn");
char ch = (char)in.read();
if (ch == 'x')
System.out.print(ch);
break;
}
catch (IOException e)
{
}
}//end of while

}
}[/code]

Report #2nd of July 2010

2010-07-02T03:04:00.000-07:00

[b]*** NEWS :[/b] 3 more members have joined us :-) Two have been to Kick-start meetings before, but one(Ehab) is a new member :-)

We are already finished with programing the micro-controller(Arduino card) and right now we are working on the navigation program with Java. The program writes forth and read back from USB port.
The following code is developed in Arduino C language and is written for two motors which one(MOTOR#2) is connected to the front wheels controlling LEFTWARDS & RIGHTWARDS movement and the other(MOTOR#1) which controls the SPEED, and FORWARDS & BACKWARDS movement. The program can receive characters from USB port which according to those will enter different phases :

F - Moving Forward(Change the mode in Motor#1)
B - Moving Backward(Change the mode in Motor#1)
S - Moving Straight(Change the mode in Motor#2)
R -Moving Right(Change the mode in Motor#2 & does not change anything about Motor#1)
L - Moving Left(Change the mode in Motor#2 & does not change anything about Motor#1)
r - Resets everything & STOPS all the motors
V(speed)# - Sets the speed(PWM value) - Ex : V45# OBS : Be careful not to crash into the wall, driving with too high speed :-D We did it :-D

This ability to read & write from the USB port has made it easier to control the Arduino program running on the board with a Java program. When writing the Java navigation program we came to situations which we found out that serial communication is slow and even having one print command before setting a value can mean a lot in delay concept. See following example :
[code]---------------------------------------------- EXAMPLE
Code sample 1 :
   // reset, r
   case 114:
   Serial.print( "Reseting the system");
   initFrontMotor();
   digitalWrite(13, LOW);
   digitalWrite(ENM1, LOW);
   digitalWrite(ENM2, LOW);
   break;
Code sample 2 :
   // reset, r
   case 114:
   digitalWrite(13, LOW);
   digitalWrite(ENM1, LOW);
   digitalWrite(ENM2, LOW);
   Serial.print( "Reseting the system");
   initFrontMotor();
   break;
----------------------------------------------END OF EXAMPLE[/code]
Comparing these two pieces of our code shows that moving "a print method and a small function" made a significant difference in the delay we had stopping the test subject(Thanks to Ole we fixed this bug:-)). So be careful when you writing back & forth to USB port, there is a delay and [b]every single extra line[/b] can make your test subject to crash into something or fall off the table ;-)

[b]OUR ARDUINO CODE : [/b]
[code]

boolean motorEnable = false;

//OUTPUT PINS
byte IN1M1 = 2;//IN1 Motor1
byte IN2M1 = 4;//IN2 Motor1
byte IN1M2 = 11;//IN1 Motor2
byte IN2M2 = 12;//IN2 Motor2
byte ENM1 = 5;//enable signal Motor1
byte ENM2 = 10;//enable signal Motor2
byte PWMM1 = 3; //PWM Motor1
byte PWMM2 = 9; //PWM Motor2
byte ledPin = 13; // LED connected to digital pin 13

//Analog
int sensorPin = 2; // select the input pin for the potentiometer
double sensorValue = 0.00; // variable to store the value coming from the sensor
double oldSensorValue;
int counter = 0;

void setup()
{
  Serial.begin(115200);

  //Declaring outputs
  pinMode(IN1M1, OUTPUT); // MOTOR1 IN1
  pinMode(IN2M1, OUTPUT); // MOTOR1 IN2
  pinMode(IN1M2, OUTPUT); // MOTOR2 IN1
  pinMode(IN2M2, OUTPUT); // MOTOR2 IN2
  pinMode(ENM1, OUTPUT); // MOTOR1 Enable
  pinMode(ENM2, OUTPUT); // MOTOR2 Enable
  pinMode(PWMM1, OUTPUT); // MOTOR 1 PWM
  pinMode(PWMM2, OUTPUT); // MOTOR 2 PWM
  pinMode(ledPin, OUTPUT); // LED

  //INITILIZING
  digitalWrite(IN1M1, LOW);
  digitalWrite(IN2M1, LOW);
  digitalWrite(IN1M2, LOW);
  digitalWrite(IN2M2, LOW);
  digitalWrite(ENM1, LOW);
  digitalWrite(ENM2, LOW);
  digitalWrite(PWMM1, LOW);
  digitalWrite(PWMM2, LOW);
  digitalWrite(ledPin, LOW);
initFrontMotor();
  Serial.println( "Starting ..." );
}

//********************************************************
//********************************************************
//***************** LOOP *********************************

void loop()
{
  //Serial.print("x");
  if (Serial.available() > 0 )
   comm();
  //micRead();
  //Serial.print( "We are here !!!" );
/* digitalWrite(IN1M1, HIGH);
  digitalWrite(IN2M1, LOW);
  digitalWrite(IN1M2, HIGH);
  digitalWrite(IN2M2, LOW);
  digitalWrite(ENM1, HIGH);
  digitalWrite(ENM2, HIGH);
  //digitalWrite(PWMM1, HIGH);
  analogWrite(PWMM1, 150);
  //digitalWrite(PWMM2, HIGH);
  analogWrite(PWMM2, 80);
  digitalWrite(ledPin, HIGH);*/
}
//***************** LOOP *********************************
//********************************************************
//***************** COMM *****************************

void comm()
{
  int lastPosition = 0;
  byte value = Serial.read();
  int counter = 1;
  int sum = 0;
  char temp;

   switch(value)
   {
   // reset, r
   case 114:
   digitalWrite(13, LOW);
   digitalWrite(ENM1, LOW);
   digitalWrite(ENM2, LOW);
   Serial.print( "Reseting the system");
   initFrontMotor();
   break;

   case 86://Velocity, V pressed
   Serial.print( "Velocity set to :" );
   temp = Serial.read();
   while (temp != '#'){
   sum = (10 * sum) + (temp - 48);
   //counter = counter * 10;
   temp = Serial.read();
   }
   Serial.print(sum);
   analogWrite(PWMM1, sum);
   break;

   case 70://Forward, F pressed
   Serial.println( "F pressed" );
   digitalWrite(IN1M1, LOW);
   digitalWrite(IN2M1, HIGH);
   digitalWrite(ENM1, HIGH);
   //analogWrite(PWMM1, 100);
   digitalWrite(ledPin, HIGH);
   break;

   case 66://Back, B pressed
   Serial.println( "B pressed" );
   digitalWrite(IN1M1, HIGH);
   digitalWrite(IN2M1, LOW);
   digitalWrite(ENM1, HIGH);
   //analogWrite(PWMM1, 100);
   digitalWrite(ledPin, HIGH);
   break;

   case 83://Straight, S pressed
   Serial.println( "S pressed" );
   if (lastPosition == 0)
   return;
   else if (lastPosition == 1){
   digitalWrite(IN1M2, HIGH);
   digitalWrite(IN2M2, LOW);
   }
   else if (lastPosition == 2){
   digitalWrite(IN1M2, HIGH);
   digitalWrite(IN2M2, LOW);
   }
   digitalWrite(ENM2, HIGH);
   analogWrite(PWMM2, 120);
   digitalWrite(ledPin, HIGH);
   delay(50);
   digitalWrite(ENM2, LOW);
   lastPosition = 0;
   break;

   case 82://Right, R pressed
   Serial.println( "R pressed" );
   lastPosition = 1;
   digitalWrite(IN1M2, HIGH);
   digitalWrite(IN2M2, LOW);
   digitalWrite(ENM2, HIGH);
   analogWrite(PWMM2, 200);
   digitalWrite(ledPin, HIGH);
   delay(100);
   digitalWrite(ENM2, LOW);
   break;

   case 76://Left, L pressed
   Serial.println( "L pressed" );
   lastPosition = 2;
   digitalWrite(IN1M2, LOW);
   digitalWrite(IN2M2, HIGH);
   digitalWrite(ENM2, HIGH);
   analogWrite(PWMM2, 200);
   digitalWrite(ledPin, HIGH);
   delay(100);
   digitalWrite(ENM2, LOW);
   break;
   }
}

//***************** COMM *****************************
//********************************************************
//****************** INITIAL FRONT MOTOR *****************
void initFrontMotor(){
   Serial.println( "Initializing" );
   digitalWrite(IN1M2, HIGH);
   digitalWrite(IN2M2, LOW);
   digitalWrite(ENM2, HIGH);
   analogWrite(PWMM2, 120);
   digitalWrite(ledPin, HIGH);
   delay(50);
   digitalWrite(IN1M2, HIGH);
   digitalWrite(IN2M2, LOW);
   analogWrite(PWMM2, 120);
   digitalWrite(ledPin, HIGH);
   delay(50);
   digitalWrite(ENM2, LOW);
}
[/code]
Members developing the code : Puya, Shahab B., Ramtin, Ehab, Shahab F. + Special thanks to Ole for help :-)
Up to now no problems that we could not solve and we have found our way with reverse engineering, asking others for help and creativity :-)

Soon we are finished developing the navigation program and will post it here ...

[b]*** REMEMBER THAT IT IS NEVER LATE TO JOIN US. WE CAN TEACH YOU WHAT WE HAVE BEEN THROUGH & WE ARE LEARNING BY TRYING, SO COME & JOIN. OUR GOAL IS TO TRAIN MEMBERS FOR FURTHER PROJECTS IN FALL 2010 ***[/b]

We also have had a workshop about 3D design in Solidworks & Arduino programing.

Re: Report 1 | #25th of June 2010

2010-06-25T03:49:00.000-07:00

Current situation :

We are right now able to control the DC-motors with given speed. Our test chassis can drive forward, backwards, to right and to left. We also have begun some experiences on starting the motors in different directions according to the input sound signal(This experiment is not useful for our summer-project but maybe for fall-projects which are based on sound signals mostly).

This is a very simple code on how to control a DC motor with sound signal :
*** THE CODE IS VERY MESSY ***

[code]

int ledPin = 13; // LED connected to digital pin 13
boolean motorEnable = false;

int sensorPin = 2; // select the input pin for the potentiometer
double sensorValue = 0.00; // variable to store the value coming from the sensor

//motordriver POLULU MD05A:
int IN1_Motor = 11;//direction of motor
int IN2_Motor = 12;//direction of motor
int D2_Motor = 9;//PWM for motor
int D1 = 5;//set to LOW
int EN = 11;//enable signal

int P;
int pwm;
int stepCounter;

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

  pinMode(2, INPUT); // ENCODER kanal A (sort strompe)
  pinMode(3, INPUT); // ENCODER kanal B

  pinMode(9, OUTPUT); // MOTOR PWM
  pinMode(10, OUTPUT); // MOTOR IN2
  pinMode(11, OUTPUT); // MOTOR EN
  pinMode(12, OUTPUT); // MOTOR IN1

  pinMode(13, OUTPUT); // LED

  digitalWrite(9, LOW);
  digitalWrite(10, LOW);
  digitalWrite(11, LOW);
  digitalWrite(12, LOW);

  //Serial.println( "For help press V");
}

//********************************************************
//********************************************************
//***************** LOOP *********************************

void loop()
{
  if (Serial.available() > 0 )
   comm();
   micRead();
   //readFromEncoder();
}
//***************** LOOP *********************************
//********************************************************
//***************** COMM *****************************
double oldSensorValue;
int counter = 0;
void micRead()
{
  counter = counter + 1;
  oldSensorValue = sensorValue;
  sensorValue = analogRead(sensorPin);
   //Serial.println(sensorValue - oldSensorValue);
  if ( sensorValue - oldSensorValue > 40 && counter != 1){
   Serial.print( "Someones is clapping : " );
   Serial.println(sensorValue);
   eventCall();
  }
}
int flag = 0;
void eventCall(){
   flag++;
   if (flag%4 == 1){
   digitalWrite(10, HIGH);
   digitalWrite(11, HIGH);
   digitalWrite(12, LOW);
   digitalWrite(9, HIGH);
   Serial.println("Moving counter-clockwise");
   Serial.println(flag);
   delay(2000);
   return;
   }
   if (flag%2 == 0){
   digitalWrite(11, LOW);
   Serial.println("Stopping the DC motor");
   Serial.println(flag);
   delay(2000);
   return;
   }
   if (flag%4 == 3){
   digitalWrite(10, LOW);
   digitalWrite(11, HIGH);
   digitalWrite(12, HIGH);
   digitalWrite(9, HIGH);
   Serial.println("Moving clockwise");
   Serial.println(flag);
   delay(2000);
   return;
   }

   /* break;


   Serial.println( "B pressed" );
   digitalWrite(10, LOW);
   digitalWrite(12, HIGH);
   digitalWrite(9, HIGH);
   break;*/
}//end of eventCall

void comm()
{
  byte value = Serial.read();

   switch(value)
   {
   // reset, r
   case 114:
   Serial.print( "Reseting the system");
   digitalWrite(10, LOW);
   digitalWrite(11, LOW);digitalWrite(13, LOW);
   digitalWrite(12, LOW);
   break;

   // STOP motor av på, S
   case 83:
   motorEnable = !motorEnable;

   if (motorEnable == true)
   {
   digitalWrite(11, HIGH); digitalWrite(13, HIGH);
   }
   else
   {
   digitalWrite(10, LOW);
   digitalWrite(11, LOW);digitalWrite(13, LOW);
   digitalWrite(12, LOW);
   }

   Serial.print( "motorEnable= ");
   Serial.println( (int)motorEnable);

   break;

   // ber om alle variable, ?
   case 63:
   Serial.println("******************************");
   Serial.print( "Motor mode :");
   Serial.println( (int)motorEnable);
   Serial.println("******************************");
   break;
   //W
   case 87:
   sensorValue = analogRead(sensorPin);
   Serial.print( "Analogue read is " );
   Serial.println(sensorValue);
   break;

   case 70:
   Serial.println( "F pressed" );
   digitalWrite(10, HIGH);
   digitalWrite(12, LOW);
   digitalWrite(9, HIGH);
   break;

   case 66:
   Serial.println( "B pressed" );
   digitalWrite(10, LOW);
   digitalWrite(12, HIGH);
   digitalWrite(9, HIGH);
   break;
   }
}

//***************** COMM *****************************
//********************************************************
//********************************************************

[/code]

Members developing the code : Puya, Shahab F.

Later updates coming soon ...

Workshop for Super Crawler team in Solidworks & Arduino

2010-06-08T14:22:00.001-07:00

The chosen day is 1st of july 15:30 when everyone can take part in the workshop.

New teams for Super Crawler

2010-05-22T07:49:00.000-07:00

New teams for Super Crawler Project :

Design / Redesign :
Magnus, Shahab F., Andre
Belts :
Magnus
Micro-controller Programming :
Puya, Jonas, Ole Marius, Shahab F., Magnus
Navigation Program :
Shahab F., Jonas, Shahab B.
Video Streaming :
Jonas, Ole Marius, Shahab F.

The goal of these groups are to make the first version of Super Crawler, which is a simple remote controlled robot which can do the following operations :

Drives around (Not autonomous)
Controlled of a remote control system
Send back a video report to a computer at the Robotica Osloensis robotic lab

Design / Redesign :

We use SolidWorks as our CAD program. Design of a chassis for Super Crawler. The current chassis is designed and 70% finished, but there are still things to be done ... Solidworks tutorials can be found both on Internet and on Youtube.

Belts :

Belts are 90% finished, but still there are things to be done before we reach the actual printig pahse.

Micro-controller Programming :

We are going to use Arduino cards and the programming language will be a simplified C which is designed by Arduino for programing on their products ... Current package solution can be seen here.

The Navigation/Controller Program

The environment and programming language for this program is yet to be chosen by the team. The alternatives are Java, Matlab or Max MSP.

Video Streaming :

The limitation of this part of project is up to the team. The goal is to send a video report back to the lab and even if we can do it with choosing the right technology and the right application it is enough for us. But this can be extended to applications being written for Gstreamer or under MPEG-21 standards.

Team Building meeting presentation

2010-05-22T04:13:00.000-07:00

Super Crawler will soon get new team members

2010-05-10T06:35:00.000-07:00

This project is going to be transfered to Robotica Osloensis, the student robotic community at university of Oslo. Our aim is to set up different teams to work on Super Crawler project together and finish it as soon as possible as the first robotic project for Robotica Osloensis.
If you are interested in cooperating with us, don't hesitate to contact us :-)
Want to show up in team building meeting, click here.

Project KICK-OFF, Robotica Osloensis

2010-05-09T02:25:00.000-07:00

Possible Electronic Solution

2010-05-03T06:21:00.001-07:00

Solutions for Video streaming without need for application or computer

2010-05-01T06:51:00.000-07:00

Tank Belt design w/sprockets

2010-04-12T05:47:00.000-07:00

Tank Type Design, Robot report #4

2009-08-24T02:56:00.000-07:00

Robotic Project Report #3

2009-08-16T02:55:00.000-07:00

Tank Type Design

Top Cover Sample

Robot Project Report, report #2

2009-07-27T02:54:00.000-07:00

This is the newest design of the robot chassis getting more and more closer to reallity … Now we have places for Motor#1 & #2, sprock wheels, Microcontroller and laptop inside the robot for Image Processing. The 3D design was designed at SolidWorks 2008 and will be printed by a 3D printed with a mixture of plastics material.

Live broadcast of Robot’s environment #2

2009-07-24T02:54:00.000-07:00

Well I decided to do it the hard way … Yep I did it with Java, with my own code and now I have two applications(server & client) that sends the streaming video over the whole network subnet or just one specific IP address. I am improving my code and trying to update the codes that mostly I gathered and made up from here and there … Soon I come with the source code

Image Processing

2009-07-15T02:52:00.000-07:00

The Image processing part of the Robotic project, in hardware point of view contains a camera and laptop. The laptop is placed inside the robot chassis for Image Processing applications to run on it. The camera is going to be place on an arm which is not exactly decided how it is going to be and how much would we reach to make. But for sure there is going to be an arm, probably with one prismatic and two revolute joint(we are probably going to remove one revolute joint as the robot is able to turn around itself 360 degrees). This will give the camera a very good workspace which would be alittle less than a sphere on bottom and top.

As this project is a summer project and we do not have much time left, we have decided to go for easiest solutions for time being. Everything that makes the project to take one more step toward the goal is acceptable. Now I am trying to find ways how we can broadcast the stream of video we get from Robot’s cameras online. Our choices up to now are as followed :

USTREAM.COM website which let you to stream live videos and people are able to watch it online in flash format. It’s not the best choice to make, but it is a possible choice.
RealPlayer

Project Report

2009-07-14T02:51:00.000-07:00

Well as said before, we are 4 students working on this Robotic project and things have been much more clear than the imaginary robot I was talking about last time. Now we know what kind of micro controller are we going to use, although still we have troubles setting it up(Vegard). We have designed the basic circuit for controlling the robots movement as well, but not tested yet(Kjetil). Also we are working on the body. My friend Magnus is designing the belt and the wheels ! Yep it’s gonno drive around with the help of 2 belts and 8 wheels. My responsibility is to design the chassis up to now. Here is a very basic version of it that I am just playing around to learn more how to work with Solidworks. When we are finished we are going to print this out with the help of a 3D printer that the robotic group has(in a quite nice resistible plastic material). Image processing part has not even started yet !!!

Basic Chassis with 4 holes on each sides for placing the wheels.

Haha, before I forget, Vegard wants to name robot, Superman Dunno if she is gonno be named that, but that’s what he is saying around

Early designs for Super Crawler

2009-07-05T02:42:00.000-07:00

Done by Magnus

Robotic+Image Processing summer project

2009-05-21T02:49:00.000-07:00

I am planning for a summer project these days. This semester, I have taken two difficult, but very interesting courses. These two courses are Robotics(INF3480) and Image Processing(INF2310). Although I’ve had big challenges with the good mathematical understanding of these two courses, but I am deeply interested in both and would like to combine what I’ve learnt in theory, in a practical project. The plan is to combine Robotics and Image Processing to make a portable robot with more than basic Image Processing abilities. The following drawing is just an imaginary plan of the final robot. Of course I would be happy to be able to finish half of this and I believe I would come to changes many of these fantacies with realities and there might be fundemental changes in the plan on the way. I am sure I am going to learn alot soon

Imaginary Robot

The imaginary robot is supplied by a wireless transmitter and GPS adapter(The anthenas are just symbols and are not going to be there). The robot is supposed to be portable and move around to a desired location by the help of GPS adapter. She would also be able to send the information(a film stream or even sounds) about her environment back to the lab by the help of the wireless LAN(Wireless Internet or a dedicated wireless LAN). The cameras are supposed to capture the film stream and send the perspective(Not Flat) pictures to the screen at the lab. Also same cameras will be used for Image Processing operations(locally at the robot by laptop or at the lab). The plan up here is showing that the robot actually is carrying a light Eee laptop to implement image processing at place right after they are captured by the cameras. There is also another scenario that the robot can carry just a combination of Micro Processors that sends all the information to the lab and the information would be processed in the lab and would be sent back to the robot. There would be proabably some delays and I am not sure if this system is actually practical.

I am not going to be alone at this project and I am going to have some friends with me. The plan is to do this project step by step and keep it simple at first and at every step we would try to expand our previous simple model to a more advanced one. The duration of this project would be up to the end of next semester(December 2009) and would probably will be my(an others if they are intrested to continue) bachelor project.