Mechatronics & Robotics

Installing ROS 2 (Melodic) in Windows 10

2018-09-30T23:07:00.001-07:00

Introduction:

Requirements:

Objectives:

Methodology:

Summary:

Remarks:

Conclusion:

Neato Lidar XV11 + ROS

2018-08-28T18:33:00.001-07:00

Introduction:

Hello once again, we are quite a bit focus on finishing tutorials about lidars. These kinds of sensors are important because SLAM in R.O.S rely much about the use of it. As much as possible we are trying to choose, reverse engineer , economize the build of our rotating laser sensors. Our purpose is to craft and replicate lidars into a more affordable and efficient distant ranging sensors. Otherwise, though robotic is interesting, not everybody will be doing industrial robots because of cost and that is not practical for a mass patronage.

For a few days we had already tackle introduction and hands on tutorial as motivational guide for a hobbyists to start using R.O.S. After familiarizing the usefulness , we will proceed to interfacing encoders and motors to relate the actuation ,speed,revolution of motors when running,this time all are test and first. Next step is to put wheels on the chassis and see for our selves how our code able to simulate movement of the robots from the visualized GUI to what we are able to observe it in a real world action.

One of the cheapest and known lidar was the Neato XV11 lidar, this was because a vacuum cleaner robot was deployed world wide so old machine produce stocks of 2nd hand lidars. We choose this surplus or second hand lidar because of course it is cheaper and its hacks had complete documentations on the internet , so not a bad choice for us Filipino.

I have just bought Neato XV11 lidar recently and saw a lot of tutorials on the internet and am glad about it. One I have observed was that it needs to power source 5V and 3.3V other hobbyist tried to isolate the source so they needed two modules (DC-DC step down and USB-to Serial), but its obvious that USB-t Serial module has 5V/3.3V so it is perfect for the Lidar power requirements.The rest are instruction to be discussed below. Hope we can get more units as stocks online :)

Requirements:
Neato XVII Lidar
ROS Kinetic
Ubuntu 16.04
USB to Serial module with 5V and 3.3V

Objectives:

Methodology:

Summary:
Trouble:
Shooting:

Conclusions:

It is ideal cost effective LIDAR for hobbyist.

LaserScan ROS + Arduino

2018-08-26T01:23:00.001-07:00

Introductions:

Yes, a happy weekend plus a holiday on Monday, so with choco and cookies placed on the table ah what a little time to spare ticking keyboards here. Anyway, we will be continuing our R.O.S tutorials , and its all about understanding how LIDARs works in R.O.S. We knew that the scattered lines served as the perception of a robot using this kind of sensors. These lines forming figures creates a dimensions of area used to be navigated by robots.The rays of line were formed as a collection of distances measured or sensed by LIDAR/LEDDAR).Thus infra red lights emitted by transmitter are then feedback to the receiver usually the photo diode. An array of these measured distances will be included in the parameters' value of scanning angle,time,and the number of points how wide is the coverage of scanning.All these parameters are wrapped in the "Sensor Messages/LaserScan" in a R.O.S string packet format.

This time, the deal is using rosserial library, "ros_lib and ROS Sensors Messages:: LaserScan. The Arduino DUE will process the publishing of "LaserScan" messages and its topic. Using "ros_lib" an Arduino Due communicate with the host R.O.S installed in the computer (Laptop/Desktop) both of which are connected physically via serial serial interface . In the near future of these tutorials, using Arduino/microcomputer will not be ideal anymore in integrating multiple sensors to R.O.S. This is because processing and computing will be at risk and not a practical design of R.O.S application. In short, the use of microcontroller is only to interface sensor modules yet most of single board computers have IO ports to their advantage.

Thus , what we will be doing is to get a common measuring modules such as SAMSUNG infrared or Ultrasonic SRF04 considered as poor man's LIDAR. SG90 servo motor will carry and rotate the sensor with the speed relative to the frequency of its data acquisition. The angle of rotation is as wide as 180 degrees angle, a back and forth or a clock and counter clockwise directions. It is possible to rotate 360 degrees wide but it requires a slip ring and that is an additional cost. The interval of time,angle, and number frequency of measuring distances can be set or adjusted depending the type of sensor or modules being used. To accurately dump data in R.O.S Laser scan messages , is to configure its parameter settings, for example a 180 degrees maximum angle if divided by desired 90 points then the angular interval of scanning is 2 degrees.

The simple steps to code ROS Laser Scanning,first is to initialize Sensor messages,its laser scan function ,and to check topic that publish messages. The finale, use the R.O.S visualization "rviz" to simulate the functionality of DIY LIDAR. Okay? So let's get this done :)

Requirements:
Software: Ubunto 16.04, ROS (kinetic)
Hardware: Arduino DUE, SBC or Laptop,SG90 Servo
Optional : sensors (ultrasonic or infra red)

Objectives:
1) To be able to publish a ranging(distance measurement sensor) messages from a DIY LIDAR to ROS .
2) To be able to study algorithm or program to collect array of measurements and feed(publish) it into a R.O.S messages format.
3) To create a program using rosserial library "ros_lib" from Arduino to ROS

Methodology:
Testing Arduino Due sample code to fake laser array of data(ranges)

Arduino Due code for Laser scan

Please copy and paste the program

 
 
/*
Simple code for LaserScan that can be substituted by any ranging 
sensor (LIDAR,InfraRed,Ultrasound and etc).
It give details to the use of sensor message in ROS 
http://docs.ros.org/melodic/api/sensor_msgs/html/msg/LaserScan.html

The code can be used and be ported as is -Thank you.

Christopher Coballes
ROS Philippines

*/

#include "math.h"
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif


// ROS includes
#define USE_USBCON;
#include <ros.h>
#include <ros/time.h>
#include <sensor_msgs/LaserScan.h>
sensor_msgs::LaserScan Laser_msg;

#include <Servo.h> 
//
float Angle_min;
float Angle_max;
float Angle_increment;
float Time_increment;
float Scan_time;
float Range_min;
float Range_max;
float Ranges[90]; // max of 90 measurements
float Intensities[90];

