This is the application report from Texas Instruments about distance measurement using ultrasonic and MSP430 microcontroller. The report is provided in PDF file, you may download the application report at the end of this post.

This application report describes a distance-measuring system determined by ultrasonic sound using the MSP430F413 ultralow-power microcontroller. The system transmits a burst of ultrasonic sound waves towards the subject point and after that receives the corresponding echo.

This application is primarily based upon the reflection of sound waves. Sound waves are defined as longitudinal pressure waves in the medium in which they’re travelling. Subjects whose dimensions are greater than the wavelength of the impinging sound waves reflect them; the reflected waves are known as the echo. In the event the speed of sound in the medium is recognized and the time taken for the sound waves to travel the distance from the source towards the subject point and back to the source is measured, the distance from the source to the subject point will be computed accurately.

The devices applied to transmit and receive the ultrasonic sound waves within this application are 40-kHz ceramic ultrasonic transducers. The MSP430 drives the transmitter transducer using a 12-cycle burst of 40-kHz square-wave signal derived from the crystal oscillator, and therefore the receiver transducer receives the echo. The Timer_A in the MSP430 is configured to count the 40-kHz crystal frequency such that the time measurement resolution is 25 µs, that is more than enough for this application. The measurement time base is extremely stable because it is derived from a quartz-crystal oscillator. The echo received by the receiver transducer is boosted by an operational amplifier and the amplified output is fed towards the Comparator_A input. The Comparator_A senses the presence of the echo signal at its input and triggers a capture of Timer_A count value to capture compare register CCR1.

The capture is accomplished exactly at the immediate the echo arrives at the system. The captured count will be the measure of the time taken for the ultrasonic burst to travel the distance from the system to the subject point and back to the system. The distance in inches from the system towards the subject point is computed by the MSP430 implementing this measured time and displayed on a two-digit static LCD. Instantly right after updating the display screen, the MSP430 goes to LPM3 sleep mode to keep electrical power. The Basic Timer1 is programmed to interrupt the MSP430 every 205 milliseconds. The interrupt signal from the Basic Timer1 wakes up the MSP430 to repeat the measurement cycle and update the display screen.

Download the application report of distance measurement using ultrasonic and MSP430 microcontroller
» Download Link 1 (direct download from Texas Instruments)
» Download Link 1 (mirror download)

Arduino Tutorial: Use a Piezo Element to Detect Vibration. This tutorial shows you how to use a Piezo element to detect vibration, in this case, a knock on a door, table, or other solid surface.

A piezo is an electronic device that generates a voltage when it’s physically deformed by a vibration, sound wave, or mechanical strain. Similarly, when you put a voltage across a piezo, it vibrates and creates a tone. Piezos can be used both to play tones and to detect tones.

The sketch reads the piezos output using the analogRead() command, encoding the voltage range from 0 to 5 volts to a numerical range from 0 to 1023 in a process referred to as analog-to-digital conversion, or ADC.

If the sensors output is stronger than a certain threshold, your Arduino will send the string “Knock!” to the computer over the serial port.

Open the serial monitor to see this text.

Hardware Required

• Arduino Board
• (1) Piezo electric disc
• (1) Megohm resistor
• solid surface

Piezos are polarized, meaning that voltage passes through them (or out of them) in a specific direction. Connect the black wire (the lower voltage) to ground and the red wire (the higher voltage) to analog pin 0. Additionally, connect a 1-megohm resistor in parallel to the Piezo element to limit the voltage and current produced by the piezo and to protect the analog input.

It is possible to acquire piezo elements without a plastic housing. These will look like a metallic disc, and are easier to use as input sensors. PIezo sensors work best when firmly pressed against, taped, or glued their sensing surface.

Schematic Diagram:

A Piezo to attached to analog pin 0 with a 1-Megohm resistor

Code

In the code below, the incoming piezo data is compared to a threshold value set by the user. Try raising or lowering this value to increase your sensor’s overall sensitivity.

