Walloid Porject

Thesis is handed, I am tiered ...

2012-02-02T23:57:00.000+01:00

The master thesis is handed in. I am tiered. I need some time to update contents of last months work online ... I am very tiered ...

End Effector Design

2011-09-25T14:12:00.000+02:00

Preparing for Xbee practical test for distributed embedded systems

2011-09-24T22:34:00.000+02:00

Arduino Fio(x4), Arduino Mega(x1), Arduino Ethernet shield(x1), Xbee modules(x5), Xbee shileld(x1), Xbee Explorer(x1)

Climbing gait 3D motion design, ongoing

2011-09-15T01:11:00.002+02:00

Not ready yet ...

Taking action is important

2011-09-10T19:31:00.002+02:00

To do something, however small, to make others happier and better, is the highest ambition, the most elevating hope, which can inspire a human being.
- Sir John Lubbock

Thesis progress

2011-09-08T01:18:00.002+02:00

The numbers on the right side are numbers of pages while the numbers in the bottom are the dates.

The benefits of taking action

2011-09-06T18:18:00.002+02:00

Thinking will not overcome fear but action will.
- W Clement Stone

3D visualization of the climbing gait

2011-09-06T15:56:00.000+02:00

early design

Ethics & Robotics

2011-09-04T02:16:00.002+02:00

The Three Laws of Robotics (often shortened to The Three Laws or Three Laws) are a set of rules devised by the science fiction author Isaac Asimov and later expanded upon. The rules are introduced in his 1942 short story "Runaround", although they were foreshadowed in a few earlier stories. The Three Laws are:

A robot may not injure a human being or, through inaction, allow a human being to come to harm.
A robot must obey any orders given to it by human beings, except where such orders would conflict with the First Law.
A robot must protect its own existence as long as such protection does not conflict with the First or Second Law.

Source : Wiki

Thread programming is a key element

2011-09-02T15:53:00.001+02:00

Thread programming in writing high speed stream of data is a key point in navigation systems. Effective DAQ system is critical in such systems and the idea of synchronization between different threads and the communication channels between different threads are also very important. More about this later ...

Brain storming

2011-08-26T12:48:00.000+02:00

Engineers facing the world ...

2011-08-23T02:39:00.002+02:00

Engineers believe they can fix everything and in case of failure, they are humble enough to accept carry the guilt personally and mention that it is them who can not solve the challenge, but a challenge always has a solution :-)

I like to be an engineer ;-)

:-S

2011-08-11T04:17:00.000+02:00

I feel I got a lot to do ...

Nice quote ...

2011-08-08T02:46:00.000+02:00

To solve any problem, here are three questions to ask yourself:

- First, what could I do? - Second, what could I read? - And third, who could I ask?

- Jim Rohn

Climbing patterns

2011-08-05T03:50:00.001+02:00

Fast climbing with degrees from 0 - 360 degrees

Slow climbing with either upwards and downwards, or right and left

The combination of these two types of climbing can give a combination of very fast climbing plus precise climbing when needed. Also fast climbing method gives robot the chance to move to directions from 0 - 360 degrees.

Bluetooth Technology

2011-08-05T03:05:00.001+02:00

Bluetooth uses very little energy !!! They are used in Tsunami detectors (ZIGBEE tech) ...

Advantages	Disadvantages
High throughput	Device discovery is slow in term of power usage and time
Resilience against interference	Keeping connections open is expensive in term of power usage
????????	??????????

Infrared Technology

2011-08-04T16:55:00.001+02:00

Using Infrared for connecting micro-controllers is one of the available choices of wireless intercommunication between micro-controllers. Here is a short list of challenges and the benefits that using such technology would provide us :
Advantages

Very low power requirement, hence it is best suitable for machinery with limited battery capacity, like mobile robots, laptops, pads, phones, etc.
Inexpensive -> Not a very important issue in designing a revolutionary system. The redundancy is the most important feature.
Very secure. The data flow among the source and target is unidirectional, meaning the direction of the infrared beam ensures that there in no leaked or move to nearby devices as it’s transmitted.

Disadvantages

Data transmission happens in eye sight. -> Meaning you can not have it in a big robot.
Short range communication -> Actually this is an advantage in our case, which brings more security.
Easily gets interrupted by obstacle -> Meaning you can not have it in a robot with several layers between micro-controllers. Almost any kind of obstacle interrupt the signal.
Not a good choice under extreme weather conditions(sunlight, rain, pollution etc) -> This is the most negative point for this technology not be used in an offshore robot.

Depending on the area of application Infrared might be or might not be the right choice. E.g. the short range of availability would increase our security a lot, while exactly in Walloid project the harsh weather condition is very common in future platforms. Today, there are many technologies exists that are much better than IR like Bluetooth, Wi-Fi etc.

Arduino boards LAN

2011-08-02T23:54:00.000+02:00

A wild idea which I hope it's going to work ...

Arduino LAN

It is all about making a SYSTEM !!!

2011-07-24T00:12:00.000+02:00

After visiting the Mercedes Benz factory in Bremen, and reading some articles/research papers form integrated operation in offshore world, I think the solution is all about System ... A system that can put both human controllers and robots in one system.

Simulation with Processing

2011-07-13T21:36:00.000+02:00

Snapshot of the simulation of the climbing robot

TAIL IO project

2011-06-21T20:40:00.000+02:00

TAIL Integrated Operation, is a project leaded by Statoilhydro, trying to connect offshore platforms to the onshore offices, bringing down the number of staff on platforms and let expert, regardless of where they are, to communicate with the people on site. More about this comes later ...

Source : http://www.statoil.com/en/NewsAndMedia/Multimedia/features/Pages/io.aspx

The tolerance issue in 3D printing

2011-05-10T03:56:00.000+02:00

These broken parts are gonna delay my work ...

The conjunction between the motor led and the robot body

The broken conjunction on robot body side

The broken conjunction on Motor side

Totally new printed encoder parts were received on 9th of May 2011, and one of them(picture below) was broken into two pieces while being mounted on the same day

The old broken encoder part(black one) beside the new one that was broken under mounting

Supervisor Meeting

2011-05-09T14:32:00.000+02:00

Today I had a very quick supervisor meeting with my supervisor. Results :

I got the spare part for encoders, so now I can start to test my positioning code
I got some tips about I2C technology(Several cards connected together with the same wire)
I will have wired(RxTx, I2C, Dig2Dig, etc) & wireless(Xbee, ...) networking of Arduino cards discussed in my thesis
I got tips that there are more products/technologies than Xbee
I get to write more about "Van der Waals" technology & discuss related to the conditions in offshore.

Finally OpenCV 2.1 & MS VC++ 2008 worked together ...

2011-05-05T04:12:00.001+02:00

This is OpenCV helloWord program which is an easy code that just opens one picture. Too sleepy to continue today ... OpenCV 2.2 is too much unstable and I couldn't get to make it work with MS VC++ 2010. Downgrade worked :-)

Good night

Model - Controller - View design

2011-05-03T03:27:00.001+02:00

Arduino Nano and new possibilities in electronic design

2011-04-30T21:04:00.001+02:00

The new Arduino Nano is the smallest and most versatile Arduino board yet. It contains an ATmega168 micro-controller (w/ boot loader), integrated USB (FTDI chip) w/ Mini-B jack, a full complement of i/o pins, an ICSP programming header, and on-board regulator. Measuring 0.73″ x 1.70″, it’s smaller and cheaper than the combination of Arduino Mini and Mini-USB adapter.
The possibilities that this state of art design brings to Walloid project can be new electronics design as it is now very easy to have a network of Arduino boards, communicating data, processing things faster, etc ... My previous post about I2C is about the same idea; connecting multiple Arduino boards ...

I2C

2011-04-28T12:13:00.002+02:00

I2C inter micro controller communication

First experiment, failed !!! The problem : Grounds were not connected together !!!

Second experiment, Succeeded :-)

I2C connection between one master Arduino & one Slave Arduino over a serial clock pin (SCL, pin number 4 in the picture down here, YELLOW wire) that the Arduino pulses at a regular interval, and a serial data pin (SDA, Pin number 5 in the picture down here, RED wire) over which data is sent between the two devices. Also make sure that the grounds are connected together.

Master Writer Code - Program for Arduino 1


// Wire Master Writer
// by Nicholas Zambetti 

// Demonstrates use of the Wire library
// Writes data to an I2C/TWI slave device
// Refer to the "Wire Slave Receiver" example for use with this

// Created 29 March 2006

// This example code is in the public domain.


#include 

void setup()
{
  Wire.begin(); // join i2c bus (address optional for master)
}

byte x = 0;

void loop()
{
  Wire.beginTransmission(4); // transmit to device #4
  Wire.send("x is ");        // sends five bytes
  Wire.send(x);              // sends one byte  
  Wire.endTransmission();    // stop transmitting

  x++;
  delay(500);
}

Slave Receiver Code - Program for Arduino 2




// Wire Slave Receiver
// by Nicholas Zambetti 

// Demonstrates use of the Wire library
// Receives data as an I2C/TWI slave device
// Refer to the "Wire Master Writer" example for use with this

// Created 29 March 2006

// This example code is in the public domain.


#include 

void setup()
{
  Wire.begin(4);                // join i2c bus with address #4
  Wire.onReceive(receiveEvent); // register event
  Serial.begin(9600);           // start serial for output
}

void loop()
{
  delay(100);
}

// function that executes whenever data is received from master
// this function is registered as an event, see setup()
void receiveEvent(int howMany)
{
  while(1 < Wire.available()) // loop through all but the last
  {
    char c = Wire.receive(); // receive byte as a character
    Serial.print(c);         // print the character
  }
  int x = Wire.receive();    // receive byte as an integer
  Serial.println(x);         // print the integer
}

Source : http://arduino.cc/en/Tutorial/MasterWriter

Use of FPGA, Pros & Cos vs. use of Arduino

2011-03-31T00:23:00.002+02:00

FPGA advantages

One of the main disadvantages can be complexity.

Supervisor meeting, new milestones

2011-03-29T16:00:00.000+02:00

New calculations for positioning

2011-03-18T02:01:00.002+01:00

Update : 06:01, 18.03.201, I am almost done with the C code on Arduino ... Too sleepy, going back home now ...

I should write a program that can simulate the workspace as I have no idea what are the valid points on workspace that are reachable by the feet.

----------------------

New calculations for positioning, the whole thing could not be easier than this ...

I2C Inter Board communication, Arduino

2011-03-15T05:45:00.001+01:00

http://www.arduino.cc/playground/Learning/I2C
http://en.wikipedia.org/wiki/I%C2%B2C
http://www.lammertbies.nl/comm/info/I2C-bus.html
http://absences.sofianaudry.com/en/node/10

Kinematic Calculations #2

2011-03-15T04:27:00.004+01:00

No results yet ...

OpenCV, finally configured ...

2011-03-14T01:11:00.002+01:00

After 3 days struggling and working to make OpenCV to work with any possible programming language on Windows 7, I gave up. Today I thought to try it on my Ubuntu and after couple of hours struggling finally I got it. Now I should learn how to code with processing for image processing, as a possible decision making base for the robot and of course streaming ...

this is a demo from OpenCV C++ sample library...

Challenges ...

2011-03-13T22:06:00.000+01:00

New challenges with the robot arm, while I am working with positioning. The prototype(robot arm) is not totally functional as just one of the three motors work the way it should. Problems with mechanic design, and the motor axle is worn away(3D printer product in plastic) ...

OpenCV & Positioning; Today's focus

2011-03-11T13:01:00.000+01:00

