Archive for June 2013

Hound Mechanics Part I

One of the Hound goals was the low cost and a short development time. To achieve this it was decided not to design a chassis and work on top of a RC car chassis. This reduced the development time and avoided all the prototyping extra costs.

chassis

Crawler Chassis

We used not only the mechanical components but also the driving electronics like the electronic speed controller (ESC) and steering Servo. This meant that we had to work with a Ackerman style steering which has is advantages like an easier driving algorithm but also some disadvantages like the short turn ratio usual to this type of steering.

chassis

Chassis top view

Another main mechanical component is the camera arm which will be discussed in mechanics Part II. The arm was 3D designed from scratch in order to elevate the camera and be as effective as possible by maintaining the 2 servos in the base.

Arm test

Arm test

Since the main part of Hound was the ability to see, the camera had to had at least 2DOF of movement, so a pan/tilt system was installed in the arm so that the user could see various angles in front of the vehicle. Was used 2 standard hobby servos.
Pan Tilt Close up

Pan Tilt Close up

The base between the electronics and the chassis was made using a 3.3mm acrylic reinforced with 2mm aluminum bars to prevent flex while moving.
In part II we will discuss the Arm, chassis cover and the pro/con of choosing a Crawler chassis.

 

Attiny85 camera stabilizer

Description

This was designed as a proof of concept for our tiny lsm303 library. It is based on a Attiny85, 9g servos and our LSM303DLHC breakout board.

Although the accelerometer is not the best solution for a stabilizer due to the data noise induced by the vibration, for this proof of concept (and for some basic applications) it was enough.

breadboard_camera

Breadboard test

This is meant as a cost controlled stabilizer for a frontal mounted camera in our SUGV series the HOUND that we will be showing in future posts.

Material Used

Steps

We assume that you have basic knowledge of the arduino IDE and electronics

  1. Install Tiny LSM303 Library and all dependencies
  2. If not installed, install Arduino Core in the Attiny85 (good tutorial on how to do it)
  3. Upload the example sketch TinyStabilizer from the tiny LSM303 Library
  4. Connect the attiny and the LSM303DLHC as described in the wiring section
  5. Connect the Servos signal to the attiny if using different power supplies remember to have a common ground
  6. Power up servos and Attiny
  7. Move the breadboard to see the servos “compensate” the movement

 Wiring

Wiring diagram

Wiring diagram

Working

Note

The data itself from the accelerometer is very noisy, and don’t allow a smooth operation of the servos, so the best way to “clean” this data is to pass a low pass filter with a very low alpha (0.2 in this case)

The different outputs can be seen in the below graphic took with our DT Serial Chart , as you can see the “yellow” line has a much smoother curve in contrast with the raw data from the blue line.

Raw Data vs Filtered Data

We will soon make a post about how to get the data on the chart with our software.

 

 

ATTiny85 LSM303 Library

Description

This library is a port from the Pololu LSM303 library to be used with atmega Attiny85 using the Arduino bootloader.

It was designed to be used in small and affordable devices that don’t require many GPIO but would benefict from the use of a lsm303dlhc sensor.

It can be used to interface with our LSM303DLHC breakout board: http://www.dronetech.eu/store/index.php?route=product/product&product_id=51

We are still developing this library so follow the source code in GITHUB to get the lastest version.

Resources

Source code (GITHUB)


Dependencies

Wiring Example

LSM303DLHC    Attiny85
LREF      ->  5V (assuming your attiny is working at 5V)
VCC       ->  3.3V (regulated)
GND       ->  GND
SDA       ->  PB0
SCL       ->  PB2

Instalation

Unzip this folder to the Arduino Libraries folder.

Code Examples description


TinyHeading

Sends the current heading to the serial port using TinyDebugSerial

Wiring
Attiny85
PB3     ->  Serial RX 
PB0     ->  SDA 
PB2     ->  SCL

*note: since it uses the TinyDebugSerial it can only be used with the tiny-core

TinySerialData

Sends raw and filtered accelerometer data to serial port in csv format.

Wiring
Attiny85
PB3     ->  Serial RX 
PB0     ->  SDA 
PB2     ->  SCL

*note: since it uses the TinyDebugSerial it can only be used with the tiny-core *note2: it can be visualized with the DTSerialChart available here: http://blog.dronetech.eu/dronetech-serial-visualizer/

TinyStabilizer

Drives two micro servos compensating the pitch and roll of the board.

It uses only accelerometer data with a low pass filter. Slow and noisy but effective.

Wiring
Attiny85
PB3     ->  Servo
PB1     ->  Servo
PB0     ->  SDA 
PB2     ->  SCL

*note: this example requires de Servo8bit library available here: https://github.com/fri000/Servo8Bit

Dronetech Serial Visualizer

Description

This application reads a Serial Port for a csv string and parse it to a chart.

The chart series are customized and it can save the chart in a png file for future reference.

All data from serial port is saved in a textbox so it can be exported after to excel or other program for further analysis.

ScreenShots

application screenshot

Application screenshot

image_output

Output Image

Dependencies

  • .Net Framework 4.0
  • Visual Studio 2010

Files

Lastest compiled version (Windows MSI)

Source Code

Example usage

  • Prepare an arduino board with a example sketch that produces a csv serial stream
  • Connect a UART adapter to the USB port (http://www.dronetech.eu/store/index.php?route=product/product&product_id=53)
  • Connect the TX arduino to the RX of the adapter
  • Select port, baud, interval and series format.
  • Press the button and watch the chart go
  • To save an image just press save image at anytime, the file will be saved in the application folder

Series format

The series are generated based on a csv with the following format:

< Index >|< title 1 >,< Index >|< title 2 >

Index is the position on the csv stream that Y axes data is and the title of the Series.

Example:

csv stream -> 123,340

series format string -> 0|Sensor A, 1|Sensor B

Result:

Series 1 title = Sensor A

Serias 1 Y Axes value = 123

Series 2 title = Sensor B

Serias 2 Y Axes value = 340

Hound SUGV Concept

One of our early prototypes was built as a senior university project. It is a small unmanned ground vehicle inspired on U.S. army’s MarcBot.

MarcBot

MarcBot

The requirements were that it would be a low cost remote operated sensor platform that was able to overcome rough terrain and at the same time be small enough to carry.

diagram

Mechanical Diagram

More than “just” a camera on wheels it had also to send sensor data back to the operator in a reliable and secure way.

The vehicle should be equipped also with a navigation system such as GPS in order to know the current position and in case of lost communication do is best to come back “home”.

gui_hound

GUI

The development time given was 6 months so time was crucial and we had to keep it simple and using mostly off the shelf products.

So we come up with the following specifications:

  • Mechanical arm based on hobby servos
  • RC 4×4 crawler chassis
  • .net microframework compatible board
  • WiFi communications
  • Wireless camera
  • GPS
  • accelerometer
  • Gas sensor
  • Temperature sensor
  • Laptop base station