/* Knock Sensor
This sketch reads a piezo element to detect a knocking sound.
It reads an analog pin and compares the result to a set threshold.
If the result is greater than the threshold, it writes
“knock” to the serial port, and toggles the LED on pin 13.
The circuit:
* + connection of the piezo attached to analog in 0
* – connection of the piezo attached to ground
* 1-megohm resistor attached from analog in 0 to ground

http://www.arduino.cc/en/Tutorial/Knock

created 25 Mar 2007
by David Cuartielles
modified 4 Sep 2010
by Tom Igoe
This example code is in the public domain.
*/
// these constants won’t change:
const int ledPin = 13; // led connected to digital pin 13
const int knockSensor = A0; // the piezo is connected to analog pin 0
const int threshold = 100; // threshold value to decide when the detected sound is a knock
or not
// these variables will change:
int sensorReading = 0; // variable to store the value read from the sensor pin
int ledState = LOW; // variable used to store the last LED status, to toggle the light
void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as as OUTPUT
Serial.begin(9600); // use the serial port
}
void loop()
// read the sensor and store it in the variable sensorReading:
sensorReading = analogRead(knockSensor);
// if the sensor reading is greater than the threshold:
if (sensorReading >= threshold) {
// toggle the status of the ledPin:
ledState = !ledState;
// update the LED pin itself:
digitalWrite(ledPin, ledState);
// send the string “Knock!” back to the computer, followed by newline
Serial.println(“Knock!”);
}
delay(100); // delay to avoid overloading the serial port buffer
}

Download the Arduino Tutorial: Use a Piezo Element to Detect Vibration in PDF document:
» Download Link

NanoVM is a open-source implementation of the Java virtual machine. The NanoVM was initially developed to run on the Atmel AVR ATmega8 utilized in the Asuro Robot. It was ported to run on the C’t-Bot and the Nibo-robot and can easily be ported to other AVR-based systems.

The virtual machine uses almost 8 kilobytes of code memory (entire flash in case of ATmega8) and 256 bytes of RAM. Each and every user’s .class are processed by NanoVM’s Converter which transforms it into 1 bytecode file. Unique tools next send this file via serial line into device. For this operation is valuable NanoVM’s bootloader (alternatively you are able to use ISP programmer like: PonyProg) which store this content on-chip EEPROM.

NanoVM is not a full featured Java VM and it will never be.  It will constantly be limited to a tiny subset of the java language along with the regular java libraries plus a few application certain strategies. Furthermore, it really is not meant to replace C as the standard way of programming microcontrollers. It is much less flexible and has a lower performance than C or assembler programs.

The NanoVM is actually a method to present a limited but controllable programming interface to a microcontroller based device. With most of essentially the most hardware specific code being portion of the NanoVM itself, the user can focus on the application itself. If a user is given a device equipped using the NanoVM he is not needed to consider the hardware itself. Moreover, he does not need any target distinct compilers or the like. All he wants is a standard java compiler as well as the NanoVMTool which itself is written in java. Thus, the whole development chain works on any device that has a java compiler and can run java code. Using the hardware abstraction the NanoVM gives, the user doesn’t even have to care about the microcontroller type the target is based on. The very same java compiler as well as the identical NanoVMTool could be used with any NanoVM based program running on any sort of microontroller.

NanoWM documentation and download area: go to this page

Arduino UNO Board:

Arduino UNO Schematic:

Adruino UNO Schematic and PCB Design Download:
EAGLE files (rev2): arduino-uno-rev2-reference-design.zip
Schematic (rev2): arduino-uno-rev2-schematic.pdf
EAGLE files (original): arduino-uno-reference-design.zip
Schematic (original): arduino-uno-schematic.pdf

Arduino Tutorial:
» Go to this page

Ardunio Software Download:
» Go to this page

About Arduino UNO:
The Arduino UNO is really a microcontroller board based on the ATmega328. It has 14 digital input/output pins (of which 6 can be utilised as PWM outputs), 6 analog inputs, a 16 MHz crystal oscillator, a USB connection, a power jack, an ICSP header, along with a reset button. It contains every thing necessary to support the microcontroller; merely connect it to a computer having a USB cable or power it having a AC-to-DC adapter or battery to get began.