Today I'll be focusing on Positioning of a point and OpenCV(Computer Vision) with Processing. I will start to work on positioning and hope to have my first streaming ready by today or early tomorrow morning(before 7:00 a.m.), as I work usually at nights.

Zero positioning, EEPROM implementation

2011-03-10T16:09:00.003+01:00

Today I am planning to finish this one, Will come up here with code.

04:34, 11.03.2011 : I am totally finished with current positioning & Zero Positioning of the robot. I can start to call Walloid a smart system ... Even in case of loosing power, or sudden improper shutdown of program, Walloid will still be able to recover and send commands to the motors without ANY crashing fear. Very effective logging system is another specification of current system.

Java CP

Logging systems which logs everything with time in details(Translating Error codes which exist in my own defined Arduino-Java Protocol)

Arduino code :



/*
*Differences with previous code : 
* 1 - It stops when reaching negative values which result in preventing it to crash with the motor
* 2 - It stops when reaching MAX values which result in preventing the feet to go loose
* 3 - Error protocol ready
* 4 - Current positioning & Zero positioning in place :-)
*/

#include EEPROM.h


byte pinEncA[] = {3,5,7}; // digital inputs
byte pinEncB[] = {2,4,6}; // digital inputs

// MOTOR OUTPUTS
byte pinDir[] = {13,8,12}; // digital output, controls direction for motor nr. [x]
byte pinPwm[] = {10,11,9}; // analog output, controls motor speed, nr. [x]

//Global variables
int readValue;
int pwmValue;
int motorDir;
//int channelA = 2;
//int channelB = 3;
int cycle[] = {0, 0, 0};

boolean f = false, b = false, r = false, l = false;
int cyclecounter[] = {-1, -1, -1};
int cyclecounterold[] = {-1, -1, -1};

//13 , 10 right, down
//8 , 11 middle, top
//9, 12 left, down



void setup(){
  
  Serial.begin(115200);
  //Serial.print("WELCOME TO C1S0");  
  for (int i=0; i < 3; i++){
    pinMode(pinDir[i], OUTPUT);
    pinMode(pinPwm[i], OUTPUT);
    //in case, just to be sure ...
    digitalWrite(pinPwm[i], LOW);
    // just in case to be sure
    digitalWrite(pinDir[i], LOW);
    pinMode(pinEncA[i], INPUT);
    pinMode(pinEncB[i], INPUT);
    digitalWrite(pinEncA[i], LOW);
    digitalWrite(pinEncB[i], LOW);
    //cyclecounter[i] = -1;
    //cyclecounterold[i] = -1;
  }//end of for
  //findCurrentPosition();

}//end of setup()

void loop(){
    commandCenter();
    checkEncoder();
}//end of loop
int value;
void commandCenter(){
  //variables
  int temp = 0;
  if ( Serial.available() > 0 ){
    readValue = Serial.read();
  //delay(50);
    switch (readValue){
      case 'h' : //handshake
        Serial.print("h");
        delay(50);
        break;
      case 'P' : //handshake
        findCurrentPosition();
        delay(50);
        break;        
      case '0' ://motor #0
        int temp__;
        temp__ = 0;
        if(Serial.available() < 0)
          ;
        delay(500);
        temp__ = Serial.read();
        if (temp__ == 102){// -f -> forward
          //Serial.print("*** Right forward ***");
          digitalWrite(pinDir[0], LOW);
          digitalWrite(pinPwm[0], HIGH);
        }//end of if
        else if(temp__ == 98){// -b -> backward
          //Serial.print("*** Right backward ***");
          digitalWrite(pinDir[0], HIGH);
          digitalWrite(pinPwm[0], HIGH);
        }
        else{
          Serial.println("E00");
          //Serial.print(temp__);
        }
        f = false;
        b = false;
        l = true;
        r = false;
        break;
      case '1' ://motor #1
        int temp_;
        if(Serial.available() < 1)
          ;
          delay(500);
          temp_ = Serial.read();
        if (temp_ == 102){// -f
          //Serial.print("*1FW*");
          digitalWrite(pinDir[1], LOW);
          digitalWrite(pinPwm[1], HIGH);
        }//end of if
        else if(temp_ == 98){// -b
          //Serial.print("*1BW*");
          digitalWrite(pinDir[1], HIGH);
          digitalWrite(pinPwm[1], HIGH);
        }
        else{
         
          Serial.println("E00");
          //Serial.print(temp_);
        }
        f = true;
        b = false;
        l = false;
        r = false;
        break;
      case '2' ://l -> left
        temp_ = 0;
        if(Serial.available() < 1)
          ;
          delay(500);
          temp_ = Serial.read();
        if (temp_ == 102){//motor #2
          //Serial.print("*2FW*");
          digitalWrite(pinDir[2], LOW);
          digitalWrite(pinPwm[2], HIGH);
        }//end of if
        else if(temp_ == 98){// -b
          //Serial.print("*2BW*");
          digitalWrite(pinDir[2], HIGH);
          digitalWrite(pinPwm[2], HIGH);
        }
        else{
          Serial.println("E00");
          //Serial.print(temp_);
        }        
        f = false;
        b = false;
        l = false;
        r = true;
        break;
      case 82 : //R->RESET
        Serial.println("R");
        resetAll();
        f = false;
        b = false;
        l = false;
        r = false;
        break;
    }//end of switch  
  } 
  /*
  if (f || b || r || l){
    Serial.print("cycle[i]: ");
    convertToThreeDigits(cycle[i]);
  }//end of if
  */
}//end of commandCenter

//int angleMaalt;

void checkEncoder(){
  int A;
  int B;
  int i;
  for (i = 0; i < 3; i++){
      cyclecounterold[i] = cyclecounter[i];
      A = digitalRead(pinEncA[i]);
      B = digitalRead(pinEncB[i]);
    
      if ( (A==LOW) && (B==LOW) )
        cyclecounter[i] = 0;
      else if ( (A==LOW) && (B==HIGH) )
        cyclecounter[i] = 1;
      else if ( (A==HIGH) && (B==HIGH) )
        cyclecounter[i] = 2;
      else if ( (A==HIGH) && (B==LOW) )
        cyclecounter[i] = 3;   
    
      switch (cyclecounter[i]){
        case (0) : {
           if ( cyclecounterold[i] == 0){
              ;//Do nothing
           }
           else if ( cyclecounterold[i] == 1){
             if (cycle[i] + 1 > 213){
                 criticalSituation(i, 1);
             }
             else{
                cycle[i]++;
                saveCurrentPosition();
                Serial.print("C");
                Serial.print(i);
                Serial.print("*");            
                convertToThreeDigits(cycle[i]);
             }
           }
           else if ( cyclecounterold[i] == 2){
                Serial.println("E01");//Error reading from Encoder-
            }
           else if ( cyclecounterold[i] == 3){
             if (cycle[i] -1 < 0){
                 criticalSituation(i, 0);
             }
             else{
                cycle[i]--;
                saveCurrentPosition();
                Serial.print("C");
                Serial.print(i);
                Serial.print("*");            
                convertToThreeDigits(cycle[i]);
             }
            }
            else 
                ;//Serial.print("ERROR");
            break;
        }//end of case-0
        case (1) : {
            if ( cyclecounterold[i] == 0){
               if (cycle[i] -1 < 0){
                 criticalSituation(i, 0);
             }
             else{
              cycle[i]--;
              saveCurrentPosition();
              Serial.print("C");
              Serial.print(i);
              Serial.print("*");            
              convertToThreeDigits(cycle[i]);            
             }
            }
            if ( cyclecounterold[i] == 2){
             if (cycle[i] + 1 > 213){
                 criticalSituation(i, 1);
             }
             else{
                cycle[i]++;
                saveCurrentPosition();
                Serial.print("C");
                Serial.print(i);
                Serial.print("*");            
                convertToThreeDigits(cycle[i]);
             }
            }
            else if ( cyclecounterold[i] == 3){
                Serial.println("E01");//Error reading from Encoder-
            }
            else 
                ;//Serial.print("ERROR");
            break;
        }
        case (2) : {
            if ( cyclecounterold[i] == 1){
             if (cycle[i] -1 < 0){
                 criticalSituation(i, 0);
             }
             else{              
              cycle[i]--;
              saveCurrentPosition();
              Serial.print("C");
              Serial.print(i);
              Serial.print("*");            
              convertToThreeDigits(cycle[i]);
             }
            } 
            else if ( cyclecounterold[i] == 2)
              ;
            else if ( cyclecounterold[i] == 3){
             if (cycle[i] + 1 > 213){
                 criticalSituation(i, 1);
             }
             else{
                cycle[i]++;
                saveCurrentPosition();
                Serial.print("C");
                Serial.print(i);
                Serial.print("*");            
                convertToThreeDigits(cycle[i]);
             }
            }
            else if ( cyclecounterold[i] == 0){
                Serial.println("E01");//Error reading from Encoder-
            }
            else 
                ;//Serial.print("ERROR");
            break;
        }//end of case-2
        case(3) : {
            if (cyclecounterold[i] == 0){
             if (cycle[i] + 1 > 213){
                 criticalSituation(i, 1);
             }
             else{
                cycle[i]++;
                saveCurrentPosition();
                Serial.print("C");
                Serial.print(i);
                Serial.print("*");            
                convertToThreeDigits(cycle[i]);
             }
            }
            else if (cyclecounterold[i] == 1){
              Serial.println("E01");//Error reading from Encoder-
            }
            else if ( cyclecounterold[i] == 2){
             if (cycle[i] -1 < 0){
                 criticalSituation(i, 0);
             }
             else{              
              cycle[i]--;
              saveCurrentPosition();
              Serial.print("C");
              Serial.print(i);
              Serial.print("*");            
              convertToThreeDigits(cycle[i]);
             }
            }
            else if ( cyclecounterold[i] == 3)
              ;
            else 
              ;//Serial.print("ERROR");
            break;
        }//end of case-3
      }
  }//end of for
}//end of checkEncoder()

int criticalSituation(int motorNumber, int type){
      digitalWrite(pinPwm[motorNumber], LOW);//Setting all PWM's to LOW
      if (type == 0)
        Serial.println("E02");//*** FATAL ERROR, CRASH POSSIBLE, STOPPING MOTOR ***
      else if (type == 1)
        Serial.println("E03");//*** FATAL ERROR, ROBOT ARM MIGHT GO LOOSE, STOPPING MOTOR ***
      //Serial.print(motorNumber);
      return 0;
}//end of criticalSituation

int resetAll(){
  for (int i=0; i < 3; i++){
          digitalWrite(pinPwm[i], LOW);//Setting all PWM's to LOW
          Serial.print("C");
          Serial.print(i);
          Serial.print("=");
          convertToThreeDigits(cycle[i]);
        }//end of for
        return 0;
}//end of resetAll()


void convertToThreeDigits(int input){
  if (input >= 0 && input < 10){
    /*switch (input){
      case 0 :
        Serial.print("00");
        break;
      case 1 :
        Serial.print("01");
        break;      
      case 2 :
        Serial.print("02");
        break;      
      case 3 :
        Serial.print("03");
        break;      
      case 4 :
        Serial.print("04");
        break;      
      case 5 :
        Serial.print("05");
        break;      
      case 6 :
        Serial.print("06");
        break;      
      case 7 :
        Serial.print("07");
        break;      
      case 8 :
        Serial.print("08");
        break;      
      case 9 :
        Serial.print("09");
        break;      
      default :
        Serial.print("00");
        break;      
    }//end of switch
    */
    Serial.print("00");
    Serial.print(input);
  }
  else if ( input >= 10 && input < 100){
    Serial.print("0");
    Serial.print(input);
  }
  else{
    Serial.print(input);    
  }
}//end of convertToThreeDigits()