int publisher_timer;
int laser_frequency = 100; 
int point_reading = 90;
float time_Now,time_Later;
ros:: Publisher pub_Laser("LaserData", &Laser_msg);
ros::NodeHandle nh;
//char frameid[] ="/sonar_ranger";
Servo Rservo;

void setup() 
{
  nh.initNode();
  nh.advertise(pub_Laser);
 // Serial.begin(57600);
  Angle_min = 0;
  Angle_max = 3.14159265;
  Angle_increment =  3.14159265 / point_reading; //  90 measurement points
  Time_increment=  ((1 /laser_frequency)/point_reading);  // (1 / laser_frequency) / (num_readings);
  //Scan_time = 1.5;
  Range_min = 0.0;
  Range_max = 100.00;
  Laser_msg.ranges_length = 90;
  Laser_msg.intensities_length = 90;
  Rservo.attach(9);
  initRanges();
}

float deg2Pi(float angle)
{
  float rad ;
  rad = angle /3.14159265 ;
  return rad;
}

float getDistance()
{  
   float randDistance;
   randDistance = random(0.5, 4.00);
  // randDistance = 0.3;
   return randDistance;

}

void clearScan()
{
  int tos;
 // Serial.println("CLEARING");
 // delay(300);
  for (tos = 0; tos <= 180; tos += 2) { 
    //   Serial.println(tos+"OK");
       Ranges[tos]= 0 ;                     
  }
}

void initRanges()
{
  for (int set_points = 0 ; set_points<90; set_points ++)
  {
    Ranges[set_points] = set_points;
    Intensities[set_points] = set_points*set_points;
  }
}

void loop() 
{
 if ((millis() - publisher_timer)> 50 ) 
  {
   
    Laser_msg.header.stamp = nh.now();
    Laser_msg.header.frame_id = "/Lidar_frame";
    Laser_msg.angle_min = Angle_min;
    Laser_msg.angle_max = Angle_max;
    Laser_msg.angle_increment = Angle_increment;
    Laser_msg.time_increment = Time_increment;
    Laser_msg.range_min = Range_min;
    Laser_msg.range_max = Range_max;                 

    // scan_time
     time_Later = millis();
    for (int angle_Setpoints = 0 ; angle_Setpoints < point_reading; angle_Setpoints ++)
    {
      delay(5);
     Rservo.write((angle_Setpoints+1)*2); 
    // Serial.println((angle_Setpoints+1)*2); 
     Ranges[angle_Setpoints]= getDistance();
     Laser_msg.ranges[angle_Setpoints] =  Ranges[angle_Setpoints];
     Laser_msg.intensities[angle_Setpoints] =  Intensities[angle_Setpoints];
     
    }

    
    time_Now  = millis();
    Scan_time = time_Now - time_Later;
    Laser_msg.scan_time = Scan_time;
    pub_Laser.publish(&Laser_msg);
    publisher_timer = millis() ;
  }
  nh.spinOnce();
 // delay(500);

}

A simple setup of our DIY Lidar (photo credit to the photographer)

Open four CLI terminals:
Run the ros core "roscore"
robook# roscore

Communicate between ROS and Arduino using rosserial
library
robook # rosrun rosserial_python serial_node.py /dev/ttyUSB0
robook# rosrun rosserial_arduino serial_node.py _port:=/dev/ttyUSB0

Make sure that the "/laserScan" topic is being echoed or broadcasted to ROS.
robook# rostopic list
robook# rostopic echo /LaserScan
If Arduino DUE is able to bombard those collected ranges in ROS , scrolling
stream of string may appear in the screen

Set the transformation of the frame required to accurately map the laser data
robook# rosrun tf tf_publisher_transform 0.0 0.0 0.0 0.0 0.0 0.0 /base_frame /Lidar_frame

Displaying or visualizing the laser data, we can use RVIZ to plot
it in its grid map.
robook# rosrun rviz rviz

By setting the ROS Visualizer "rivz": fixed frame "Lidar_frame" and LaserScan
"LaserScan". The display would eventually appear same as the screen below.

Making sure that RVIZ is properly configured , LaserScan
topic is receiving messages coming from Arduino Due,also
transformation is set properly.

Summary:
Trouble: Arduino is not syncing to rosserial
Shooting: Place "#define USE_USBCON" before the include "ros.h"
Trouble: No display of laser data in RVIZ
Shooting : Check if there is a laser scan topic
Use #rostopic echo /LaserScan -> if this is the topic

Conclusion:
A simple code of a possible integrations of different ranging sensor to ROS

Ultrasonic Sensor + ROS (rviz)

2018-08-05T06:48:00.001-07:00

Introduction:

My arduino uno starter kit is saved, nobody dare to get the assignment, but we need to continue this ROS tutorials come what may.

I had been observing many questions in ros.org most of these problems are the ROS howtos , but it needs to understand both side of a learner and the business of a developer. Well Robotic Operating System aka ROS had proven its system dexterity . However , I would say it has along way to go to dominate all robotics software in the market. Those are the business side of the deal because consumers are still needing more robots that can perform dynamic services to both households and companies tasks. Also clients are expecting that an AI almost similar to human comprehension can be used in robots.Somehow its a gradually happening today, people and business men alike are curios and excited what these machines are capable of.

Wait a minute,as I am saying we forget some part of the pi, and these are the learners of robotics technology they are new breed of technicians, programmers and analysts. Or let may ask this ,who would be the sales representative of robotics company,how the marketing competitions will be observed sooner.Whatever happens we need to realize and consider that there will be a group of learner willing to participate the trend, but in this current scenario developers are focus on advancing development to fast tract their robotics innovations-its a point of no return. So since not all robotics knowledge is an open book yet, everybody is searching for an answers to simplify and shorten their learning curve as much as possible.

