Synopsis of 8051 Microcontroller Project For Speed Measurement:
The speedo-Meter will measure the speed of motor attached to an industrial production machine is being developed in this microcontroller experimental project. The application of this speed measurement project is comprised of a variety of field like it can be used in the home appliance to the production industrial machinery. In this 8051 Microcontroller project we will be doing to design a digital meter used as measuring device to be develop for measuring instantaneous rotational speed of the encoded shaft. The basic technique behind the measurement of speed to use a suitable incremental optical encoding-based algorithm. The sensor used to detect the motion of the shaft attached with the motor will be based on a custom-built optical encoder consisting of transmitter and receiver. Accurate real-time calculations for speed measurement will be performed in an Atmel AT89C51 microcontroller. The output will be shown on LED seven segment display in the form of Rotation Per Second (RPMs). The system’s functionality and implementation details are presented in the sections below.
Subject Descriptors:
- Speedometers
- Optical Encoding
- Microcontrollers
- Optical Encoder
Implementation of Software and Hardware for the development of speed measuring device:
Hardware will be based on the Atmel AT89C51 microcontroller, and the software will be written in Keil C51 Compiler and Micro vision IDE.
Introduction of the Final Year Degree Project based on 8051 MCU:
Scope of Project:
In current configuration, the system can measure only the rotational speed up to a few thousand RPMs (revolutions per minute) with a fine degree of accuracy using the number of microseconds elapsed as the time interval.
Objectives
- To provide a higher degree of accuracy than its counterparts.
Significance
and Common Applications
Optical Encoding base rotary speedometers can commonly be used as feedback devices for motor controllers.
- They can also be utilized:
- To provide visual feedback.
- To increase compliance with traffic laws (e.g. on highways to check vehicle speeds).
- For conducting speed studies.
Salient features Of Speed Measurement System
Use
of Optical Encoding:
Besides
having low cost, fine accuracy and almost no parts to break, the Optical
Encoding scheme is quite simple, flexible and easy to implement. Moreover, as
the role of embedded digital systems and computers is getting more and more
significant with time in every technological domain, digital interfacing
capability has also become a mandatory feature in modern systems such as data
acquisition systems, control systems etc. Using Optical Encoding scheme is the
simplest way to incorporate such features into an application.
- Lower Cost – Only a transmitter (infrared LED) and a receiver (phototransistor) are needed for the basic operation. Also there’s no wear and tear of components which ensures that no re-calibrations etc. are required.
- Better accuracy – Due to its fast response, less number of components required, discrete signal operation (digital output), no maintenance or calibration requirements, the Optical Encoding makes it easier to provide very accurate result over a high range of operation.
- No Analog to Digital Conversion: Because of no analog to digital conversion involved, the system unsurprisingly has a number of significant plus points.
- Finer accuracy – Analog to digital converters provide unique output value up to a certain number limited by the umber of output bits, which is a hardware dependency. E.g. a 12 bit ADC can provide only 2^12 (=4096) different speed values. On the other hand, this Digital Speedometer system performs its calculations using 32-bit software arithmetic operations, based on the revolutions per number of microseconds elapsed, which is far more accurate than a system using ADC.
- Smaller time delays – The use of extra hardware components/stages introduces extra time delays, which is not desirable in any real-time application. Less hardware – Using lesser hardware than software is becoming a trend because it results in more flexibility, lesser design and debugging time hence more simplified overall design.
Custom-Built
Encoder Device:
Use
of 8051 based microcontroller device:
The
advantages in using a microcontroller are:
It allows one to move the whole logic and functionality in software, which is easily modifiable. A number of development and debugging tools are available for this series of devices. Hence, the overall development time is reduced and a more reliable product results in.
Architecture of the Speed-o-Meter
The speed measuring system based on microcontroller 8051 family has been divided in to following three subsystems:
- Input scanning subsystem
- Speed Measurement and calculation Subsystem
- Display Control Subsystem
Detailed explanation of each of the above sub-system follows in the next section. The high-level architecture of the system is represented in Figure No. 1, below.
 |
| Block Diagram Of Speed Measurement System |
Functionality and Implementation
This section explains the function of each of the subsystem in detail with its implementation and related issues step wise. The Atmel AT89C51 microcontroller (Intel 8051 derivative) is used in this project to implement the speed measurement and display control due to its low cost, simple architecture, re-programmability and good development tools available.
Input Subsystem (ENCODER):
Converts the mechanical rotary motion into digital electronic pulses, which are input to the speed measurement subsystem. The frequency of these pulses is directly proportional to rotational speed of the external source. The shaft encoder being sued in this project is a sensor associated with the detection of mechanical motion.
 |