void saveCurrentPosition(){
  for (int i = 0; i < 3; i++){
    EEPROM.write(i, cycle[i]);
  }  
}//end of saveCurrentPosition

void findCurrentPosition(){
  for (int i = 0; i < 3; i++){
    value = EEPROM.read(i);
    cycle[i] = value;
    Serial.print("P");
    Serial.print(i);
    Serial.print("*");
    convertToThreeDigits(value);
  }
}//end of findCurrentPosition

My status on the 6th day of my holidays that I use for working on my thesis

2011-03-09T03:38:00.001+01:00

Counter code fixed in Arduino C code
Problems with wrong usage of RxTxLibrary(mis match which wasted enough of my time during 6 days ago; unstable connection from Arduino to Java Control System)
Java Simulator works fine, just need to finish the fancy java demonstration
Logging system works very good
Help through HTML file, online
Java & Arduino are communicating perfectly
Some problems with the prototype feet I have as just one motor functions
Working on positioning & zero positioning
Safety system for preventing the motor to crash backwards or too much forward

Prevention of motor crash in C, offline Robot

Prevention of motor crash in Java, online Robot, Simulation & Real world

Positioning calculations, Walloid

2011-03-07T02:45:00.004+01:00

Update 17.03.2011 : These calculations are totally wrong ... The whole concept is much easier than these things. See the new post about the positioning calculations.

-----------------------------------

Although my supervisor meant that the positioning is happening through very easy geometrical calculation but I struggled a lot to find these equations. I am soon going to code this in my program for Walloid and come up with practical results. I should thank my dear friend Puya Afsharian who helped me a lot in figuring out some of the details.

Robot ideas

2011-03-03T01:10:00.002+01:00

http://www.newscientist.com/article/mg20928015.000-sticky-feet-send-insectbot-climbing-up-the-walls.html

Ignite Oslo, Rapid Prototyping

2011-02-25T13:50:00.004+01:00

Webcam & Processing

2011-02-19T00:08:00.007+01:00

Updated, 22nd of February 2011
OpenCV seems to be the perfect tool to do the image processing calculation. A practical example.
---
Hey Shahab,
You should look at the flob library for blob detection. Its listed on the libraries page on processing.org. Its pretty simple to use. Also for better object detection, you might have more luck with openFrameworks, which is c++ based and has a better library for OpenCV.
For my project, I used the flob library and using the OSC protocol (oscp5 library for processing) I sent the data from the webcam to the sound generation program.
Using the OSC protocol you could also use something call openTSPS, by Rockwell Labs, which would be much more easier and exact since its also based on openFrameworks. So sense people with openTSPS and send the data via OSC to your program that controls the micro-controller.
Hope it helps.
Sumit
------------
On Feb 16, 2011, at 3:20 PM, Shahab F. M. wrote:
Hi.
I was wondering if u can give me some tips/tutorial links about webcam & processing. I am working on Walloid as my master thesis.
http://walloid.blogspot.com/
Shahab
Sent from my HTC

Internal Arduino Communication

2011-02-19T00:03:00.000+01:00

http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1153415010

Test units(JUnit) on the way ...

2011-02-17T22:09:00.000+01:00

Today I got some tips from a very experienced programmer who is a team leader at a leading IT consulting company here at Norway. He advised to me to no matter what have test codes in my java code. No matter what use a version control system and have a structure in my coding. I think as long as I am so keen of having things planned and well-structured I would do implement his ideas into my master thesis to have a much clear expectation from myself and be able to plan better my way ahead. I think this would also give me the chance to do implement white box testing on my code and of-course more things to write about :-)

More structured and better plans a head

2011-02-17T14:32:00.002+01:00

I need more of structure on coding and planing for my thesis. Things like simple UML diagrams that makes understanding the whole thing much easier. UML diagrams in different levels for different tasks. I also need test scripting to test my code while running it.
will be updated

Artificial Intelligence

2011-02-10T14:19:00.000+01:00

I am taking an Artificial Intelligence course at department of Informatics(INF5390), where Artificial Intelligence - A Modern Approach is the book. Our lecture believes in this book as a bible for AI and this makes it as a good reference in my master thesis as I see LOTS of similarities between what I have done/do/will do and what I learn here in an academic way. I think I can use this source both as an theory back-up for my master thesis and an explanation of my decision making process in my codes.

Zero positioning, new ideas

2011-01-20T16:25:00.002+01:00

Lately I have been working on mounting an Open Source 3D printer called RepRap(Version 1.0, Darwin). While working on it, I learnt about their brilliant idea for Zero Positioning. They use a tiny beam light sensor(Opto endstop V2.1) which is interrupted by a small stick which is connected to the moving joint. The interrupted state defines that the moving joint is in the zero position.

Picture from : RepRap Blog

What is EEPROM / E2PROM ?

2011-01-15T02:54:00.008+01:00

We do need a way to save the numbers which represents the current situation of the robot actuators somewhere(either at PC or somewhere on Arduino microcontroller, EEPROM here). This post dedicates itself to storing data on Arduino non-volatile memory and use this information for zero positioning of the moving joint. First an introduction to EEPROM from Wikipedia and later code example and links to its API's at Arduino website.

What is EEPROM ?
EEPROM (also written E²PROM and pronounced "e-e-prom," "double-e prom" or simply "e-squared") stands for Electrically Erasable Programmable Read-Only Memory and is a type ofnon-volatile memory used in computers and other electronic devices to store small amounts of data that must be saved when power is removed, e.g., calibration tables or device configuration.

When larger amounts of static data are to be stored (such as in USB flash drives) a specific type of EEPROM such as flash memory is more economical than traditional EEPROM devices. EEPROMs are realized as arrays of floating-gate transistors.

EEPROM is user-modifiable read-only memory (ROM) that can be erased and reprogrammed (written to) repeatedly through the application of higher than normal electrical voltage generated externally or internally in the case of modern EEPROMs. EPROM usually must be removed from the device for erasing and programming, whereas EEPROMs can be programmed and erased in circuit. Originally, EEPROMs were limited to single byte operations which made them slower, but modern EEPROMs allow multi-byte page operations. It also has a limited life - that is, the number of times it could be reprogrammed was limited to tens or hundreds of thousands of times. That limitation has been extended to a million write operations in modern EEPROMs. In an EEPROM that is frequently reprogrammed while the computer is in use, the life of the EEPROM can be an important design consideration. It is for this reason that EEPROMs were used for configuration information, rather than random access memory.*

Practical Information about how to get things to work :

Source Code :



#include EEPROM.h

int a = 0;
int value;

void setup()
{
Serial.begin(9600);
for (int i = 0; i < 20; i++){
    Serial.println("***");
    EEPROM.write(i, i);
  }
}

void loop()
{
  value = EEPROM.read(a);

  Serial.print(a);
  Serial.print("\t");
  Serial.print(value);
  Serial.println("***");
  a++;

  if (a == 20){
    a = 0;
    Serial.println("DONE");
    delay(5000000);
  }
}

* : Source : Wikipedia

Problem of current position in case of loosing power & possible fixes ...

2011-01-13T02:00:00.005+01:00

I think I have found my way to bear in mind the current position of the robot in case of the robot loosing power & not being able to drive itself back to the ZERO. The way is to either use the built in EEPROM(512 bytes), or other external storages which can be connected to Arduino. More info about EEPROM :

http://www.arduino.cc/playground/Main/InterfacingWithHardware#Storage

The 2nd option is to always send the position to the computer and save it somewhere there at the program(Lots of traffic on serial port, higher risk to encounter problem or missing packages).

Too tiered to fix it now ... Later ...

It matters to choose BYTE or INTEGER, BUG fixed + Handshaked protocol added

2011-01-13T01:30:00.007+01:00

Just now fixed a bug in my code. Choosing BYTE as my variable type made some confusions on startup for the program as it couldn't initialize the variable with 0 value. The problem was fixed as soon as I changed the type to INTEGER. This resulted in errors in my program as no value made some random cases to launch which was totally wrong. This means that the bug on startup of my program which I talked to my supervisor today about is fixed :-) I was thinking as it just happened on startup to be a noise or some wrong reading from ports on Arduino, but it seems to be just a confusion on defining the variable as byte !!! I have also changed the startup value from 0 to -1 which result in no possible meaningful combination ...

Differences with previous code : Handshake added, Startup bug fixed, Some changes in standard writing to serial port from Arduino side.



//the code is entering saving with Java and we are printing as little as possible in Serial ports
// Encoders inputs
byte pinEncA[] = {7,5,3}; // digital inputs
byte pinEncB[] = {6,4,2}; // digital inputs

// MOTOR OUTPUTS
byte pinDir[] = {13,8,12}; // digital output, controls direction for motor nr. [x]
byte pinPwm[] = {10,11,9}; // analog output, controls motor speed, nr. [x]

//Global variables
int readValue;
int pwmValue;
int motorDir;
//int channelA = 2;
//int channelB = 3;
int cycle[] = {0, 0, 0};

boolean f = false, b = false, r = false, l = false;
int cyclecounter[] = {0, 0, 0};
int cyclecounterold[] = {0, 0, 0};

//13 , 10 right, down
//8 , 11 middle, top
//9, 12 left, down



void setup(){
  
  Serial.begin(115200);
  Serial.println("WELCOME TO C1S0");  
  for (int i=0; i < 3; i++){
    pinMode(pinDir[i], OUTPUT);
    pinMode(pinPwm[i], OUTPUT);
    //in case, just to be sure ...
    digitalWrite(pinPwm[i], LOW);
    // just in case to be sure
    digitalWrite(pinDir[i], LOW);
    pinMode(pinEncA[i], INPUT);
    pinMode(pinEncB[i], INPUT);
    digitalWrite(pinEncA[i], LOW);
    digitalWrite(pinEncB[i], LOW);
    cyclecounter[i] = -1;
    cyclecounterold[i] = -1;
  }//end of for

}//end of setup()

void loop(){
    commandCenter();
    checkEncoder();
}//end of loop

void commandCenter(){
  //variables
  int temp = 0;
  if ( Serial.available() > 0 ){
    readValue = Serial.read();
    switch (readValue){
      case 'h' : //handshake
        Serial.println("h");
        break;
      case '0' ://motor #0
        int temp__;
        temp__ = 0;
        if(Serial.available() < 0)
          ;
        delay(500);
        temp__ = Serial.read();
        if (temp__ == 102){// -f -> forward
          Serial.println("*** Right forward ***");
          digitalWrite(pinDir[0], LOW);
          digitalWrite(pinPwm[0], HIGH);
        }//end of if
        else if(temp__ == 98){// -b -> backward
          Serial.println("*** Right backward ***");
          digitalWrite(pinDir[0], HIGH);
          digitalWrite(pinPwm[0], HIGH);
        }
        else{
         
          Serial.print("error ");
          Serial.println(temp__);
        }
        f = false;
        b = false;
        l = false;
        r = true;
        break;
      case '1' ://motor #1
        int temp_;
        if(Serial.available() < 1)
          ;
          delay(500);
          temp_ = Serial.read();
        if (temp_ == 102){// -f
          Serial.println("*1FW*");
          digitalWrite(pinDir[1], LOW);
          digitalWrite(pinPwm[1], HIGH);
        }//end of if
        else if(temp_ == 98){// -b
          Serial.println("*1BW*");
          digitalWrite(pinDir[1], HIGH);
          digitalWrite(pinPwm[1], HIGH);
        }
        else{
         
          Serial.print("error ");
          Serial.println(temp_);
        }
        f = true;
        b = false;
        l = false;
        r = false;
        break;
      case '2' ://l -> left
        temp_ = 0;
        if(Serial.available() < 1)
          ;
          delay(500);
          temp_ = Serial.read();
        if (temp_ == 102){//motor #2
          Serial.println("*2FW*");
          digitalWrite(pinDir[2], LOW);
          digitalWrite(pinPwm[2], HIGH);
        }//end of if
        else if(temp_ == 98){// -b
          Serial.println("*2BW*");
          digitalWrite(pinDir[2], HIGH);
          digitalWrite(pinPwm[2], HIGH);
        }
        else{
         
          Serial.print("error ");
          Serial.println(temp_);
        }        
        f = false;
        b = false;
        l = true;
        r = false;
        break;
      case 82 : //R->RESET
        Serial.println("*** Resetting ***");
        for (int i=0; i < 3; i++){
          digitalWrite(pinPwm[i], LOW);//Setting all PWM's to LOW
          Serial.print("C");
          Serial.print(i);
          Serial.print("=");
          Serial.println(cycle[i]);          
        }//end of for
        f = false;
        b = false;
        l = false;
        r = false;
        break;
    }//end of switch  
  } 
  /*
  if (f || b || r || l){
    Serial.print("cycle[i]: ");
    Serial.println(cycle[i]);
  }//end of if
  */
}//end of commandCenter