Indeed they need tutorials with learning by doing approach , and yours truly is trying to achieve that goal ,and we are also the same-learning in progress. So please accompany as while we will treasure the technology of robotics and how ROS would simplify this intellectual craving. (for edition

Objectives:
To use std_msg/range in ROS
To use ultrasonic SRF04 sensors and its parameters
To simulate the sensor's (frame id, topics) data inside ROS visualization tool (rviz)

Requirements:
Software: ROS Kinetic + Ubuntu 16.04
Hardwares: Arduino Mega + Ultrasonic SRF04

Methodology:

Setup of the experiments using arduino mega 2560 and ultrasonic SRF04

Copy and paste the program

 
 
/*
  Ping to Sonar ROS
  The circuit:
 - +V connection of the PING))) attached to +5V
 - GND connection of the PING))) attached to ground
 - SIG connection of the PING))) attached to digital pin 7

  created 3 Nov 2008
  by David A. Mellis
  modified 30 Aug 2011
  by Tom Igoe
  ported to ROS July 31,2018
  by Christopher Coballes 
  This example code is in the public domain.
  http://www.arduino.cc/en/Tutorial/Ping
*/

 #include <ros.h>
 #include <ros/time.h>
 #include <sensor_msgs/Range.h>
 
 ros::NodeHandle  nh;
 sensor_msgs::Range sonar_msg;
 ros::Publisher pub_sonar( "rangeSonar", &sonar_msg);
 float sensoReading = 0;
   
// this constant won't change. It's the pin number of the sensor's output:
const int trigPin = 7;
const int echoPin= 5;

char frameid[] ="/sonar_ranger";
void setup() {
  // initialize serial communication:
//  Serial.begin(9600);
    nh.initNode();
    nh.advertise(pub_sonar);
    pinMode(trigPin,OUTPUT);
    pinMode(echoPin,INPUT);
    sonar_msg.radiation_type = sensor_msgs::Range::ULTRASOUND;
    sonar_msg.header.frame_id =  frameid;
    sonar_msg.field_of_view = (10.0/180.0) * 3.14;
    sonar_msg.min_range = 0.0;
    sonar_msg.max_range = 10.0;
    
}
int duration;
unsigned long publisher_timer;
void loop() {
    sensoReading = 0 ;
    
  // establish variables for duration of the ping, and the distance result
  // in inches and centimeters:


if ((millis() - publisher_timer)> 50 ) 
   {
    digitalWrite(trigPin,LOW);
    delayMicroseconds(2);
    digitalWrite(trigPin,HIGH);
    delayMicroseconds(10);
    
   duration = pulseIn(echoPin, HIGH);
   sensoReading = duration *0.342/2000;
   //sensoReading = getDistance;
   sonar_msg.range = sensoReading;
   //Serial.println(sensoReading);
   sonar_msg.header.stamp = nh.now();
   pub_sonar.publish(&sonar_msg);
   publisher_timer = millis(); //publish once a second
   
   }
   
  nh.spinOnce();
    
}

Please check the program
Test the sonar program via serial monitor, please uncomment "Serial.println(sensoReading)

Open four terminal for each cli commands

1)Run "roscore" command

2) Run Arduino with serial port argument

3)Check the topic list

4)Echo or display the data content in the "sonaRange topic"

5)Run ros visualation tool "rviz

6)In rviz GUI

7)Change frame id name from map to "/sonar_ranger"

8) At the bottom of the Panel Select "Add" button to add "Range" for ultrasonic
and add the publish topic "/sonaRange"

9) Select color for the prism

10) In Rviz GUI you can see the prism length varies according to the
distance emitted by the Sonar SRF04 ultrasonic sensor.
Simulate the rviz if the circular prism change is lenght as you will interrupt
the sonar range of the ultrasound.

11) Save the rviz configuration
rosrun -d rviz sonar_rviz to rerun the GUI of the sonar rviz

12) Realtime simulation of Ultrasonic "SRF04 inside RVIZ

Remarks:
We summarize the use of std_msgs using range of ultrasound

Summary:
If roscore dont run in the cli please wait because it might be initiating
Or please check if the current ip address is the one being assigned in the /etc/hosts

Conclusion:
Simple experiment to use ros visualization tools

Hello World ROS (Robotic Operating System)

2018-07-27T19:41:00.002-07:00

Introduction:
Everybody can do programming in ROS, as much as they are interested to explore the importance of this software to simplify application of Robotics. These blog will literally explain the application of ROS hence if the reader already understand this simple tutorial. I would suggest to take the next steps/ experiments here .

Requirements:
Software: Ubunto 16.04 ,ROS (commands: roscore, rosrun,rostopicdriver: rosserial_arduino)
Hardware: Arduino UNO/Mega 2560, RPi or Laptop/Desktop

Objectives:
To learn the first stage of ROS through learning by doing
To use ROS to communicate an Arduino to PC
To test a simple publishing and displaying of data that uses ROS environment

Methodology:

Simple hardware setup

Install ROS library for Arduino either by:
robook# sudo apt-get install ros-[PACKAGE-RELEASE-rosserial-arduino
robook# sudo apt-get install ros-[PACKAGE-RELEASE-rosserial

Or install if from the source
Download ros library from its repository in the source folder of catkin workspace directory
robook# cd catkin/src/
robook# gitclone git https://github.com/ros-drivers/rosserial
robook # cd rosserial/arduino_rosserial/roslib PATH/Arduino/libraries
Then rename the original "ros_lib" to the ros_lib.bak
robook# mv rosserial/arduino_rosserial/roslib rosserial/arduino_rosserial/roslib.bak

Select ros_lib from rosserial driver
robook# cd rosserial
Copy "ros_lib" in the Arduino library folder
robook# cp ros_lib PATH/arduino/library

Check "ros_lib" in Arduino IDE "Built-in/Examples"

Cut & paste the code modify it according to your own test and checking

 
  /*
   * Source Code Hello World 
   * rosserial Publisher Example
   * Prints "hello world!"
   */
    
   // Use the following line if you have a Leonardo or MKR1000 
   //#define USE_USBCON 
    
   #include <ros.h>
   #include <std_msgs/String.h>
   
   ros::NodeHandle nh;
   
   std_msgs::String str_msg;
   ros::Publisher chatter("chatter", &str_msg);
   
   char hello[13] = "hello world!";
   
   void setup()
   {
     nh.initNode();
     nh.advertise(chatter);
   }
   
   void loop()
   {
     str_msg.data = hello;
     chatter.publish( &str_msg );
     nh.spinOnce();
     delay(1000);
   }

Open the first terminal to run ros core environment "roscore"

Open the second terminal to run the serial interface betwen ROS system and Arduino link its port
robook# rosrun rosserial_pythoon serial_node.py /dev/ttyACMO