The UNO differs from all preceding boards in that it doesn’t use the FTDI USB-to-serial driver chip. Instead, it characteristics the Atmega8U2 programmed as a USB-to-serial converter.

“UNO” means one in Italian and is named to mark the upcoming release of Arduino 1.0. The Uno and version 1.0 is going to be the reference versions of Arduno, moving forward. The Uno is the latest in a series of USB Arduino boards, along with the reference model for the Arduino platform; for a comparison with previous versions, see the index of Arduino boards.

This is the project report for cellphone controlled mobile robot by Gaurav A.Khadasane, Tejas  Jethwa, Suraj,  Akshay Sonawale. You may use this document for your robot building project reference.

Detail module used for cellphone controlled mobile robot:

• DTMF Decoder: MT8870/CM8870
• Microcontroller: ATMEGA16
• Motor Driver: L293D
• Actuator: DC Motor 5-6V

Download Cellphone Controlled Mobile Robot Tutorial:
Download Link
Learn how to make mobile robot controlled
by a cellphone

• Simple 87LPC76x Microcontroller Tutorial
• Using the 87LPC76X microcontroller as an I²C bus master
• Using the 87LPC76X in multi-master I²2C applications
• Using the Philips 87LPC76x microcontroller as a remote control transmitter

About P87LPC760 Microcontroller:
The P87LPC760 is known as a 14-pin single chip microcontroller developed for applications demanding highintegration, minimal price solutions over a wide range of performance requirements. It’s based on an 80C51 processor architecture that executes instructions at twice the rate of standard 80C51 devices.

Download Philips 87LPC76x Microcontroller Tutorial and Application:
» Download Link

Microcontrollers are binary computers and so they operate on the basis of binary numbers. Binary numbers consist of only 1 and 0. Binary, nevertheless, is unnatural for humans to make use of. ssembly language is one step above binary. It’s therefore probably the most basic language for controlling computers because it represents binary directly and it’s simpler to know. Knowledge of assembly is not totally necessary to program the MSP430, but it is useful in optimizing routines to obtain the maximum overall performance (in terms of speed or memory). The C programming language is the main language utilized and will be followed all through this tutorial. In general, a compiler translates the C code into the binary code and we’ll not worry about how this is performed at first.

A microcontroller isn’t just a CPU. It usually incorporates a range of peripherals, apart from the memory and storage needed to operate. Simply put, it is a computer with some specialized functions. Of course, it cannot evaluate to a contemporary PC in elements like speed and processing capability for all but the high overall performance CPUs, however it is useful inside a wide selection of applications where bigger processors are not feasible. We start by discussing the most essential part of any pc: numbers and computation.

Download MSP430 Microcontroller Tutorial:
» Download Link

A particularly useful feature of the 8051 core is the inclusion of a boolean processing engine which allows bit-level boolean logic operations to be carried out directly and efficiently on internal registers and RAM. This feature helped cement the 8051′s popularity in industrial control applications. Another valued feature is that it has four separate register sets, which can be used to greatly reduce interrupt latency compared to the more common method of storing interrupt context on a stack.

8051 Microcontroller Tutorial Contents:

1. INTRODUCTION
2. TYPES OF MEMORY
3. SFRS
4. BASIC REGISTERS
5. ADDRESSING MODES
6. PROGRAM FLOW
7. INSTRUCTION SET, TIMING, AND LOW-LEVEL INFO
8. TIMERS
9. SERIAL COMMUNICATION
10. INTERRUPTS

Download 8051 Microcontroller Tutorial:
Download Link

Download the document of step by step Make a Robot tutorial:
Download Link

Go to online page of how to make a robot:
Visit the page

This tutorial explains all things related to the Atmel bootloader, including source code, how to install, programming, modification and uploading bootloader.

Tutorial document of Bootloader Tutorial for Atmel ATMega Microcontroller:
Download Link

Note: You must have the files required, go to this original page to download the files.