//int angleMaalt;

void checkEncoder(){
  int A;
  int B;
  int i;
  for (i = 0; i < 3; i++){
      A = digitalRead(pinEncA[i]);
      B = digitalRead(pinEncB[i]);
    
      if ( (A==LOW) && (B==LOW) )
        cyclecounter[i] = 0;
      else if ( (A==LOW) && (B==HIGH) )
        cyclecounter[i] = 1;
      else if ( (A==HIGH) && (B==HIGH) )
        cyclecounter[i] = 2;
      else if ( (A==HIGH) && (B==LOW) )
        cyclecounter[i] = 3;
    
      switch (cyclecounter[i]){
        case (0) : {
           if ( cyclecounterold[i] == 0){
              ;//Do nothing
           }
           else if ( cyclecounterold[i] == 1){
             cycle[i]++;
              Serial.print("C");
              Serial.print(i);
              Serial.print("-");            
              Serial.println(cycle[i]);
           }
           else if ( cyclecounterold[i] == 2){
                Serial.println("Error reading from Encoder-");
            }
           else if ( cyclecounterold[i] == 3){
              cycle[i]--;
              Serial.print("C");
              Serial.print(i);
              Serial.print("-");            
              Serial.println(cycle[i]);
            }
            else 
                ;//Serial.print("ERROR");
            break;
        }//end of case-0
        case (1) : {
            if ( cyclecounterold[i] == 0){
              cycle[i]++;              
              Serial.print("C");
              Serial.print(i);
              Serial.print("-");            
              Serial.println(cycle[i]);
            }
            if ( cyclecounterold[i] == 2){
              cycle[i]--;
              Serial.print("C");
              Serial.print(i);
              Serial.print("-");            
              Serial.println(cycle[i]);            
            }
            else if ( cyclecounterold[i] == 3){
                Serial.println("Error reading from Encoder--");
            }
            else 
                ;//Serial.print("ERROR");
            break;
        }
        case (2) : {
            if ( cyclecounterold[i] == 1){
              cycle[i]--;
              Serial.print("C");
              Serial.print(i);
              Serial.print("-");            
              Serial.println(cycle[i]);
            } 
            else if ( cyclecounterold[i] == 2)
              ;
            else if ( cyclecounterold[i] == 3){
              cycle[i]++;
              Serial.print("C");
              Serial.print(i);
              Serial.print("-");            
              Serial.println(cycle[i]);
            }
            else if ( cyclecounterold[i] == 0){
                Serial.println("Error reading from Encoder---");
            }
            else 
                ;//Serial.print("ERROR");
            break;
        }//end of case-2
        case(3) : {
            if (cyclecounterold[i] == 0){
              cycle[i]--;             
              Serial.print("C");
              Serial.print(i);
              Serial.print("-");
              Serial.println(cycle[i]);
            }
            else if (cyclecounterold[i] == 1){
              Serial.println("Error reading from Encoder----");
            }
            else if ( cyclecounterold[i] == 2){
              cycle[i]++;              
              Serial.print("C");
              Serial.print(i);
              Serial.print("-");            
              Serial.println(cycle[i]);
            }
            else if ( cyclecounterold[i] == 3)
              ;
            else 
              ;//Serial.print("ERROR");
            break;
        }//end of case-3
      }
      
      cyclecounterold[i] = cyclecounter[i];
      
  }//end of for

}//end of checkEncoder()

Meeting with my supervisor Mats Høvin, Summary

2011-01-12T22:17:00.003+01:00

Today I met my supervisor Mats Høvin(associated professor at IFI,UiO). Here comes a summary of what he thinks I should be focusing on :

Handshake protocol. I do not have this protocol & this is something that according to Mats, I better have it implemented in my code
Zero Positioning. My suggestion to this challenge is to save the current position all the time either at PC side or at the Arduino non-volatile memory.
Sending data packages back & forth in serial communication would possibly result in loss of data packages. How can my code handle this kind of problems ?
Error on startup, fix for it ? Is it a programming error, or a hardware error because of Noise on reading inputs from ports ???
Sending many bytes and the delays resulting by that
The speed control, should be handled in java or Arduino ??? Maybe fast in the beginning and slow down little by little while reaching the end of the axle
Play off modus & Should it be target based, or follow every detail from the log blindly ??? Discuss ...
Camera candidates & streaming , but not image processing -> Intelligent cameras with output ports(how many???) for sending commands to Arduino according to the image processing done by camera itself.
Using WiFi tech & how ??? WiFly component ?
Programing a simulator in JAVA (xyz generation and visualization in JAVA)
PHP/JAVA Applet GUI & Streaming show on website
Multi Arduino card solutions ? Benefits and disadvantages ??? Discuss ...
FPGA??? A possible solution instead of Arduino? Discuss ...
Different methods to read data from encoders, External interruptions or software methods reading encoders value by analogRead() on loop frequence. Discuss based on Atmel/AVR architecture
Positioning in the room & semi-Kinect sensors

Multi Arduino card solution ?

2011-01-11T10:40:00.003+01:00

Discussion about using more than one Arduino card in this project on Arduino.cc froum
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1294709114/

Robot foot Control Panel(in Java) for the robot feet, version 0.01

2011-01-07T15:07:00.001+01:00

This is the first snapshot of a GUI for the Robot foot Control Panel in Java that I am designing right now. I do not have much trouble with it and it looks promissing :-) Updates of the code and more snapshots come soon ...

Serial data transmission and problem with it being SLOW !!!

2011-01-07T12:49:00.000+01:00

A while ago I was facing a problem reading some inputs from Serial Communication(USB port) in Arduino. The Arduino would work perfect(read all the inputs from Serial Communication Window as planned) if I was having my debug print outs but not if I would remove them(they also could be substituted by Delays) !!! I later tried to find out about them and here was the answer :

"Serial data transmission is slow. The Serial.print statement takes time, which allows time for more data to arrive. You have two choices. Add a delay statement to the while loop, and hope all the data arrives in time is the first choice. The longer you waste time waiting for data, the better your chances of it all arriving in time.

The second choice is to add an end-of-packet marker, and keep appending to temp until that end of packet marker arrives. Only use the data in temp when the end of packet marker has arrived.

The delay masks the issue of not being able to read a complete packet in one pass. If the delay is too small, the whole packet will not arrive before the delay(s) expire. If the delay is too large, you are just wasting time.

The better approach is to add an end of packet marker to the packer, wo you can read the packet as quickly as possible.."

Source : http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1294185714/1#1

RxTx API, Java

2011-01-07T12:41:00.005+01:00

By clicking on the following link you can have access to the full directory of RxTx library API's in Java :

http://users.frii.com/jarvi/rxtx/doc/index.html

Encoders & Cycles 2, All DC motors are monitored now -> All_Encoders.pde

2011-01-06T01:46:00.000+01:00

This code can monitor the changes in cycles of all the DC motors used in the robot feet.



// Encoders inputs
byte pinEncA[] = {7,5,3}; // digital inputs
byte pinEncB[] = {6,4,2}; // digital inputs

// MOTOR OUTPUTS
byte pinDir[] = {13,8,12}; // digital output, controls direction for motor nr. [x]
byte pinPwm[] = {10,11,9}; // analog output, controls motor speed, nr. [x]

//Global variables
int readValue;
int pwmValue;
int motorDir;
//int channelA = 2;
//int channelB = 3;
int cycle[] = {0, 0, 0};

boolean f = false, b = false, r = false, l = false;
byte cyclecounter[] = {0, 0, 0};
byte cyclecounterold[] = {0, 0, 0};

//13 , 10 right, down
//8 , 11 middle, top
//9, 12 left, down



void setup(){
  
  Serial.begin(9600);
  Serial.println("WELCOME TO C1S0");  
  for (int i=0; i < 3; i++){
    pinMode(pinDir[i], OUTPUT);
    pinMode(pinPwm[i], OUTPUT);
    //in case, just to be sure ...
    digitalWrite(pinPwm[i], LOW);
    // just in case to be sure
    digitalWrite(pinDir[i], LOW);
    pinMode(pinEncA[i], INPUT);
    pinMode(pinEncB[i], INPUT);
    digitalWrite(pinEncA[i], LOW);
    digitalWrite(pinEncB[i], LOW);
    cyclecounter[i] = 0;
    cyclecounterold[i] = 0;
  }//end of for
  
}//end of setup()

void loop(){
    commandCenter();
    checkEncoder();
}//end of loop

void commandCenter(){
  //variables
  int temp = 0;
  if ( Serial.available() > 0 ){
    readValue = Serial.read();
    switch (readValue){
      case 102 ://f -> forward
        Serial.println("*** Forward ***");
        digitalWrite(pinDir[1], LOW);
        digitalWrite(pinPwm[1], HIGH);
        f = true;
        b = false;
        l = false;
        r = false;
        break;
      case 98 ://b -> back
        Serial.println("*** Backward ***");
        digitalWrite(pinDir[1], HIGH);
        digitalWrite(pinPwm[1], HIGH);
        f = false;
        b = true;
        l = false;
        r = false;        
        break;
      case 108 ://l -> left
        int temp_;
        temp_ = 0;
        if(Serial.available() < 1)
          ;
          delay(5);
          temp_ = Serial.read();
        if (temp_ == 102){// -f
          Serial.println("*** Left forward ***");
          digitalWrite(pinDir[2], LOW);
          digitalWrite(pinPwm[2], HIGH);
        }//end of if
        else if(temp_ == 98){// -b
          Serial.println("*** Left backward ***");
          digitalWrite(pinDir[2], HIGH);
          digitalWrite(pinPwm[2], HIGH);
        }
        else Serial.println("*** NOTHING ***");
        f = false;
        b = false;
        l = true;
        r = false;
        break;
      case 114 ://r -> right
        int temp__;
        temp__ = 0;
        if(Serial.available() < 0)
          ;
        delay(5);
        temp__ = Serial.read();
        if (temp__ == 102){// -f
          Serial.println("*** Right forward ***");
          digitalWrite(pinDir[0], LOW);
          digitalWrite(pinPwm[0], HIGH);
        }//end of if
        else if(temp__ == 98){// -b
          Serial.println("*** Right backward ***");
          digitalWrite(pinDir[0], HIGH);
          digitalWrite(pinPwm[0], HIGH);
        }
        f = false;
        b = false;
        l = false;
        r = true;
        break;
      case 82 : //R->RESET
        Serial.println("*** Resetting ***");
        for (int i=0; i < 3; i++){
          digitalWrite(pinPwm[i], LOW);//Setting all PWM's to LOW
          Serial.print("*** Cycle[");
          Serial.print(i);
          Serial.print("] = ");
          Serial.println(cycle[i]);          
        }//end of for
        f = false;
        b = false;
        l = false;
        r = false;
        break;
    }//end of switch  
  } 
  /*
  if (f || b || r || l){
    Serial.print("cycle[i]: ");
    Serial.println(cycle[i]);
  }//end of if
  */
}//end of commandCenter