Open the third terminal to display messages in the "chatter" topic
robook# rostopic echo chatter

Remarks:
Trouble: "Unable to communicate with master with roscore running"
Shooting: Check the ROS_MASTER_URI or ROS_HOSTNAME
in /etc/hosts or in ./bashrc

Trouble: "No rosserial_arduino
Shooting: Install or check the new files in repostitories or github

sudo apt-get install ros-[package version]-rosserial-arduino
sudo apt-get install ros-[package version]-rosserial

Summary:
We wanted to actualize first a simple program to run ROS environment , install rosserial_arduino , a publisher for a data message and echoing/displaying ROS topic.

Conclusion:
First stage of learning by doing ROS.

Robotics: Reality and the Challenge of Applications

2017-07-31T08:41:00.001-07:00

Robotics: Mobile ,Wheeled , Pedal Robots

2017-07-31T08:36:00.000-07:00

Robotics: 3D Printed Robot , Cart Robot

2017-07-31T08:11:00.001-07:00

Robotics: Arduino Smart Cart,Lego Robots

2017-07-31T08:03:00.003-07:00

Arduino motors and sensors with ROS interface Examples

2017-07-11T08:00:00.004-07:00

Basic Mobile Robot w/ ROS

2017-07-11T07:45:00.003-07:00

We will discuss a simple mobile robot that can be integrated to Robotic Operating System.

As we all knew ROS currently is the most available programs and libraries that we can used to build

a good robot. ROS support robotics from hobby to industrial grade application of robotics.ROS is intended to be run on computer hardware, like the notebook you indicated. rosserial is intended to allow you to bridge physical hardware and sensors to the ROS computation graph using a micro controller (at this time, the Arduino has client libraries developed). rosserial should be used when the hardware doesn't already have a ready-made interface and driver (for example, you shouldn't use a GPS receiver with rosserial).

Requirements:
IMU
Motor with encoder
Odroid C1+
Ultrasonic
Laser range finder.

Objective:
To build a simple robot that can use a ROS.

Methodology:

Subscriber

A motor controller implemented on an Arduino will want to create a ROS Subscriber that will listen to a Twist Message on a given topic. Many people use /cmd_vel as the topic for this purpose.

Now, with a ROS core running, and the rosserial_python node running, you should see a /cmd_vel appear in a rostopic list command. You can use another node on your system to publish messages to /cmd_vel, that the Arduino will interpret into motor commands. The Arduino firmware should be able to turn a Twist message (linear and angular velocities) into appropriate motor commands for your platform.

Publisher

Another application may be reading an ultrasonic rangefinder to l physically interface the line sensor to the Arduino, and then create a ROS Publisher. It could then make this message type a Float32 if you wanted to represent a floating point distance or perhaps an Int32, if you wanted to get the raw ADC values. These would then be published into the computation graph on the topic of your choice (say /rangefinder). You could then see these values by doing rostopic echo /rangefinder on the command line.

Integrating Subscriber and Publisher

If the robot can receive movement commands from ROS via /cmd_vel and can broadcast readings of the physical world, then you can start creating (or using) other ROS nodes to process this data and make decisions.

If the robot can accept command velocities, can publish range scans, and can publish odometry information, you can start to use higher-level nodes for navigation, localization, and path planning.

Navigation

Localization

Path Planning

Summary:

Conclusions:

Robotics Philippines (A long overdue)

2017-07-08T06:38:00.002-07:00

Introduction:

Good day to all the readers, and we hope that this journey of uncovering the reality of robotics should be studied ,implemented and create a tangible robotics platform.

The design of mobile robotics platform is essential to every ages of learner,users and researchers , in this techno blog we will try our best initiative to layout every methods of learning about robotics.

Since I was a kid Robotics had made me so fanatic of machine acting like a human,hence it had given me a lot of motivation. The only problem at the time was that when you are leaving in a barrio everything thing would seems a fantasy. However, since I was so enthusiastic to do something related to automation every electronics stuffs then were a treasures: damaged radio,cassette tapes,turn tables, RC motors and etc . of stuff to feel me like I was on to to study engineering,

I do believe that encouragement to engage in Robotics is not enough to turn our place to engage in Robotics. Although that is a big factor, a lot of effort should be shared to them so that they can do robots not a toy. I don't think its a bit difficult but its true that every concern old people, the adults should be the proponents of this big effort-Engineer,Teachers, Researchers,Hobbyists. As much as possible we should take consideration and responsibility that we need to showcase to them how robots was done, the technology and foremost our own tangible outputs, and ending up questioning if we really have done robots? So if that is the main problem how can we teach a kid to learn robotics if we ourselves doesn't seem to know to innovate one. I believe there should be a continuity of example that must be shown to them from toys, to line follower to mechatronics to robotics. A wheeled, legged or winged robot. Well that is robotics.But not only that, where can we all purchase ,or outsource materials (electronics, cpu,mcu board, sensors,hard frame)? Sad to say its seldom that you will get a deal from machinist about precision, the fact is, when accuracy of framing or gearing project they would simply reject it. For them, it is a complicated things, time consuming and less profits. Only to find out that their skills are very much outdated to the challenge new technologies like robotics development. So the solutions for the serious Roboticists are to deal to a machining company which price offer could blow out a whole project;s budget.

In short this was one of hindrances why we could not widely pursue robotics. One thing more, even the old or adult hobbyist are vying to misrepresented the younger generations that a line follower toy is a robotic field a concept that perhaps is true but if we are doing for decades it only to compromise the evolving technology of robotics and it turns out of just dreaming and appearing to the kids -we simply a Roboticist. In my perception that system is not leading to a good example. The last but not the least ,is a question that where else did our Graduates people,Masters and Doctorate gone? Where they simply enjoying the the social stature they benefited from obtaining diplomas? At what level the complex equations in math simply make it to the understanding of average people? Since Robotics requires higher mathematics (well it all goes down to algebra) does it means the breakthrough will fall only to a limited people? Well most of the developed countries simplified all mathematical theories into actuality good for their graduate people efforts to contribute a mass of simplified knowledge comprehensive and understandable to every constituent understanding. An interesting outcome was that robotics competition welcomes every people irrelevant to their educational attainment.Let us look to the level of their robotics nowadays,how it incubates their new technologies ,and contribute to the wealth of their economy- a chain of efforts for success of every constituent in their country. So and so. Anyway this is it, and I must challenge myself to do this initiative hoping some people out there will do the same or much better.