| Encoder with optical sensor |
- A Metal Encoder Disk having a shaft for external mechanical interface and 4 equidistant holes along its circumference.
- An Infrared Emitting Diode [Device ID: F5E2]
- A Hermetic Silicon Phototransistor [Device ID: L14G3]
As the disk rotates, the light from the diode to the transistor is blocked and passed continuously. Due to this, the output of the circuit is low when the light passes through the disk hole and is high when the light is blocked. This produces digital pulses (0V Low, +5V High), which are fed directly into INT0 pin of the microcontroller. The advantage of using optical encoder becomes evident here, as there’s no voltage level conversion circuitry required.
Speed Measurement Subsystem:
It’s the software existing in the microcontroller, which calculates the instantaneous rotational speed in real-time. The calculated speed depends upon the frequency of pulses received at INT0 pin. The speed is calculated in following manner. On each high (+5V) to low (0V) transition detected at INT0 pin by the microcontroller, an event (interrupt) is triggered in the software. The speed is calculated at this event using [Speed = Distance/Time] formula. The distance is a fixed known parameter (1/4 rotation for 4 holes in the disk) and the time taken is provided by the internal timer of microcontroller in microseconds. The interrupts may occur at higher rates up to 40, 50 per second with speed values being calculated at the same rate. As these real-time values cannot be displayed at the same rate, some display control mechanism is necessary which updates the speed display at a rate suitable for human eye. There is a possibility that the wheel is moving very slowly and no event is triggered up to a particular time. A maximum interrupt waiting time has been adjusted after which the speed is taken as zero. Being in software, this parameter can be easily set to any practically desirable value (e.g. 1 sec to 30 sec).
Selection
of an optimal Speed Measurement Technique:
- Count the number of interrupts per unit time.
- Calculate the time elapsed between two successive interrupts.
The second approach is far more accurate than the other because of its resolution in microseconds.
Design Parameters:
|
MAX
RPM |
Maximum
No. Of Interrupts per second |
||
|
|
For 1 Hole |
4 holes |
8 holes |
|
20,000 |
333 |
1333 |
2667 |
|
10,000 |
167 |
667 |
1334 |
|
MIN
RPM |
Maximum
Wait Time (sec) |
||
|
|
For 1 Hole |
4 holes |
8 holes |
|
10 |
6 |
1.5 |
.75 |
|
1 |
60 |
15 |
7.5 |
Display
Control Subsystem:
Displays the instantaneous speed in RPMs (revolutions per minute). Updates the display at a rate suitable for human eye. Typically, a 1 sec update time is desirable and practical; i.e. a speed value is shown on the display for a minimum of 1 sec. As the speed is measured at the interrupt arrival rate, a number of speeds values may have been calculated within display update time. In this case, the most recent value is displayed as it best fulfils the definition of instantaneous speed.
Seven-segment display:
In current system configuration, a common anode seven-segment digit display is used for output. In order to use least possible hardware, there’s a slight trick involved here. The seven lines (N’s of diode) of each LED are connected to the 7 pins of port P1 of the microcontroller. As the 7 lines of each LED are common, each digit is updated one by one very frequently, which makes the display look stable. A separate transistor for each digit is used for switching.
Circuit Diagram of Speed Meter:
 |