//int angleMaalt;

void checkEncoder(){
  int A;
  int B;
  int i;
  for (i = 0; i < 3; i++){
      A = digitalRead(pinEncA[i]);
      B = digitalRead(pinEncB[i]);
    
      if ( (A==LOW) && (B==LOW) )
        cyclecounter[i] = 0;
      else if ( (A==LOW) && (B==HIGH) )
        cyclecounter[i] = 1;
      else if ( (A==HIGH) && (B==HIGH) )
        cyclecounter[i] = 2;
      else if ( (A==HIGH) && (B==LOW) )
        cyclecounter[i] = 3;
    
      if (cyclecounter[i] == 0){
        Serial.print("CAME IN AS 0");
         if ( cyclecounterold[i] == 0){
            Serial.print("Case old is 0");
         }
         else if ( cyclecounterold[i] == 3){
            //angleMaalt++;
            Serial.println(cycle[i]);            
            Serial.print("*** Changed cycle[");
            Serial.print(i);
            Serial.print("] = ");
            cycle[i]--;
            Serial.println(cycle[i]);
            Serial.println("++++++");            
            Serial.print("cyccleCounter is : ");
            Serial.println(cyclecounter[i]);
            Serial.print("cyccleCounterOld is : ");              
            Serial.println(cyclecounterold[i]);
          }
          else if ( cyclecounterold[i] == 2){
              Serial.println("Error reading from Encoder-");
              Serial.println("cyclecounter[i]");
              Serial.println(cyclecounter[i]);
              Serial.println("cyclecounterold[i]");
              Serial.println(cyclecounterold[i]);
          }
          else Serial.print("CRAP");
      }
      else if (cyclecounter[i] == 1){
          /*if ( cyclecounterold[i] == 2)
            angleMaalt--;
          else if ( cyclecounterold[i] == 0)
            angleMaalt++;
          else*/ if ( cyclecounterold[i] == 3){
              Serial.println("Error reading from Encoder--");
              Serial.println("cyclecounter[i]");
              Serial.println(cyclecounter[i]);
              Serial.println("cyclecounterold[i]");
              Serial.println(cyclecounterold[i]);
          }
      }
      else if (cyclecounter[i] == 2){
          /*if ( cyclecounterold[i] == 3)
            angleMaalt--;
          else if ( cyclecounterold[i] == 1)
            angleMaalt++;
          else*/ if ( cyclecounterold[i] == 0){
              Serial.println("Error reading from Encoder---");
              Serial.println("cyclecounter[i]");
              Serial.println(cyclecounter[i]);
              Serial.println("cyclecounterold[i]");
              Serial.println(cyclecounterold[i]);
          }
      }
      else if (cyclecounter[i] == 3){       
          if (cyclecounterold[i] == 0){
            //angleMaalt--;
            Serial.println(cycle[i]);            
            Serial.print("*** Changed cycle[");
            Serial.print(i);
            Serial.print("] = ");
            cycle[i]++;
            Serial.println(cycle[i]);
            Serial.print("++++++");            
            Serial.print("cyccleCounter is : ");
            Serial.println(cyclecounter[i]);
            Serial.print("cyccleCounterOld is : ");              
            Serial.println(cyclecounterold[i]);
          }
          /*else if ( cyclecounterold[i] == 2)
            angleMaalt++;*/
          else if ( cyclecounterold[i] == 1){
              Serial.println("Error reading from Encoder----");
              Serial.println("cyclecounter[i]");
              Serial.println(cyclecounter[i]);
              Serial.println("cyclecounterold[i]");
              Serial.println(cyclecounterold[i]);
          }
      }

    
      cyclecounterold[i] = cyclecounter[i];
  }//end of for

}//end of checkEncoder()

Encoders & Cycles

2011-01-05T03:45:00.000+01:00

Tonight(or better say this morning at 4:00 a.m.) I managed to make a code to finally count the cycles(it takes around 70 cycles for a motor to screw totally open) that the light fork encoder on this foot counts. This code is an alpha version which monitors just one of the DC motors(the one in the middle, motor with index "1" in the code).

The challenge to discus here is a limitation in Arduino which I have discussed in my previous post here(few external interruption on Arduino ). Most Arduino boards, so do mine, have just two external interruptions and this makes me not to use this method(which looks to be a perfect one) to monitor the changes on the pins received from the motor driver(changes in A & B state from Motor driver which tells us about the current position of the DC motor connected to it). With external interruptions out of the picture the only way that I came to is to solve this with a software trick. I tried to monitor the changes sent from the encoder which is connected to a moving motors as fast as I can. This is done by placing readFromEncoder() method in loop() method which repeats pretty fast and up to now has given satisfactory results. Check the code down here :



// Encoders inputs
byte pinEncA[] = {7,5,3}; // digital inputs
byte pinEncB[] = {6,4,2}; // digital inputs

// MOTOR OUTPUTS
// digital output, controls direction for motor nr. [x]
byte pinDir[] = {13,8,12}; 
// analog output, controls motor speed, nr. [x]
byte pinPwm[] = {10,11,9}; 

//Global variables
int readValue;
int pwmValue;
int motorDir;
int cycle;

boolean f = false, b = false, r = false, l = false;
byte cycleCounter;
byte cycleCounterOld;

void setup(){
  Serial.begin(9600);
  Serial.println("WELCOME TO C1S0");  
  for (int i=0; i < 3; i++){
    pinMode(pinDir[i], OUTPUT);
    pinMode(pinPwm[i], OUTPUT);
    //in case, just to be sure ...
    digitalWrite(pinPwm[i], LOW);
    //in case, just to be sure ...
    digitalWrite(pinDir[i], LOW); 
    pinMode(pinEncA[i], INPUT);
    pinMode(pinEncB[i], INPUT);
  }//end of for
}//end of setup()

void loop(){

//  digitalWrite(pinDir[2], LOW);
//  digitalWrite(pinPwm[2], HIGH);
//  Serial.println("...");
  //if ( Serial.available() > 0 )
    commandCenter();
    readFromEncoder();
    //Serial.print("cycle: ");
    //Serial.println(cycle);
}//end of loop

void commandCenter(){
  //variables
  int temp = 0;
//  while (Serial.available() < 0)
//    ;
  if ( Serial.available() > 0 ){
    readValue = Serial.read();
    switch (readValue){
      case 102 ://f -> forward
        Serial.println("*** Forward ***");
        digitalWrite(pinDir[1], LOW);
        digitalWrite(pinPwm[1], HIGH);
        f = true;
        b = false;
        l = false;
        r = false;
        break;
      case 98 ://b -> back
        Serial.println("*** Backward ***");
        digitalWrite(pinDir[1], HIGH);
        digitalWrite(pinPwm[1], HIGH);
        f = false;
        b = true;
        l = false;
        r = false;        
        break;
      case 108 ://l -> left
        Serial.println("*** Left ***");
        digitalWrite(pinDir[2], LOW);
        digitalWrite(pinPwm[2], HIGH);
        f = false;
        b = false;
        l = true;
        r = false;        
        break;        
      case 114 ://r -> right
        Serial.println("*** Right ***");
        digitalWrite(pinDir[0], LOW);
        digitalWrite(pinPwm[0], HIGH);
        f = false;
        b = false;
        l = false;
        r = true;
        break;
      case 82 : //R->RESET
        Serial.println("*** Resetting ***");
        for (int i=0; i < 3; i++){
          //Setting all PWM's to LOW
          digitalWrite(pinPwm[i], LOW);
        }//end of for
        f = false;
        b = false;
        l = false;
        r = false;
        break;
    }//end of switch  
  } 
}//end of commandCenter

int angleCount;

void readFromEncoder(){
  int A;
  int B;

  A = digitalRead(pinEncA[1]);
  B = digitalRead(pinEncB[1]);
  digitalWrite(13, A);

  if ( (A==LOW) && (B==LOW) )
    cycleCounter = 0;
  else if ( (A==LOW) && (B==HIGH) )
    cycleCounter = 1;
  else if ( (A==HIGH) && (B==HIGH) )
    cycleCounter = 2;
  else if ( (A==HIGH) && (B==LOW) )
    cycleCounter = 3;

  switch(cycleCounter)
  {
  case 0:
    if ( cycleCounterOld == 1)
      angleCount--;
    else if ( cycleCounterOld == 3){
      angleCount++;
      Serial.print("cycle: ");
      Serial.println(cycle);
      cycle--;
    }
    else if ( cycleCounterOld == 2){
        Serial.println("Error reading from Encoder");
        Serial.println("cycleCounter");
        Serial.println(cycleCounter);
        Serial.println("cycleCounterOld");
        Serial.println(cycleCounterOld);
    }
    break;  

  case 1:
    if ( cycleCounterOld == 2)
      angleCount--;
    else if ( cycleCounterOld == 0)
      angleCount++;
    else if ( cycleCounterOld == 3){
        Serial.println("Error reading from Encoder");
        Serial.println("cycleCounter");
        Serial.println(cycleCounter);
        Serial.println("cycleCounterOld");
        Serial.println(cycleCounterOld);
    }
    break;  

  case 2:
    if ( cycleCounterOld == 3)
      angleCount--;
    else if ( cycleCounterOld == 1)
      angleCount++;
    else if ( cycleCounterOld == 0){
        Serial.println("Error reading from Encoder");
        Serial.println("cycleCounter");
        Serial.println(cycleCounter);
        Serial.println("cycleCounterOld");
        Serial.println(cycleCounterOld);
    }
    break;  

  case 3:
    if ( cycleCounterOld == 0){
      angleCount--;
      Serial.print("cycle: ");
      Serial.println(cycle);
      cycle++;
    }
    else if ( cycleCounterOld == 2)
      angleCount++;
    else if ( cycleCounterOld == 1){
        Serial.println("Error reading from Encoder");
        Serial.println("cycleCounter");
        Serial.println(cycleCounter);
        Serial.println("cycleCounterOld");
        Serial.println(cycleCounterOld);
    }
    break;            
  }
  cycleCounterOld = cycleCounter;
}

The plan a head is to make a complete Arduino code that monitors all three motors and connect it to a Java code. Java code can communicate with Arudino through serial communication and monitors all the three motors, being able to report the current cycle that the motor is right now at.

External interrupts in Arduino & its limitations

2011-01-05T02:24:00.000+01:00

Description

Specifies a function to call when an external interrupt occurs. Replaces any previous function that was attached to the interrupt. Most Arduino boards have two external interrupts: numbers 0 (on digital pin 2) and 1 (on digital pin 3). The Arduino Mega has an additional four: numbers 2 (pin 21), 3 (pin 20), 4 (pin 19), and 5 (pin 18).

Parameters

interrupt: the number of the interrupt (int)

function: the function to call when the interrupt occurs; this function must take no parameters and return nothing. This function is sometimes referred to as an interrupt service routine.