Elementary Robotics.
Application of robotics in this stage is almost showing them a programmable toys which will give them interest in Robotics. A simple automation in controlling of a toy car will be a good example to teach them a moving machine and to its simple controls of run,directions, speed and some signalling ,warning of its state.

K-12 Robotics.
In this stage junior and senior high school can now learn computer programming with application of mathematics and common A.I must be included at this time a fuzzy logic.On the hardware side they are now well aware of CAD as there were lots of opensource or freeware on the internet. The combination physics and basic electronics will be their tools on the hardware side of robotics.The recommended platform for the first teaching course is the Arduino smart car, after mastering the said level they can proceed to a simple cart wheeled robot WiFi or blue-tooth controlled or has a built in coded AI.

BS College Robotics

In this stage a serious exploration of Robotics must be studied yet collaboration with other group of students should be encourage ,ie; computer science students and mechanical engineering students, electronics and mechanical engineering , computer science with electrical engineering or computer engineering combine with IT,IMS and technicians.The focus is applying higher mathematics in programming resulting to the application of AI( CS students are RockStar on this).Computer Engineering is reliable to the design of CPU, the bulky of Load processing, their skills can be used to data network ,cluster and also programming.Electronics engineering can participate the radio communication (beacon, GPS) and the route of robotics navigation,other course are contributory with their own arsenal of skills. The mobile platforms are 3D Printers, CNC Design, Robotics Arm ,Bi Pedal Robots and Autonomous wheeled Robots. Some tools that must be learn are ROS,Robotics Operating System,it is expected that they are able to integrate all the applications provided by the opensource community.

Graduate to Industry Robotics

In this stage we seek the opportunity to apply all knowledge,tools and design into a tangible form of machine- as we can say Robot as we are using the field of Robotics. Robotics or Robot enthusiast must works to help the community solve the basic problems of life .Otherwise lets stop calling papers as it will not elevate the standard of life that we suffered today. Let us not hide for the benefits of those diploma and other credential putting us in the pedestal of nothingness except "Title".The focus of the robotics here should be in the Agriculture-Robotics, Security-Robotics-Aqua Robotics,Navigation and Transportation. It is also considered a recourse to simplify all theoretical knowledge into a reality that can be spoken and understand by a common people and younger generations.The stage where experienced technocrats, policy makers are put in pressure to deliver technology in the counter -no excuse.

Requirements:

Simplifying hidden mysteries of Mathematics into the common tongue of average Filipinos.
Say it ,simplify into a language being expressed everyday in the life of every Filipino.
Harness an Opensource of free technologies of Robotics used by the Global Industry.
Let us compete and challenges ourselves into Robotics win or loss its nothing for the technological advancement of this country.
No more call of papers lets put the podium to call for the machines-Robotics.

Methodology:

I)Technology Transfer
Copy ,Cut and Paste
Opensource industrial grade technology
Outsourcing surplus staffs(frame and sensors)
Competitions as everybody is welcome Janitor to PhD

II) Education Training and Technology Language conversion
Elementary
High school
College

III) Coordination to Government Policy makers
Reduce administrator cost and shift the budget to sustain engineers/inventors
Reduce age of setting administrator who are funds of travels and too much expenditures
Put the budget to a nationwide grant of technology incubation
Put the budget to a nationwide competitions or innovation
Put the credential on the tangible outputs of technologies not the multiple choice of titles
Requires all the university and colleges to create machine the feasible budget as possible.

IV) Produce technological outputs
Regional Robotics products
National Robotics products
ASEAN Robotic products-lets raise who will will dominate Robotics in south east asia

Summary
A ....

Conclusions:
B...
...final edition and para phrasing will follow after the completion of the subject topics

Hokuyo 2D/3D Lidar

2017-07-08T06:33:00.003-07:00

Introduction:

Objective :

Methodology:

Summary :

Conclusions:

LMS 200 SICK 2D/3D Lidar

2017-07-08T06:25:00.001-07:00

Introduction:

Requirements:

Methodology:

Summary:

Conclusion:

ROS Setup and Installation

2017-03-28T18:43:00.002-07:00

Installation

ROS Kinetic ONLY supports Wily (Ubuntu 15.10), Xenial (Ubuntu 16.04) and Jessie (Debian 8) for debian packages.

Configure your Ubuntu repositories

Configure your Ubuntu repositories to allow "restricted," "universe," and "multiverse." You can follow the Ubuntu guide for instructions on doing this.

Setup your sources.list

Setup your computer to accept software from packages.ros.org.

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

Mirrors

Source Debs are also available

Set up your keys

sudo apt-key adv --keyserver hkp://ha.pool.sks-keyservers.net:80 --recv-key 421C365BD9FF1F717815A3895523BAEEB01FA116

Installation

First, make sure your Debian package index is up-to-date:

```
sudo apt-get update
```

There are many different libraries and tools in ROS. We provided four default configurations to get you started. You can also install ROS packages individually.

In case of problems with the next step, you can use following repositories instead of the ones mentioned above ros-shadow-fixed

Desktop-Full Install: (Recommended) : ROS, rqt, rviz, robot-generic libraries, 2D/3D simulators, navigation and 2D/3D perception
- ```
sudo apt-get install ros-kinetic-desktop-full
```

To find available packages, use:

apt-cache search ros-kinetic

Initialize rosdep

Before you can use ROS, you will need to initialize rosdep. rosdep enables you to easily install system dependencies for source you want to compile and is required to run some core components in ROS.

sudo rosdep init
rosdep update

Environment setup

It's convenient if the ROS environment variables are automatically added to your bash session every time a new shell is launched:

echo "source /opt/ros/kinetic/setup.bash" >> ~/.bashrc
source ~/.bashrc

If you have more than one ROS distribution installed, ~/.bashrc must only source the setup.bash for the version you are currently using.

If you just want to change the environment of your current shell, instead of the above you can type:

source /opt/ros/kinetic/setup.bash

If you use zsh instead of bash you need to run the following commands to set up your shell:

echo "source /opt/ros/kinetic/setup.zsh" >> ~/.zshrc
source ~/.zshrc

Getting rosinstall

rosinstall is a frequently used command-line tool in ROS that is distributed separately. It enables you to easily download many source trees for ROS packages with one command.

To install this tool on Ubuntu, run:

sudo apt-get install python-rosinstall

Controlling Nikon D40

2011-05-05T18:30:00.000-07:00

Introductions:

This time lets try the other brand of camera (Nikon D40X ) and it will be coming from someone who is willing to sponsor for the curiosity of this test.I have mentioned it for the past few weeks and hey the camera just arrived this Friday(May 6,2011 Note::-Pacqiao and Mosely fight can't wait to see it; then Sir Edwin 'Son baptism -Ninong ako..) am so excited to test the scanning software and see if something could happen so different (Canon Vs Nikon)

Requirements:
RoBook Scanner beta-release
Nikon D40X
PC -Fedora OS

Objectives:
To test D40X in our scanning software and see some extra features:

Methodology:

Detail(1)Oh my.. I have a plenty of them

Detail(2) Nikon D40X ready to shoot

Detail(3) Turn off the light and see the working settings

Detail(4) Yes! Its been detected

Detail(5)Lets check gphoto2 first

Detail(6) Let's see what we can tweak(gphoto2 --list-config)

Detail(7) Menu setup (MTP/PTP)

Detail(8) Capture output focusing just the sjubject

Detail(9) Video of controlling D40X

Remarks:

First of all many thanks to Sir Edwin for lending me his personal Camera (Nikon D40X) that I will be using in this test.(..again thanks Sir!)

With the observations I'd experienced , just a little modification for the scanning software then its ready to accommodate all brands of cameras.

Conclusions:

RoBook Scanner (Video Capture)

2011-04-10T19:52:00.001-07:00

Introductions:

Once again, our RoBook Scanner will be on its next level, this is how to incorporate Video capturing on the RoBook Arm.Basically our objective is to guide the Robot itself the variations of its movement and how to adapt every conditions of changing sizes of different books.Anyway, we'll use it to monitor the scanning system's activity and to find out if ever there would be an occurrence of malfunctions and see for ourselves also a real time scenes of RoBook in actions-how about that?

As we've mentioned a while ago, we were using gambas for Linux and the forum now is somewhat asking the examples on how to use "picturebox"to display video files or much better if the features capability should be for a real time video streaming.Well, as the date of writing I don't know much about the updates , but I am trying to seek for a solutions myself.

But before that(our discussion obviously), I have changed my platform -oh- a 64 bit quad core server type DELL computer(a cute monter machine)-How about that bro?I found out again installing Ubunto is different from Fedora ,perhaps the technical terms in spelling per se is different -they have the unique term respectively . So you better use "yum search " to what was you usually did in Ubunt "apt-get" then install it if the file ,package or resources are available-quite tasky.

I have come up to an idea that, I need mplayer to do task (video4Linux perhaps) and a "/video/mywebcam/ " example included in Gambas2 and will try if I could pipe it out in a real video streaming- and lets see-hope we could do that.

Requirements:

Libraries for Mplayer,Xine and VLC:
a52dec.x86_64 0:0.7.4-15.fc11
faad2-libs.x86_64 1:2.7-1.fc11
fribidi.x86_64 0:0.19.2-2.fc12
libdca.x86_64 0:0.0.5-5.fc12
libmpeg2.x86_64 0:0.5.1-8.fc12
libvdpau.x86_64 0:0.4.1-1.fc14.1
lirc-libs.x86_64 0:0.8.7-1.fc14
live555.x86_64 0:0-0.27.2010.04.09.fc14
mplayer-common.x86_64 0:1.0-0.119.20100703svn.fc14
opencore-amr.x86_64 0:0.1.2-1.fc12
xvidcore.x86_64 0:1.2.2-2.fc14

xine-ui.x86_64 0:0.99.6-25.fc14
xine-lib.x86_64 0:1.1.19-2.fc14.1

Objectives:
To include Video Capturing in RoBook Scanning system(period!)

Methodology:

I)Installing Mplayer (Two options: Libna or RPMfusions)
1)Set your proxy for downloads
2) Using Libna repos
rpm -ivh http://rpm.livna.org/livna-release.rpm3) Using RPMfusions repo
3)RPMfusions repo
rpm -Uvh http://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-stable.noarch.rpm
rpm -Uvh http://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-stable.noarch.rpm
4)Another RPMfusions repo
rpm -Uvh rpmfusion-free-release-stable.noarch.rpm rpmfusion-nonfree-release-stable.noarch.rpm

or you can visit another blog that serves as reference
http://www.redips.net/linux/yum-install-mplayer/
II Coding with Gambas2
0) Click the project->properties->components menu
1) Enable the gb.v4l video capture properties.
2) Requirements for the are gb.qt tool kit , gb.qt setting and etc.(requirements)

Detail(1): Gambas2 Componets

Detail(2) RoBook Arm GUI Interface

Detail(3) Left most side beneath this screen shot is the RoBook'sVideo

Remarks:

Conclusions:

RoBook Scanner II( Automation)

2011-03-14T22:53:00.000-07:00

Introduction:

Now is the time to move on to the 2nd phase of the project and that is automating the scanning process.But before anything else , camera automation is our concern first and if we are going to deal it that is the zooming features.
The zooming of a camera is in the category of capture calibration , every time user will be using this features for image viewing adjustment ,the motor is triggered and the actuation pushes the lens and causes its zooming- a requirements in scanning procedures.

Objectives:
To automate the camera capture mode
To sync the camera to the robot arm sensor.
Initial phase of RoBook Scanner automations

Requirements:
1) An installed libgphoto2 and gphoto2 and libraries
2) A Powershot camera (Canon G10)
3) USB Cables

Methodology:
Note:

Please use the gphoto manual to explore further command combinations.At the cli type:

root@localhost# gphoto2 --help

Installation:

Make sure nothing else has access to the camera, and kill any other possible gphoto instances.

root@localhost# ps aux | grep gphoto2