| Circuit Diagram of Speed Meter using Microcontroller 8051 |
Work Breakdown Structure (WBS)
The work Breakdown structure of this project may involve the sub-tasks like, Formulation of Problem Statement Initial Study Objectives Definition Selection of the Optimal Solution Subsystems Design Circuit Design Selected Optical Technique Understanding the AT89C51 Architecture and Assembly Language Learning C51 Software Implementation Simulation and Testing Circuit Implementation and Testing Hardware and Software Integration Testing and Verification Implemented on Vero Board Bringing into a Demonstrable Form.
Summary:
The Digital Speedometer is an incremental optical encoder based real-time rotational speed measuring system having low cost, higher accuracy and practical operating ranges. Using this system, one can observe accurate instantaneous rotational speed of an object.
Limitations:
- Minimum measurable speed is limited by the maximum wait time. The wait time is in the software can be adjusted up to an adequate value.
- Maximum measurable speed is limited by the oscillator speed (in microcontroller) and the number of holes in the encoder disk.
Future Enhancements:
- Linear Speed, Velocity, Acceleration can be displayed on multiple display devices.
- Direction of rotation can be detected by using the quadrature technique with two diode/transistor pairs.
Reference Microcontroller Books consulted during the development of speed measuring system
Title: “The 8051 microcontroller”, 3rd edition
Author:
I. Scott. Mackenzie
Software coding:
The software of the microcontroller project based on MCU At89s51 is written in C-Language and compiled on Keil C51 compiler. The code listing is presented as below:
//The Software of Speed Meter // To include the library file related to Microcontroller //At89S51 #include <AT89X51.H> // Initialization and declaration of some variable to be // used in rest of program int digit1=0,digit2=0,digit3=0; // An array is taken to stort the codes // for the seven segment display int seven_segment[]={64, 124, 18,24,44,9,1,92,0,8}; #define MAX_WAIT_TIME_uSECS 2000000 #define DISPLAY_UPDATE_TIME_uSECS 2000000 #define MAX_TIMER_DELAY_uSECS 65536 #define TIMER_DELAY_uSECS 50000 #define TIMER_DELAY_VALUE (MAX_TIMER_DELAY_uSECS - TIMER_DELAY_uSECS) #define TIMER_INIT_VALUE TIMER_DELAY_VALUE #define MAX_OVERFLOWS (20) #define UPDATE_OVERFLOWS (21) void ext0isr(); void timer0isr(); void startTimer0(); void my_delay(int usec, int iterations); void mydivide(); // tmplong / elpsedTime // int maxwait_timerOverflowCount=0; int update_timerOverflowCount=0; int temp=0; int rpm=0; long elapsedTime=15000000+1; long tmpq; int quotient; void main() { EX0=1; //Enable external INT0 IT0=1; //External 0 edge triggered TMOD = 0x11; //Timer 0 16-bit mode ET0=1; //Enable Timer0 interrupts startTimer0(); EA=1; //Enable all interrupts while(1) { P3_3=0; P1=seven_segment[digit1]; P3_5=1; my_delay(100,1); P3_5=0; P1=seven_segment[digit2]; P3_4=1; my_delay(100,1); P3_4=0; P1=seven_segment[digit3]; P3_3=1; my_delay(100,1); } } void int0_ISR() interrupt 0 { TR0 = 0; //Stop Timer; to read value// // Read current elapsed microseconds // elapsedTime = TH0; elapsedTime <<= 8; elapsedTime |= TL0; elapsedTime -= TIMER_INIT_VALUE; // Add microsecond due to overflows occured// elapsedTime += maxwait_timerOverflowCount * TIMER_DELAY_uSECS; //Calculated factor. Dirty !!// elapsedTime += 25310; // Now we have the complete elapsed time // // mydivide();
//Divides the distance by elapsedTime. Only calculates the quotient// // rpm = quotient; // Calculate RPM ; Multiply numerator by 1E6 to make it seconds // //rpm = 60 * ROT_PER_INT * 1.0E6 / elapsedTime; // rpm = 15000000 / elapsedTime; // Reset time // maxwait_timerOverflowCount = 0; startTimer0(); } void timer0_ISR() interrupt 1 { TR0 = 0; ++maxwait_timerOverflowCount; ++update_timerOverflowCount; // If Maximum-wait-time has elapsed; Set RPM to zero // if(maxwait_timerOverflowCount == MAX_OVERFLOWS) { maxwait_timerOverflowCount=0; elapsedTime=15000000+1; } // If update time has arrived // if(update_timerOverflowCount == UPDATE_OVERFLOWS) { mydivide();
//Divides the distance by elapsedTime. Only calculates the quotient// temp = quotient; // RPM is in quotient // digit1 = temp%10; temp/=10; digit2 = temp%10; temp/=10; digit3=temp%10; update_timerOverflowCount = 0; } startTimer0(); } void startTimer0() { TR0 = 0; // Stop Timer // //Load high byte for timer delay into TH0 // temp = (TIMER_DELAY_VALUE & 0xFF00)>>8 ; TH0 = temp; //Load low byte for timer delay into TL0 // temp = (TIMER_DELAY_VALUE & 0x00FF); TL0 = temp; TR0 = 1; } void my_delay(int usec, int iterations) { int temp; usec=-usec; while(iterations>0) { temp=usec & 0xFF00; temp>>=8; TH1=temp; temp=usec & 0x00FF; TL1=temp; TR1=1; while(!TF1); TR1=0; TF1=0; iterations--; } } void mydivide() { quotient = 0; tmpq = 15000000; while(tmpq > elapsedTime) { tmpq -= elapsedTime; quotient++; } //tmpq has the remainder// }