mode defines when the interrupt should be triggered. Four contstants are predefined as valid values:

LOW to trigger the interrupt whenever the pin is low,
CHANGE to trigger the interrupt whenever the pin changes value
RISING to trigger when the pin goes from low to high,
FALLING for when the pin goes from high to low.

Returns

none

Example

int pin = 13;
volatile int state = LOW;

void setup()
{
  pinMode(pin, OUTPUT);
  attachInterrupt(0, blink, CHANGE);
}

void loop()
{
  digitalWrite(pin, state);
}

void blink()
{
  state = !state;

Climbing robot, brain storming

2010-11-17T08:36:00.002+01:00

This project is an ongoing rapid prototype which is under development by Puya Afsharian & me …

Requirements :

4 x step motor
4 x El. Magnet
1 x Arduino
1 x Thin Aluminium plate

Components :

Magnet #1
Magnet #2
Magnet #3

Motor #1-1
Motor #1-2
Motor #2-1
Motor #2-2

Algorithm & states :

Initial state :
Mag. 1,2,3 -> ON
Motor 11,12,21,22 -> OFF
Lift state :
Mag3 -> OFF
Mag 1,2 -> ON
Motor 12, 22 -> CCW ON
Mag3 -> ON
Move Up Right state :
Mag2 -> OFF
Motor 11 CW ON MAX
Motor 12 CW ON -> Vertical(Parallel with chassis)
Mag 2 -> ON
Move Up Left state :
Mag1 -> OFF
Motor 21 CW ON MAX
Motor 12 CW ON -> Vertical(Parallel with chassis)
Mag 1 -> ON

and again to Lift state

New foot design details

2010-09-05T01:15:00.000+02:00

I have received these along with the foot from my supervisor Mats Høvin.

Actuator Design

Encoders mounted on Motor jacket

Arudino + Motor drivers

Encoder

Source of all details is www.robotikk.com

New feet received

2010-08-03T16:57:00.001+02:00

Published with Blogger-droid v1.4.9

More info

Found useful/inspiring designs on Youtube ...

2010-07-16T11:53:00.000+02:00

Inspiring :-)

New feet design for walloid

2010-07-15T19:11:00.000+02:00

As explained in the previous post, I received new robot design which is under development by Mats Høvin a while ago. While working on a summer-project which is highly related to my master thesis & receiving some tips discussing the new design with some friends*, I came up with some new ideas regarding climbing solutions.
My idea is a very simple grip for each foot which gives the climbing robot the ability to hang on a nail(bolt) on the wall. The curved(bent) part in the middle will be where the robot would grip the nail. I am thinking of using a flex sensor there to receive a signal every time a foot is hanging to a bolt. Meaning if we want to make a move at a time, before moving the foot, we should receive 4 bent resistor signals from the robot feet and while moving, all the way we should be receiving 3 bent resistor signals from other three remaining hanging feet.When we are finished with moving our foot to the new point of griping, we should again receive the 4th signal again ... I am still working on this idea and going to discus it as soon as my supervisor is back from his holiday.
*Thanks to my colleague Tarjei & my friend Magnus :-)

For more snapshots click read more ...

New design received from Mats

2010-07-13T16:52:00.000+02:00

I have received new robot design, plus new motor designs from Mats Høvin(my supervisor). Right now I am working on two things at the same time. One is the new motor design which is used in this chassis and at the same time I am working on Mats design to develop a grip(feet) for this chassis. I have came up with some ideas that will soon be posted here ...

Down here you see the Mats Høvin chassis for the climbing robot :

New chassis designed by Mats

New Motor designed by Mats

New Motor chassis designed by Mats, printed in 3D printer

LATEST NEWS, Working on summer project which is highly related to my thesis

2010-07-13T12:23:00.000+02:00

Right now I am leading a team consist of 7 students, doing a summer-project called Super Crawler(a tank-type robot which roles around with the belt) at Robotica Osloensis(Robotics student community at university of Oslo). My team and I have gained many new experiences(reverse engineering techniques, Programming different motors to work with Arudino boards in C, Communicating with Arduino borads with Java on Serial communication port, signal processing, etc) and have developed different codes for our purposes. You can read all about it, see the photos & videos and have direct access to our codes on our project worklog. I have also added a RSS-reader on the right side of this weblog about latest news on Super Crawler project ...

These experiences would help me a lot in future development of my climbing robot, Walloid :-)

Category-partition Testing

2010-06-11T09:49:00.001+02:00

Testing, Verification & Validation
X Robot families
INF4290
Semester Project Report

Title : Testing of a X family Robots
Akbar Faghihi Moghaddam - (Shahab)

TABLE OF CONTENTS

INTRODUCTION
BACKGROUND
DESIGN OF CASE STUDY

The SUT
The System Specification
Testing Phase

Enable / Disable Motor
Restart
Rotation of the robot arm

Base Choice(BC)
Each Choice(EC)
All combinations (AC)

ANALYSIS OF THE RESULT
LESSONS LEARNED AND OPEN ISSUES
REFERENCES

INTRODUCTION

This is my semester project in testing and verification in INF4290 course(Testing, Verification & Validation) at institute for informatics at university of Oslo. The semester project is supposed to apply some of the testing techniques to actual software and quantitatively compare techniques,assess drawbacks and advantages. My project is testing a system which is a robotic package solution, used in different projects here at institute of Informatics(IFI). The System Under Test(SUT) is a robotic solution of X family robots developed here at Robotics and Intelligent Systems(ROBIN) group. These solutions are designed to be used as the foundation of master projects and other educational purposes(INF3480, Introduction to Robotics). Three generations of X family robotic solutions has been developed by Mats Høvin up to now. You can see the X2 version of this family on the right side of the page. The X3 version is much smaller, with some design improvements, as the new 3D printer here at Robotic group allows us to print our designs in even smaller scales. The main goal of all of these designs are to rotate the jointed arms to reach to final point at the robots workspace.

My interest in this particular project is because of its involvement in my own master thesis. My master project is a climbing robot, which will benefit from four X3 modules as the its arms. The reason of choosing this specific system as my SUT was to deeply understand the functionality and the way it is developed through testing it. Clearly another goal of this testing project is to find the errors, document and map them and finally debug it later, as re-developing this system is a part of my master thesis. It should be mentioned here that testing this system has given me a deep understanding of almost all the advantages and disadvantages of the SUT and has made me the right person to re-develop an error-free version of it in future. I also have plans of improving my own skills in testing and maybe having an improved version of this report as a part of my thesis. One of my goals here in this project was to have a deep understanding of the code and I would reach that by using White Box testing. This was not possible as is explained in detail later in Background part of this report.

Here in this report I will be describing the challenges I have been facing writing this report. Challenges which made me at the end to set a side some of the choices I had and choose Black Box testing, category-partition as the right choice for this paper. The report is structured in a way to give a good description of the system itself, methods and techniques in details with test cases used to perform the functional testing and finally the results and analysis of the result which I reached through this test.

BACKGROUND

To my knowledge no one has ever written a report on testing the X family robots and this report is not only the first paper written about this product family, but generally testing as a separate work is not so usual at the Robotic group here at IFI. I hope this paper can be the beginning of new point of view to robotic development here at ROBIN group. The decision to choose the right method for testing a robotic project was not easy at all. I have used several hours trying to find my way through lots of different choices I had in choosing a suitable SUT and the right method and tools for it(as the choices are simply too many for an unexperienced tester like me). For testing the functionality of my chosen SUT, I finally came up with category-partition technique of Black Box testing. The reader might ask why not the others ? For example why not White Box testing which would give me more understanding of the code behavior as it is one of my intension choosing this SUT ? Why not model checking which is a suitable system for hardware testing ? Or simply why not Random Testing ?

White Box Testing ? Not a good idea in this case ...
As I will describe in the part "Design of the case study" the programing language used at the SUT, is not a standard popular language. It is a kind of semi-C++ language developed for programing Micro controllers. After looking around for a while, I found out there is absolutely no tools that I can benefit automating test cases(e.g. JUnit for Java) and no extra gadget to give a coverage rate of the program traced by test cases(e.g. EclEmma plugin for Eclipse, again for Java). I was also thinking about making manual test cases that I could run on the code and developing a small program that can give an estimated coverage(like EclEmma) of the code traversed by the test cases. This was not possible because of lack of time. All difficulties running White Box testing, made me to look away from it.

Model Checking ? Perfect but not now ...
A perfect way to describe and test the hardware design. The problem rises when in our case some of the system specification should change to fit Model Checking needs for Boolean inputs. This method can be one of my future report candidates.

Black Box Testing ? The one I was looking for ...
I should underline that one of the reasons in choosing Black Box Testing method, is my lack of experience in testing which is limited to the lectures at this course. Black Box testing methods seems to be easier in concept than other methods that can get too complicated from time to time. The B.B. focuses on the functionality without really realizing all the technical parts, which is perfect for me as a person who is new to this concept(Micro controller programming).

Random Testing ? Could also be used, but was set a side because of lack of time to perform multiple tests ...

I have chosen B.B. testing, now what ? The definition says that goal of functional testing here is to find discrepancies between the actual behavior of the implemented system’s function and the desired behavior as described in the system’s functional specification. Black-box method, treats the system as a "black-box". It designs test cases based on inputs, outputs and general functionalities as defined in requirements specification and does not care about object's internal structure. The method is just interested to determine the correct or incorrect output. This means that with choosing this method, I am not going to reach the goal of understanding the code of the SUT by testing it, but I will be testing the functionality of the system and how well it can do what it is supposed to do(system specification). Usually the functional testing can be derived from three sources which are the system specification, design information and the code itself. Although we have access to the code here, but we are going to act like that we do not have a clue about the internal structure(B.B. testing) of the program and we are just after checking the functionality of this system according to test cases designed based on system specification.

Before choosing category-partition in B.B. testing, I almost did half of the report based on Equivalence Class Testing, which was not a success. The problem lead from dividing system specification into equivalent classes that could naturally not be exclusive. Therefor with help from the lecture, I have chosen category-partition which extends and combine Equivalence Class Testing, boundary value analysis. At this technique the system is divided into individual “functions” that can be independently tested. The method identifies the parameters of each “function” and, for each parameter, identifies distinct categories. The categories are further subdivided into choices in the same way as equivalence partitioning is applied. This method emphasizes both the specification coverage and the error detection aspects of testing.

To do this we need to first have a clear idea about how the program functions and what is our System Specification and requirements to be able to decompose it into small test cases for category-partition. The SUT in this report is first divided into different functions, later categories and finally choices which are all described in details in "Design Of The Case Study".

DESIGN OF CASE STUDY

In this part I am going to describe how the SUT functions in the first place and later I'll try to give a clear picture of the system specification. Afterward I am going to go through the details of how did I actually divided and conquered the actual problems I faced while using category-partition testing technique. Where I have divided the program into smaller functions and then functions to categories and choices. I will also explain in details the test cases and test tables with expected results and the actual results at the end of this section. The detailed presentation analysis of the test cases results will be presented in the next part which is called "Analysis Of The Result".

The SUT

All the X family robots are made of three different part :

The controller program
The Electronics solutions
The Design

I'll try to give a brief description of each part here :

Controller Program

The control program is a messy code which is an alpha version of the controller project and is under development right now as being used in different projects at ROBIN group. The code is consist of 375 lines of a wiring language, which is a semi-C++ family. As most of controllers do, the program is in charge of reading and writing data to the pins on the micro controller board and its main goal is to rotate the arm with to a pre-defined angle. The main area of my focus in this report is the controller program.