kill -9 pidof gphoto2
```
pkill PTP
```
```
pkill gphoto2
```

Gphoto Setup Camera:

```
gphoto2 --set-config capture=On
```
```
gphoto2 --set-config whitebalance=4
```
```
gphoto2 --set-config zoom=5
```
```
gphoto2 --set-config assistlight=Off
```
```
gphoto2 --set-config iso=0
```
```
gphoto2 --set-config canonflashmode=off
```
```
gphoto2 --set-config focusingpoint=0
```

Gphoto Testing Purposes

```
gphoto2 --set-config canonimgquality=0
```
```
gphoto2 --set-config canonimgsize=3
```

Gphoto Production Settings

```
gphoto2 --set-config shootingmode=3
```
```
gphoto2 --set-config aperture=18
```
```
gphoto2 --set-config shutterspeed=25
```
```
gphoto2 --set-config iso=0
```
```
gphoto2 --set-config canonimgquality=1
```
```
gphoto2 --set-config canonimgsize=1
```

Gphoto Camera toggle Focus

```
gphoto2 --set-config focuslock=on
```
```
gphoto2 --set-config focuslock=off
```

Gphoto Capture interval

Take Photos every 2 minutes

gphoto2 --capture-image --interval=180 --frames=0

Take videos every 2 minutes

   gphoto2 --capture-movie=2s --port=usb:001,075

Get battery level

   gphoto2 --get-config batterylevel | grep Current | cut -c 9-13

Detail(1) Video on G10 Mono capture automation

Detail(2) Video on G10 Stereo capture automations

Detail(3) Gambas (VB for Linux) Test program

Detail(4) Zooming and Remote Controls

Remarks:

Hints:
1) See to it that your PC is able to detect your G10
root@localhost/gphoto2/gphoto2/ ./gphoto2 --auto-detect
2) To set on automating the camera root@localhost/gphoto2/gphoto2/ ./gphoto2 --set-config capture=On root@localhost/gphoto2/gphoto2/ ./gphoto2 --set-config zoom=15
Note: Automation range depend on the zoom level of your camera (what was mine is g10)
3) To automate zooming on multiple cameras , just use the command
root@localhost#:/usr/local/gphoto2/gphoto2# ./gphoto2 --list-ports

Devices found: 7
Path Description
--------------------------------------------------------------
ptpip: PTP/IP Connection
serial:/dev/ttyS0 Serial Port 0
serial:/dev/ttyS1 Serial Port 1
serial:/dev/ttyS2 Serial Port 2
serial:/dev/ttyS3 Serial Port 3
usb:001,024 Universal Serial Bus
usb:001,023 Universal Serial Bus

So you can now freely include the ports and id....
root@localhost# gphoto2 --set-config zoom=20 --port=usb:001,023
root@localhost# gphoto2 --set-config zoom=20 --port=usb:001,024

Or we have the options every time we want to forcibly over write the captured image
root@localhost# gphoto2 --set-config zoom=20 --force-overwrite --port=usb:001,024

Future preferences:
Note:
As much as possible we should be able to zoom out (+) or in (-) an image as added calibration's features.Below are the suggested zoom call function:

# [Initialize Zooming]
def zoom(self,zoom,port)
captureCmd = [
"gphoto2",
"--set-config capture=On"
]
utils.invokeCommandSync(captureCmd, CaptureError, \
"Could not initialize zooming an image")
return zoom

# [Zoom Calibration values]
def zoom(self,zoom,port)
captureCmd = [
"gphoto2",
"--set-config zoom=%" % zoom,
"--port=%" % port
]
utils.invokeCommandSync(captureCmd, CaptureError, \
"Could not zoom an image with the value of %zoom" on \
% port)
return zoom

Conclusions:
So far So near to an end of deploying RoBook Scanner

RoBook Scanner Project

2010-07-06T20:00:00.000-07:00

Introductions:

It was this 1st semester(2010) of the year that caught my attentions of Book scanner and brought a challenging skills to design such machines,and that includes my scope of work for that year.Of course I was lucky enough to see those old model camera that were used before in scanning , microfilming and book digitization those were the day when you cannot apply zooming digitally but mechanically will do.One of our archivist, the pioneering staff in microfilming(media services)toured me in the whole wide area of the main library and was really surprised of what I had witnessed.I saw some giant frame of a scanner might be 6ft or 7ft long and a gigantic metal with belt for its actuation doing motion scanning.

And here we are again folks, after some assignments: MIS , Dbase and Data Network programming the next task is to design a book digitizing machine which is able to process or scan books automatically.For a little time ,I'm having a review with the code of machine vision ;of course an Open source or free software.Again,I could also apply my little background or know-how on mechanical and electronics (Mechatronics) ,But for now , I doubt if there is a n need of a simple embedded MCU control in this project automation -lets find out .This website"http://www.diybookscanner.org/wiki/index.php?title=Main_Page" help me a lot in doing such kind of Robo-Book Digitization project.Before starting the materials' procurement I have listed below words that need to be understood and define as much as possible in the sense that I could have a fast track project developments-Robo-Book Digitization

First, I have joined the Bookscanner group a community where in people are generously brilliant hobbyist who loves books for their respective good will to it.They could help you at whatever side of thoughts you would ask they have the complete solutions to have your own book scanning machine completely done. Secondly, my intentions to debug and decode decapod, a fluid project ; this is another major projects which aimed to innovate a book scanning machine.There are some development happen in the project that caught my observations : I have found out that they are using gPhoto (for capturing image) and OCROpus for " Optical Character Recognitions and some are patch scripts that wholly combined into one apps-Decapod.I was a little bit confuse of the technique used after the gphoto or image capturing process (what I mean was that its equivalent to ScanTailor)-what is that? And that could be a challenge of finding the decapod tricks to edit the picture before OCR engine took the functions.Actually I have some scratch program in testing the pre-process and the post-process.Well, lets take a look out what and how decapod are featured of -we are going to find a better and clearer understanding about decapod and then tweak it.

Thirdly, need to review all things up and down from start up until to the finale stages of this project then started my rough drop of budget proposal.

And the last, I was slowly outsourcing all the materials that need to be purchased and had downloaded all those open-source for my own scrutinizations- I am again burning my eyebrows and my hair is compressing a little bit(is that an R&D?) well they said it.Anyway,I have contacted some machinist out there to do the mechanical stuff for this project and not to forget the glassware also for the quotations of fiber glasses used for framing and handling.

freeCAD9 Camera model(8 mega pixels or higher specs) http://gdlp01.c-wss.com/gds/5/0300001565/02/PSG10_CUG_EN_02.pdf Stereo Data Maker SMD Documentations [Image reader] Scan Tailor ABBYY [OCR Software] Tesseract Ocropus Ocrad Gocr ConeiForm PageBuilder Decapod WorkFlow Objectives: To develop a low cost automated machine for book digitization To take advantage of a Book Drive design versus overhead scanner To enhance Open source OCR software To produce quality copy of scanned books Requirements: [Hardware] Digital High Resolutions Camera Frame Base PC [Software] Software Page Builder Camera Firmware PDF converter Methodology:

1) The first recourse is to have the outsourced materials at hand: The purchase of a digital camera,the initial stand to hold the camera and a simple lighting.

2)We will be using 3 different Linux -OS : Fedora ,Ubunto and CentOS these are my favorites platform and still believing that the this group will be the best Linux-OS ever.

3) I need the software at this moment, the candidates are: a) gPhoto b) ScanTailor c.1) Tesseract c.2)OCROpus C.3) d) Kpdf e) Page Builder f) Install Gambas-Basic g) install lib*(actually gambas filled the emptiness inside-Yahoooo!) 4) We do canvassing in the Hardware or DIY (Do it yourself) Thread screws Aluminum steel "4x2x6 ft" Acrylic glass (Fiber Glass) Huts & Volts Bulb,Fluorescent ,head lights halogen[gallium arsenide] (Ok, supply the missing item/s)

5)After downloading and installing the software we are going to create a single work flow of the system process-making it more convenient and making it an awesome fast book scanning- believe me.This will be done by using the enhance VB in Linux(Gambas-Basic) and programming the : API,CGI and its GUI(it might be using Stereo Vision-yes really it could).We will be tweaking the all these process in command line interfacing and catch it in the the GUI-you know what I mean bro?

6) Capture ------>Edit ----> Digitize/Filter------>Layout Recognitions------>Conversion----->Retouching Finale.

7) Have a simple (hardware[using FreeCad9] & software)assembly before the flash of a camera

8)Let us do it now!(wait I need to all list all the P.O) First Phase Second Phase Automation of a Book scanner Flip-Flop 1: Sliding pages and opening through frictions Flop-Flip 2: Sucking pages and opening it from left to right side Note:*** This blog page will only tackle Phase 1 of the project the software involves and the frame of the scanner

Detail(1) A decade archive of Camera

Detail(2) Museum Camera retreival

Detail(3) Branded Digitizing Camera

Detail(4) Old Digitizing Camera

Detail(5) Canon Digitizing Camera

Detail(6): Initial Proto-Design of " RoBook Scanner"

Detail(7) RoBook rotator

Detail(8):RoBook Rotator-Motor

Detail(9) : RoBook frame

Detail(9): RoBook Camera Stand

Detail(10):RoBooK Stand (Perspective view)

Detail(11): Camera Capture Calibrations-(Fluid Decapod File)

Remarks:

Conclusions:

A simple Robot Vision

2010-01-18T19:05:00.001-08:00

Abstract:
Machine Vision is one of the challenging Robotic application making a robots more intelligent to interact in its environment. Perhaps,the most complicated task is the technique or the skills' required to put Artificial Intelligence in the eye of a robot.The presentations will change its views about the complexities of having a robot eye, instead; it would give the most basic and simple approach with materials that is already present in your stuffs.

Introductions:
It is almost a decade that I started my personal machine vision research and I had made some successful attempts but not quite well to be proud of. I was then using my USB logitech camera(quick cam express so I got a usb version 1.X to be precised) which I had purchase then to one of my friends -perhaps he wanted to replace a new one . Another stuffs I had were the disassembled CPUs: P1 ;well I guess a socket 7 type of mother board with the installed Windows 98 operating sysem and a PII (450 Mhz) Hitachi running on Windows Millennium platforms .

As an electronics hobbyist, after I would lost my enthusiasm about robotics , its locomotion,embedded sensors and sort of AI applications. I turned to get more wandered of putting an eye to a robot (BEAM legged robot). So ,I started then searching these terms: robotic eye , machine vision and stereoscopic vision and lucky enough to find the following sites: http://www.boondog.com,http://www.generation5.org and a blog name " nullgel" but now I couldn't trace back the site and some of the machine vision url domain are not even maintained today.Maybe those authors had change change their research views or interest or upgraded their sites to a new URL domain (wish I could browse it again).Take note I was in the province at that time so how could you imagine purchasing those materials -really hard and disappointing.

Well ,that was my story , and I am again a little bit encourage to continue this hobby for a lot of reasons: First, wow amazing!, a very cheap dou-core CPU which will not even bother me about its image processing speed.Another is the availability of surplus web cameras with higher resolutions and a lot of features.

So where do I begin?Its almost a couple of years when I got stuck on so many hectic project's assignment and personal afflictions(long story to tell..) and recently finished it all the way. Here I am again, happy and very much excited about the opportunity to have time for my hobby now. Robotic eye ,machine vision ,AI ,dsp or Image processing it is going to rumble again!
It was early of this year that I browsed all the resources available on the net,not only that I keep on reminding my office mates " Hey I wanna buy your old junk web cameras" though they are hesitant they cannot resist because of my too much insistence(an annoying reminder for them) or just don't know if they are patience enough or having pity on me. Anyway,I had replace those camera with a new one-do you think they don like it?...Whatever I got now my web camera " Quickcam Express Logitech" period.

Now, let me approach you technically the How's and What's
Requirements:
Programming algorithm skills
Electronics skills
Advance Algebra skills

Materials:
Generic Web Camera (Logitech)

Methodology:

Web Camera

Electronic vision conversion

Program visual coding

VB edge detections program

Linear Programming.

Detail() : Two pcs of Logiteck QuickCam

Detail() : The hardcore part- disassembling of web camera