Electronics solutions
The main part of electronic solution behind this module is an Arduino card. An Arduino is a single-board micro controller and a software suite for programming it. The hardware consists of a simple open hardware design for the controller with an Atmel AVR processor and on-board I/O support. The software(the language the controller is developed in) consists of a standard programming language and the boot loader that runs on the board. The card is connected to the desired DC motor through one motor driver and an encoder which measures the angle traced by the motor shaft.
Design
The design is by Mats Høvin, and is implemented in SolidWorks 2009. The design later was printed out in special plastic materials by 3D printer at Robin labs. One of the goals of the test can be to check if the design have anything to do with system failures, but this was set a side because of lack of time.

Now that we have a clear picture of how the system is made and what is the main goal, maybe it is now time to picture the system specification.

The System Specification :

The controller program does its job with the help of some inputs. It is supposed to receive a set of data and after adjusting itself to those received data, it should rotate to the pre-defined angle. This is the main goal of this controller program. These inputs are angle, proportional constant, choosing the verboose mode, restarting on demand and the ability to turn the motor driver ON and OFF while the system is still functional and the program controller is not terminated yet. After running the controller code, it prints the following welcome message on start-up :

Welcome to the X2 controller.

Variables :

a = targetAngle, 16 bit signed integers, p = proportional constant, 8bit unsigned Byte

Loop error is divided by p

Commands :

V - Verboose ON / Very verboose ON (ASCII modes)

v - Verboose OFF (binary modes)

m - Toggle motor enable

r - Restarts the system

a1234 - sets target angle(-360 - +360)

p123 - sets prop constant p(1-255)

Verboose ON

Without having any previous knowledge of the code, the welcome message gives us the following information about the inputs. Now we know that it is giving us the following choices :

"a" which stands for angle :
According to welcome message, angle is defined as a 16 bit signed integer(-32767 - +32766), but limited to -360 to +360 in the program specification
"p" which stands for proportional constant :
According to welcome message, p is defined as a 8 bit unsigned Byte(0-255), but limited to 1 to 255 in the program specification
"V/v" for Verboose mode which makes the system to operate in verboose mode, meaning it will print lots of feedback from the system rotating.
"m" which turns the motor driver ON and OFF.
"r" which restart the whole system.

The program after receiving inputs is ready to start the rotation. The angle and proportional constant values would be processed first and then a signal would be sent to the Arduino micro-controller. The micro controller sends the new commands to the motor driver and the driver would steer the motor according to the received input. Finally the motor would rotate to the desired angle, but this is done under special conditions, which means the angle should be given in the range(between -360 and +360) and the proportional constant should be given according to the type of motor which is used. So here is our clear system specification :

The program receives the angle(16 bit signed integer) and proportional constant(8 bit unsigned Byte). After receiving these two inputs, it is ready to start rotating. The rotation can happen in two different modes(Verboose/NON verboose mode). On demand the user can choose to turn OFF an ON the motor driver without terminating the program and there is also a function available for Restarting the system.

I should mention that in this report I decided to set aside the Verboose functionality as the only thing it does is to print some feedback information from the motor driver.

Testing Phase

To reach the goal of our functional testing, we should test all the system functions and tests should be designed in a way to maximize the chance of finding errors in the software. As category-partition does, in this phase I have both covered the specification coverage and error detection aspect of testing. Down here I am trying to decompose the system specification into functional units which can be tested independently. The controller program can do the following tasks which here at category-partition technique we call them functions.

The Program Functions are :

Enable/Disable Motor
Restart
Rotation of the robot arm

Enable / Disable Motor

Enable / Disable motor function is performed with entering "m" as input in the program. This will enable or disable motor driver and it is guessed that we are facing a Boolean type variable(True or False). The motor driver is turned ON with entering m for the odd(1,3,5,...) number of timers, while it will be turned OFF with entering m it even(2,4,6,...) number of times. In this function we have just one parameter and the parameter is a Boolean value. There are two categories for this parameter :

Motor driver in disabled mode
Motor driver in enabled mode

Our only choice for each of these two categories is to check and see if the system performs as it should and there is no malfunction. The expected behavior is to see that the motor does not respond as it is in the disabled mode and respond to our orders as soon as it enters the enabled mode. We can generalize this with saying that if the m is pressed

Category	Choices
Motor driver in enabled mode	m (is entered for the *2N+1**(odd) time)
Motor driver in disabled mode	m (is entered for the *2N**(even) time)

Formal Test Specification :

m is pressed for the (2*N)+1 time
m is pressed for the (2*N) time

#	Test Case	Details	Expected Result	Result
1	m1	m is pressed for odd number of times	The motor is turned ON	The motor is turned ON
2	m2	m is pressed for even number of times	The motor is turned OFF	The motor is turned OFF

Restart

The restart function is performed with entering "r" and according to program help, it should restart all the inputs and set the current degree to zero. The implementation of this function with one Boolean parameter leaves us again with two types of categories. The one where "r" is entered and the one where "r" is not entered :

"r" is entered and the system has restarted
"r" is not entered and the system info should not be restarted

The only choice for each category is to check if the current angle is actually set to 0 after restarting.

Category	Choices
System is Restarted	"r" is entered
System is not Restarted	"r" is NOT entered

Formal Test Specification :

r is pressed
r is NOT pressed

#	Test Case	Details	Expected Result	Result
1	r1	r is pressed	The system restarts and the current angle is equal with 0	The system restarts and the current angle is equal with 0
2	r2	r is not pressed	The system continue to work as expected in system specification with its previous current angle	The system continue to work as expected in system specification with its previous current angle

Rotation of the robot arm

The goal of this function which is the main goal of the whole system, is the most important function. This implementation allows the program to move(rotate) the robot arm to a pre-defined angle(input a). The function should be able to rotate the robot arm to the desired angle, with desired proportional constant. There are two parameters for this function, which are :

Angle (Entered as a#)
Proportional constant (Entered as p#)

The categories for the first parameter(angle) based on the format of input, our information from the system specification and the system environment can be divided into following categories :

Inside the range ( -360 to +360 )
Out of the range
Less than 4 digit input
Invalid input

The choices we would have for the mentioned categories of angle parameter are as followed :

Category	Choices
Inside the range ( -360 to +360 )	-360, [-359 - +359], +360
Out of the range	-361, +361
Less than 4 digit input	One digit, Two digits, Three digits (16 bit signed integer permits 5 digits, but here we do not include five digits as the test case wont be exclusive anymore-intersection with "Out of range" category)
Invalid input	a(NULL) , a_, a1z2b, ...

The categories for the second parameter(proportional constant) again based on the format of input, our information from the system specification and the system environment can be divided into following categories :

Inside the range ( 1-255 )
Out of the range
Less than 3 digit input
Invalid input

The choices we would have for the mentioned categories of angle parameter are as followed :

Category	Choices
Inside the range ( 1-255 )	+1, [+2 - +255), +255
Out of the range	0 (8 bit unsigned Byte which makes 0 - 255 our range, but the last element 255 is not out of range, so we do not have upper out of range)
Less than 3 digit input	One digit, Two digits (8 bit unsigned Byte does not permit more than 3 digits)
Invalid input	p(NULL) , p_, p12b, ...

Formal Test Specification :

Angle ( a ) :

-361 [Error]
-360 [Property p ok, rotate -360]
-359 - +359 [Property p ok, rotates according to input angle]
+ 360 [Property p ok, rotate +360]
+ 361 [Error]
a1 [Property p ok, should rotate +1]
a12 [Property p ok, should rotate +12]
a123 [Property p ok, should rotate +123]
aNULL/a012z [Error]

Proportional Constant ( p ) :

0 [Error]
1 [Property angle ok, regulates with p=1]
2 - 254 [Property angle ok, regulates with input p]
255 [Property angle ok, regulates with p=255]
p1 [property angle ok, should regulate with p=1]
p12 [property angle ok, should regulate with p=12]
pNULL/p02z [Error]

Base Choice(BC)

This criterion is a compromise. A base choice is chosen for each category, and a first base test is formed by using the base choice for each category. The base choice is the simplest, smallest and first usually, also in this report. I should mention that in case of robust test cases(out of boundary), invalid input and test-spec of the environment(less than # number of digits), I have chosen not to combine them with other test cases as the result would be the same. This has reduced the number of test frames and spared much time and effort. This also applies in Each Choice and All Choice combinations.

#	Test Case	Details	Expected Result	Actual Results
1	a1	Angle = +0361	Not to accept the input	Did not to accept the input
2	a3p3	Angle = +0120, P Const = +010	To rotate 120 degrees with fine regulation	Rotated 120 degrees with fine regulation
3	a7	Angle = +90	The program should read 90 as input	The program does not crash but registers wrong input value
4	a9	Angle = +02by	The program should handle the invalid input data	The program crashed
5	p1	P Const = 0	The program should not accept p as zero	The program crashed / division by zero !!!
6	p6	P Const = 25	The program should read 25 as input	The program does not crash but registers wrong input value
7	p7	P Const = zbm	The program should handle the invalid input data	The program crashed

Result : Number of test cases which failed to succeed after running the Base Choice category-partition are 5 out of 7 test cases. Base Choice is the first try on testing the program can margins where the errors can be found. For example in our case we can see that the errors are found on invalid inputs(p=zbm instead of a number), format of entered input(less than #number of digits angle = +25 instead of +0025) and the values around the boundaries on robust testing(p=0 which is the lower boundary of proportional constant) .

Each Choice(EC)

Each choice is stronger than Base Choice, but weaker criterion. One value from each choice for each category must be used at least in one test case.

#	Test Case	Details	Expected Result	Actual Results
1	a1	Angle = -0361	Not to accept the input	Did not to accept the input
2	a2p3	Angle = -0360, P Const = +010	To rotate -360 degrees with fine regulation	Rotated -360 degrees with fine regulation
3	a3p2	Angle = +0120, P Const = +001	To rotate +120 degrees with fine regulation	Rotated around +120 degrees, but seems like precise regulation at extreme low values fails -‌‌ Boundary Test
4	a4p4	Angle = +0075, P Const = +255	To rotate +75 degrees with fine regulation	Rotated around +75 degrees, but seems like precise regulation at extreme high values fails -‌‌ Boundary Test
5	a5	Angle = +0361	Not to accept the input	Did not to accept the input
6	a6	Angle = +5	The program should read 5 as input	The program does not crash but registers wrong input value
7	a7	Angle = +90	The program should read 90 as input	The program does not crash but registers wrong input value
8	a8	Angle = +270	The program should read 270 as input	The program does not crash but registers wrong input value
9	a9	Angle = +02by	The program should handle the invalid input data	The program crashed
10	p1	P Const = 000	The program should not accept p as zero	The program crashed / division by zero !!!
11	p5	P Const = +3	The program should read 3 as input	The program does not crash but registers wrong input value
12	p6	P Const = +25	The program should read 25 as input	The program does not crash but registers wrong input value
13	p7	P Const = zbm	The program should handle the invalid input data	The program crashed

Result : Number of test cases which failed to succeed after running the Each Choice category-partition are 10 out of 13 test cases. The result from this part exactly confirms the results from the first try(Base Choice). Also we can see that the Each Choice has managed to find new kinds of errors which are errors in regulation at boundary values of P(1 and 255).

All combinations (AC)

One value for every choice of every parameter must be used with one value of every (possible) choice of every other category.

#	Test Case	Details	Expected Result	Actual Results
1	a1	Angle = -0361	Not to accept the input	Did not to accept the input
2	a2p2	Angle = -0360, P Const = +001	To rotate -360 degrees with fine regulation	Rotated -360 degrees with fine regulation
3	a2p3	Angle = -0360, P Const = +010	To rotate -360 degrees with fine regulation	Rotated -360 degrees with fine regulation
4	a2p4	Angle = -0360, P Const = +0255	To rotate -360 degrees with fine regulation	Rotated around -360 degrees, but seems like precise regulation at extreme high values fails -‌‌ Boundary Test
5	a3p2	Angle = +0045, P Const = +001	To rotate +45 degrees with fine regulation	Rotated around +45 degrees, but seems like precise regulation at extreme low values fails -‌‌ Boundary Test
6	a3p3	Angle = +0075, P Const = +010	To rotate +75 degrees with fine regulation	Rotated +75 degrees with fine regulation
7	a3p4	Angle = +0125, P Const = +255	To rotate +125 degrees with fine regulation	Rotated around +125 degrees, but seems like precise regulation at extreme values fails -‌‌ Boundary Test
8	a4p2	Angle = +0360, P Const = +001	To rotate +360 degrees with fine regulation	Rotated +360 degrees with fine regulation
9	a4p3	Angle = +0095, P Const = +010	To rotate +95 degrees with fine regulation	Rotated +95 degrees with fine regulation
10	a4p4	Angle = +0360, P Const = 255	To rotate +360 degrees with fine regulation	Rotated around +360 degrees, but seems like precise regulation at extreme values fails -‌‌ Boundary Test
11	a5	Angle = +0361	Not to accept the input	Did not to accept the input
12	a6	Angle = +5	The program should read 5 as input	The program does not crash but registers wrong input value
13	a7	Angle = +90	The program should read 90 as input	The program does not crash but registers wrong input value
14	a8	Angle = +270	The program should read 270 as input	The program does not crash but registers wrong input value
15	a9	Angle = +02by	The program should handle the invalid input data	The program crashed
16	p1	P Const = 000	The program should not accept p as zero	The program crashed / division by zero !!!
17	p5	P Const = 3	The program should read 3 as input	The program does not crash but registers wrong input value
18	p6	P Const = 25	The program should read 25 as input	The program does not crash but registers wrong input value
19	p7	P Const = zbm	The program should handle the invalid input data	The program crashed

Result : Number of test cases which failed to succeed after running the All Choices category-partition are 12 out of 19 test cases. All Choices has covered all the possible combinations and here we have even more errors, but it seems the errors result from the same source(categories) that we have found in Base Choice and Each Choice level.

ANALYSIS OF THE RESULT

The analysis of the whole result of the category-partition testing is presented in this section. Here we have some charts showing the detailed numbers of test cases ran on the SUT, number of passed results and the failures. I also have made some charts showing the error ratio based on each category compared with the whole overall system.

Function	Method	All	Passed	Failed
Enable / Disable Motor	Category-Partition	2	2	0
Restart	Category-Partition	2	2	0
Rotation of the arm	Category-Partition (All Choices)	19	7	12
SUM	Category-Partition	23	11	12

Number of test cases in each function

As it can be seen here the whole number of test cases ran on the system(All Choices is just taken into consideration from the 3rd function) is 23 test cases which resulted in 11 passed cases and 12 failed. This brings our overall error rate to 52.17%.

My main focus on the result part is on the 3rd function which is rotation of the arm. This function is the most important part of the implementation and without it the whole system is not usable. Down here I have also gathered detailed results of the tests on this function(Rotation of the robot arm). Here we can see detailed number of test cases ran on the SUT and the result both in numbers and percentage of the failed rate.

Method	All	Passed	Failed
Base Choice	7	2	5
Each Choice	13	3	10
All Choices	19	7	12

Number of test cases in each of category-partition methods for Rotation of the robot arm function

Method	Failed Percentage
Base Choice	71.4 %
Each Choice	76.9 %
All Choices	63.1 %

Error rate in each of category-partition methods for Rotation of the robot arm function

As we can see in the statistics that the percentage of discovered errors first rises which looks normal as we have raised number of our test cases and found more errors while testing the faulty categories. This process does not continue when we compare Each Choice results with All Choices. Detailed information says that actually percentage of discovered errors fell from 76.9 down to 63.1 while we have added to the number of test cases testing all the categories. This does not look normal, but I think I have a good idea about what is happening. My explanation about this phenomenon is what I mentioned earlier, where I mentioned that for saving time and effort(as done in the lecture) I have not done the Cartesian multiplication for invalid types and environment-spec test cases. While this might mis-lead us if we don't take what I mentioned earlier in consideration but this last results shows that the program works just fine doing what it is implemented for(with few errors on extreme values of proportional constant), rotating to the pre-defined angle, but has big issues when checking on invalid datatypes and system environment checks(flexibility in reading information from user in different numbers of digit, while it does not mention that the input data should have been in four digits). Error rates, while checking these categories mostly(Base Choice and Each Choice) can get to almost 77%. This is also confirmed by the results of Errors found pr. each category. As we can see in the chart down here the number of "in range" errors stays almost constant(the source was discovered in Each Choice) while it is being multiplied by all other choices in other categories, while others rise or stays constant as they have not been multiplied by other choices in other categories like "in range".

If we had done the Cartesian multiplication in case of those faulty choices the number of errors in the "All Choices" method would get up to around 84 errors. which would make the previous chart to look like this :

LESSONS LEARNED AND OPEN ISSUES

The lessons I learned from this project was that usually the errors do not happen in where the main focus is on(rotation in the normal workspace here), but happens on the boundaries(divisions by 0, malfunction in boundary values for sensitive variables), or when the input data is not expected(invalid type, or the wrong format). This can result either into huge differences in results or even terminating of the whole program which in big control programs can even result in loss of lives. In our case the program can not read +5 and it should be written +0005 !!! This is not mentioned anywhere in the help, or during running the program and can result into that the program reads the following input as 3049 !!! I am still not sure what I did in avoiding the Cartesian multiplication of the faulty categories was the right thing to do. I saw this in the page 37 of the INF4290 BB Testing and continued according to it. I can see that it saved me lots of time and effort, but changed the result of my report, which if not considered can mis-lead the reader. So at least for me still this is an open issuse that if these kind of glitches are acceptable in doing testing or I should have been more accurate ?!

REFERENCES

Lectures of INF4290 - University of Oslo
Software Testing - Writer Limaye- Publisher: McGraw-Hill - 0070139903, 9780070139909
Lectures in Category-Partition testing - Advanced Topics in Software Testing Course - University of Maryland
Lectures in Category-Partition testing - Tel Aviv University
The X family robots

Possible Designs #2, Walloid

2010-05-05T22:32:00.000+02:00

Rope Climbing ...

2010-05-05T14:14:00.000+02:00

RIWEA: Robot for the Inspection of Wind Energy Converter Rotor Blades
The objective of the project was to develop novel technologies to completely capture the condition of wind energy converter rotor blades. Such state-of-the-art inspection methods as thermography, ultrasonics and high resolution cameras in conjunction with innovative robots make a reliable, objective and integrated analysis of blade condition possible.
Wind energy converter rotor blades must be inspected for damage at regular intervals. Primarily made of glass fiber reinforced plastics, rotor blades are one of a wind energy converter's most highly stressed components.

Source : Fraunhofer

Possible Design, Walloid

2010-04-29T11:04:00.001+02:00

Nano Tech, possible solution for Walloid ?

2010-04-27T12:17:00.001+02:00

We can clearly see in this test that this kind of nano technology can operate carrying heavy weights(an adult human body). If we can be sure that this solution would operate in wet & extremely cold condition, can't this nano technology be a good start for Walloid ?
Source : Ted.com/talks

Possible electronic solution, walloid

2010-04-26T15:33:00.001+02:00

The whole idea is based on java program being able to steer the motors through Adruino cards. The java program would be run on an Linux OS on an Eee motherboard. As we have 12 motors for controlling the robot, we would be needing a USB hub with 12 outputs.

Streaming solutions

2010-04-22T23:59:00.000+02:00

http://gstreamer.freedesktop.org/

http://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol

Table of Climbing Solutions

2010-04-19T02:34:00.001+02:00

Climbing solutions :

Solution	Pros	Cons
Grip, Ring Bolt	Low coast(path), Stable	Path needed, High precision required, Unstable under special condition(under windy situation or even uncalculated torque the robot might loose stability)
Grip, Nail	Low coast(path), Very stable	Path needed, Relatively High precision required
Nano tech, bio inspiered	Path free, Relatively stable(in case of supported weight)	High coast of producing the material, Question regarding weight issue(Some studies show they are reliable), If functional in extreme cold and wet condition
Lock(IKEA type) itself to the wall	Relatively Low coast(path), Extra stable,	Path needed, High precision required
Suction cup	Easy implementation, Path free	The path should be totally clear and glossy for the solution to work(unstable and fear of robot to fall)
Magnet, pre-path	Low coast(path), Very stable, Path free(Platforms are made of metal variants)	Path needed(depends on the materials that the workspace is made of), Extra power for 4xel. magnets, Unstable in special condition(in case of ice covering the magnet -> in design of platforms up to 10mm ice is considered in calculations)
Magnet, path builder	Very stable, Path builder,	Extra arm for path building, Slow, Exact place on the path can not be screwed too many times, Extra power for 4xel. magnets, Unstable in special condition(in case of ice covering the magnet -> in design of platforms up to 10mm ice is considered in calculations)
Screw itself to the wall	Extra stable	Exact place on the path can not be screwed too many times, Unstable in special condition(in case of ice covering the magnet -> in design of platforms up to 10mm ice is considered in calculations),
?Glue ?	?	?

Early Design, Walloid

2010-04-15T11:05:00.000+02:00

The hardware design(X2 Module) designed by my supervisor Mats Høvin. I have to start designing the end effector which will contain the solution for climbing.
Source : robotikk.com

Some wild ideas about climbing feet

2010-04-01T01:37:00.001+02:00

Some early wild drawings about how the climbing feet should look like, in case of using ring bolts …

Front feet, climbing robot

Back foot, climbing robot

Suction cup solution ...

2010-04-01T01:36:00.000+02:00

Suction cup solution for a climbing robot and some early drawings ...

Suction cup solution

suction cups solution climbing stairs

Introduction

2010-04-01T01:31:00.000+02:00

This is my first post here at Walloid Project weblog. This weblog is made to be a place for me to publish my works about my master thesis. Walloid is my master thesis at university of Oslo. A climbing robot that can climb the walls and walk on the roof. The final aim of Walloid is to be a prototype for a real world model that can replace human workers, where it is too dangerous for mankind to operate. The actual thought was to make it even water proof with swimming abilities to make it the best candidate for oil fields in the middle of the sea, in a way that it can swim between different platforms, checks on oil pipes on the way and eventually fix the problems.

Walloid will have several versions which every version would try to reach some expected goals. The version names(C#S#) are the short version of C(limbing)#S(wimming)#. Well the swimming part will not be a part of my master thesis and Walloid C2S0 is the goal for my master project.

Walloid C1S0 : A remote controlled(through my navigation program) functional walking(on the floor and not the walls or roof) robot.
Walloid C2S0 : A smart climbing robot which takes its steps autonomously and is controlled totally by the navigation program(monitor its environment by sensors & cameras).
Walloid C3S0 : A smart climbing robot with image processing abilities.
Walloid C3S1 : A smart climbing robot with abilities to perform in underwater condition.
Walloid C3S2 : A waterproof smart climbing robot with swimming abilities.

As said my master project would not exceed Walloid C2S0 and the rest of the plan either will be a hobby/Phd/or even a dream job at an oil field company here in Norway :-)

Wish me lots of luck ...

Shahab.