Embedded Systems

Parsing of GPS Data with PIC Microcontroller for Extraction and Processing of useful information

2011-02-17T19:38:00.004+05:00

GPS stands for Global Positioning System.This is a space-based global navigation satellite system.GPS provides reliable time and location information at all times and in all weather anywhere on or near the Earth. However for its normal operation a GPS receiver needs an unobstructed line of sight communication link to four or more GPS satellites. It is maintained by the US government and is freely accessible anywhere around the world with a GPS receiver.

Raw GPS data need to be parsed so that useful information like position (in terms of Latitude and Longitude Coordinates),time,speed and date etc. may be extracted from the GPS receiver that is interfaced with computer or micorocntroller.Of the multiple strings generated by GPS Engine, one string starting with "$GPRMC" is of prime importance.This string contains almost alll the necessary information that may be required for tracking of a moving object like vehicle or person etc.The second important string produced by GPS engine is the string starting with "$GPGSV" which contains the information regarding the number of satellites that are visible to the GPS receiver.The information regarding satellites is important for the reason that at least four satellites should be visible to the GPS receiver for accurate estimation of location and time.

(under construction...)

SPI-to-SPI communication between two AVR microcontrollers in Master-Slave Mode

2011-02-16T15:48:00.010+05:00

SPI stands for Serial Peripheral Interface.The Serial Peripheral Interface (SPI) allows high-speed synchronous data transfer between the ATmega32 and peripheral devices or between several AVR devices. The ATmega32 SPI includes the following features:

• Full-duplex, Three-wire Synchronous Data Transfer
• Master or Slave Operation
• LSB First or MSB First Data Transfer
• Seven Programmable Bit Rates
• End of Transmission Interrupt Flag
• Write Collision Flag Protection
• Wake-up from Idle Mode
• Double Speed (CK/2) Master SPI Mode

AVR micro-controller ATmega32 is equipped with a built-in hardware SPI port.For detailed description of SPI port of ATmega32 you may consult the data sheet of ATmega32 available at the website of ATmel .The interconnection between Master and Slave CPUs with SPI is shown in the Figure 1 below.

Figure 1 : Master-Slave Interconnection between two CPUs

In this Proteus VSM based simulation i have demonstrated how two AVR micro-controller (ATmega32) may communicate with each other through their SPI ports in Master-Slave Mode.One micro-controller serves as master while the other one which is receiving data from master controller is serving as Slave.Though this code is not doing much it is just a demonstration of how you can make two AVR micro-controllers communicate withe each other through their SPI ports in Master-Slave Mode.In this simulation the master micro-controller is sending a character continuously to the slave micro-controller through SPI port,while the slave micro-controller is displaying that character, received from the master micro-controller through its SPI port, to the virtual terminal available in Proteus VSM through it serial port.The schematic diagram of this simulation is shown in the Figure 2.

Figure 2 : Circuit Schematic of simulation

A screen shot of the test run of this simulation is shown in Figure 3 below.

                           Figure 3 : Screen Shot of simulation

C Code for Master Controller:

//ICC-AVR application builder : 4/16/2009 6:56:37 PM
// Target : M32
// Crystal: 11.059Mhz

#include <iom32v.h>
#include <macros.h>

#define cs 0x10

unsigned int timer0_counter=0,j=0;

unsigned char testMsg[]="Hello this is test message for SPI-to-SPI\
                         communication in master-slave mode\n\r";

void port_init(void)
{
     PORTA = 0x00;
     DDRA = 0x03;
     PORTB = 0x00;
     DDRB = 0x00;
     PORTC = 0x00;
     DDRC = 0x00;
     PORTD = 0x00;
     DDRD = 0x00;
}

//TIMER0 initialize - prescale:1024
// WGM: Normal
// desired value: 100Hz
// actual value: 100.933Hz (0.9%)
void timer0_init(void)
{
     TCCR0 = 0x00; //stop
     TCNT0 = 0x95; //set count
     OCR0 = 0x6B; //set compare
     TCCR0 = 0x05; //start timer
}

//#pragma interrupt_handler timer0_ovf_isr:iv_TIM0_OVF
#pragma interrupt_handler timer0_ovf_isr:12
void timer0_ovf_isr(void)
{
     TCNT0 = 0x95; //reload counter value

    timer0_counter++;
    if(timer0_counter==2)
    {
        PORTA^=0x03;
        timer0_counter=0;

    }
}

//SPI initialize
// clock rate: 2764749hz
void spi_init(void)
{
     SPCR = 0x50; //setup SPI - SPE,MSTR,
     SPSR = 0x00; //setup SPI

    //PORTB=(1<<PORTB4)|(1<<PORTB5)|(1<<PORTB7);
    PORTB=(1<<PB4)|(1<<PB5)|(1<<PB7);
    DDRB=(1<<DDB4)|(1<<DDB5)|(1<<DDB7);
}

void SPI_MasterTransmit(char cData)
{
     /* Start transmission */
    SPDR = cData;
    /* Wait for transmission complete */
    while(!(SPSR & (1<<SPIF)))
    ;
}

//UART0 initialize
// desired baud rate: 57600
// actual: baud rate:57599 (0.0%)
void uart0_init(void)
{
     UCSRB = 0x00; //disable while setting baud rate
     UCSRA = 0x00;
     UCSRC = BIT(URSEL) | 0x06;
     UBRRL = 0x0B; //set baud rate lo
     UBRRH = 0x00; //set baud rate hi
     UCSRB = 0x18;
}

//call this routine to initialize all peripherals
void init_devices(void)
{
     //stop errant interrupts until set up
     CLI(); //disable all interrupts
     port_init();
     timer0_init();
     spi_init();
     uart0_init();

     MCUCR = 0x00;
     GICR = 0x00;
     TIMSK = 0x01; //timer interrupt sources
     SEI(); //re-enable interrupts
     //all peripherals are now initialized
}

//
void main(void)
{
     init_devices();
     //insert your functional code here...
    while(1)
    {
           PORTB &=~cs;
           SPI_MasterTransmit( 'a' );
           PORTB |=cs;

    }
}
C Code for Slave Controller :

//ICC-AVR application builder : 3/31/2009 1:09:34 PM
// Target : M32
// Crystal: 11.059Mhz

#include <iom32v.h>
#include <macros.h>

unsigned char spiData = 0;

unsigned int k = 0;

void port_init(void)
{
     PORTA = 0x00;
     DDRA = 0x00;
     PORTB = 0x00;
     DDRB = 0x00;
     PORTC = 0x00;
     DDRC = 0x03;
     PORTD = 0x00;
     DDRD = 0x00;
}

//TIMER0 initialize - prescale:1024
// WGM: Normal
// desired value: 100Hz
// actual value: 100.933Hz (0.9%)
void timer0_init(void)
{
     TCCR0 = 0x00; //stop
     TCNT0 = 0x95; //set count
     OCR0 = 0x6B; //set compare
     TCCR0 = 0x05; //start timer
}

#pragma interrupt_handler timer0_ovf_isr:12
void timer0_ovf_isr(void)
{
     TCNT0 = 0x95; //reload counter value
}

//SPI initialize
// clock rate: 2764749hz
void SPI_SlaveInit(void)
{
    PORTB=(1<<PB6);
     SPCR = 0x40; //setup SPI
     SPSR = 0x00; //setup SPI
}

char SPI_SlaveReceive(void)
{
     /* Wait for reception complete */
    while(!(SPSR & (1<<SPIF)))
    ;
    /* Return data register */
    return SPDR;
}

//UART0 initialize
// desired baud rate: 57600
// actual: baud rate:57599 (0.0%)
void uart0_init(void)
{
     UCSRB = 0x00; //disable while setting baud rate
     UCSRA = 0x00;
     UCSRC = BIT(URSEL) | 0x06;
     UBRRL = 0x0B; //set baud rate lo
     UBRRH = 0x00; //set baud rate hi
     UCSRB = 0x18;
}

//call this routine to initialize all peripherals
void init_devices(void)
{
     //stop errant interrupts until set up
     CLI(); //disable all interrupts
     port_init();
     timer0_init();
     SPI_SlaveInit();
     uart0_init();

     MCUCR = 0x00;
     GICR = 0x00;
     TIMSK = 0x01; //timer interrupt sources
     SEI(); //re-enable interrupts
     //all peripherals are now initialized
}

void USART_Transmit( unsigned char data )
{
     /* Wait for empty transmit buffer */
    while ( !( UCSRA & (1<<UDRE)) )
    ;
    /* Put data into buffer, sends the data */
    UDR = data;
}

//
void main(void)
{
     init_devices();
     //insert your functional code here...
     while(1)
    {
            spiData=SPI_SlaveReceive();


           if( (k%32)==0 )
           {
                USART_Transmit( '\r' );USART_Transmit( '\n' );
           }
           k++;

           USART_Transmit( spiData );

    }
}

Software UART for ATmega32 AVR microcontroller

2011-02-15T20:29:00.009+05:00

Sometimes,while developing a micro-controller based embedded system,you may find your micro-controller short of built-in hardware peripheral resources like serial port,SPI port and I2C interface etc.,in such a case,if you cannot change the micro-controller that you are interested in utilizing in design of your embedded system,you may put your software development skills to work for you to solve this issue.You may develop code for adding additional dedicated peripheral ports like serial port to your existing micro-controller, without changing the micro-controller,to meet your design requirements,by utilizing general purpose IO ports.In such a case you can make a general purpose IO port behave like a dedicated hardware peripheral port like serial port or SPI port etc.,.
In this Proteus VSM simulation project,i have given a code for Software UART for ATmega32 AVR micro-controller.I have utilized general purpose IO pins 0 and 1 of PORTB of ATmega32 micro-controller.The screen shot of the test run of this simulation in Proteus VSM is shown in Figure 1 below:

Figure 1 : Soft UART simulation and Schematic

For sharp timing control,the code for Soft UART has been written in Assembly Language for ATmega32.The C code simply prints a test string to the virtual terminal of Proteus VSM.Whenever any key is pressed, the C code prints the test string again on the virtual terminal.The C and Assembly Language Codes are given below.

C Code :

//ICC-AVR application builder : 5/28/2009 3:28:30 PM
// Target : M32
// Crystal: 7.3728Mhz

#include <iom32v.h>
#include <macros.h>

//function prototypes for soft_uart.s
//one byte return value in R16 !!!
extern unsigned char Get_Character(void);
//one byte argument in R16 !!!
extern Put_Charcter(register unsigned char key);
//initialise TxD,RxD port pins
extern void init_soft_uart(void);

void port_init(void)
{
     PORTA = 0xFF;
     DDRA = 0x00;
     PORTB = 0xFF;
     DDRB = 0x00;
     PORTC = 0xFF;
     DDRC = 0x00;
     PORTD = 0xFF;
     DDRD = 0x00;
}

//call this routine to initialize all peripherals
void init_devices(void)
{
     //stop errant interrupts until set up
     CLI(); //disable all interrupts
     port_init();

     MCUCR = 0x00;
     GICR = 0x00;
     TIMSK = 0x00; //timer interrupt sources
     SEI(); //re-enable interrupts
     //all peripherals are now initialized
}

//
void main(void)
{
     unsigned char s;
     unsigned int j=0;

    unsigned char test_Message[] = "This is test message from Soft\
                                                        UART of ATmega32!!!\r\n";
     //default
     init_devices();
     //insert your functional code here...
     //do custom settings in sUART.s !!!
     init_soft_uart();

    while(1)
       {
                for(j=0;j<sizeof(test_Message);j++)
                Put_Charcter(test_Message[j]);
                s = Get_Character();
                // press enter or any button to print more messages

        }//end while
}

Assembly Language Code:

;*** Software UART for ATmega32 AVR Microntroller ***
;*** Assembly Code for Soft UART                  ***
;*** Developed in Imagecraft Compiler for AVR     ***

.area text
;....................................................................................
;include correct file here ................................................
.include "aiom32.s" ;see path´s,same directory as *.h !!!
;....................................................................................

;volatile registers (not needed to restore)
.define bitcnt    R24
.define Temp_Variable R25
.define TxD_Byte R26
.define RxD_Byte R27

; ****** Customizable settings BEGIN ******
;change here if wanted/required !!!

.define out_port PORTB ; PORTB is used for TxD here
.define dir       DDRB   ; DDRB is used here
.define in_port   PINB ; PINB is used for RxD here
TxD = 0                     ; Px0 pin is used for sending
RxD = 1                      ; Px0 pin is used for receiving
sb = 1                          ; 1 stop bit
Osc_Frequency = 7372800 ; Crystal frequency
Baud_Rate = 57600       ; Serial bitrate in bps : 0.5% error

; ****** Customizable settings END ******

; The b value corresponds to the table on last page
; of Application Note AVR 305: Software UART
b = (((Osc_Frequency/Baud_Rate)-22)/6)

;function to init PORTx and DDRx for sending and receiving
_init_soft_uart::
;for sending
sbi out_port,TxD ;TxD is high   - set bit in I/O register
sbi dir,TxD      ;TxD is output - clear bit in I/O register
;for receiving
sbi out_port,RxD ;RxD is pull up
cbi dir,RxD      ;RxD is input
ret

;function to send a byte :first argument is in R16
_Put_Charcter::    mov   TxD_Byte,R16   ;given char to TxD_Byte
                            ldi   bitcnt,9+sb            ;1+8+sb (sb is # of stop bits)
                            com   TxD_Byte       ;inverte everything
                            sec                    ;start bit

Put_Charcter0:   brcc   Put_Charcter1   ;if carry set
            cbi          out_port,TxD;send a '0'
            rjmp        Put_Charcter2   ;else

Put_Charcter1:   sbi   out_port,TxD   ;send a '1'
            nop

Put_Charcter2:   rcall UART_Delay   ;one bit delay
            rcall UART_Delay

            lsr TxD_Byte              ;get next bit
            dec   bitcnt                ;if not all bit sent
            brne   Put_Charcter0 ;send next
           ;else
            ret                                ;done return

;function for delay
UART_Delay:        ldi   Temp_Variable,b
UART_Delay01:   dec   Temp_Variable
                brne   UART_Delay01
                ret
;

;function to receive a byte and return in R16
_Get_Character::
               ldi    bitcnt,9   ;8 data bit + 1 stop bit

Get_Character1:   sbic    in_port,RxD   ;wait for start bit
                rjmp    Get_Character1
                rcall UART_Delay   ;0.5 bit delay

Get_Character2:   rcall UART_Delay   ;1 bit delay
                rcall UART_Delay

                clc                    ;clear carry
                sbic    in_port,RxD   ;if RX pin high
               sec                    ;set carry flag in SREG

               dec    bitcnt       ;if bit is stop bit
               breq    Get_Character3   ;return
                ;else
               ror    RxD_Byte   ;shift bit into RxD_Byte
               rjmp    Get_Character2   ;go get next

Get_Character3:   mov R16,RxD_Byte    ;move RxD_Byte to R16
               ret                    ;return from function call

Difference between PDU mode and Text mode for SMS

2011-02-12T23:30:00.032+05:00

1. Introduction

Some applications need low cost,long range and reliable wireless connectivity rather than high data rate wireless links.The GSM network employed by mobile phones is particularly suitable for such applications.Mobile phone or GSM modem may be utilized for such applications where you need to remotely operate a switch or relay in your applications like turning on or turning off a fan,heater, or electric motor remotely by sending SMS to a mobile phone or GSM modem interfaced with a micro-controller or computer in your control applications.

The interface between a GSM modem or a cell phone and a host controller (PC or microcontoller) is a textual protocol call Hayes AT Commands.The GSM Modem or Cell phone can be made to perform different operations like text messaging,deleting messages and dialing etc.,through AT commands issued by host controller.
There are two modes of operation for sending and receiving SMS through a GSM modem or a mobile phone when interfaced with a microcontroller or a PC:

1. Text Mode
2. PDU (Protocol Description Unit) Mode

By default most modems and mobile phones support PDU mode for sending and receiving SMS.Text mode in which any information or message may be read as a plain text is not supported by all modems and mobile phones.However,some modems and mobile phones do support text mode as well as PDU mode for sending and receiving SMS.Text mode is actually encoding of bit stream represented by PDU mode.
You can select between PDU mode and text mode using AT commands.The following AT command returns the current status of the mode of the GSM modem:

AT+CMGF? <Enter>

To set the text mode the following AT command is used:

AT+CMGF = 1 <Enter>

To set the PDU mode the following AT command is used:

AT+CMGF = 0 <Enter>

2. PDU Mode

PDU mode offers support to send messages as either 8-bit per character or 7-bit per character.The SMS message is specified by the ETSI Organization (documents GSM 03.40 and GSM 03.38).According to these documents the maximum length of an SMS message could be up to 160 characters,where each character according to GSM 03.38 is 7-bits in size.Mobile phones and GSM modems usually do not treat eigit-bit messages (up to 140 characters) as text messages.Eight-bit messages are used for data like ring tones,images and Wap settings.Sixteen-bit messages (upto 70 characters) are viewable by most mobile phones .Sixteen-bit messages are used for Unicode (UCS32) text messages.

You can apply encryption,encoding and data compression to messages in PDU mode.There are several encoding options available when reading a SMS message in PDU mode.The most commonly available options in this regard are : "GSM", "PCDN", "PCCP437", "IRA" and "8859-1".While reading an SMS message in computer application,any of these options may be selected by the At-command "AT+CSCS". If the SMS message is read by the cell phone, the phone itself will choose the appropriate encoding.A computer Application developed for reading incoming SMS messages can be configured to employ either text mode or PDU mode. Text mode deprives the user of flexibility to choose from several available encoding options.In text mode there is a limited set of options for encoding available for the application to choose from. In some applications,this is not acceptable,in such a case PDU mode is a good choice where any encoding option can be implemented.
There are three special data types that are supported by PDU mode:

      1. Octet: Group of 8-bits in hexa-decimal encoding (0x00 - 0xFF),
           like D9.
       2. Semi-Octet: Group of 8-bits in decimal encoding (0 - 153),like 12.
       3. Septet : Group 7-bits in integer encoding (0 - 127) like 120.

By default,7-bits are used by GSM alphabets to represent characters.The message "hello", when represented by 7-bits per character,comprises five characters called septets.For SMS transfer a septet string need to be encoded to octet stream for transfer through SMS.

Table 1 : Compression septet string into octet stream

The first septet (h) is converted into an octet by adding the rightmost bit of the second septet (shown in bold).This bit from taken from second septet is inserted at the left of fist septet, this gives: 1 + 1101000 = 11101000 ("E8"). The second septet then gets two bits (shown in bold) from the third septet, so the second character (e) become an octet: 00 + 110010 = 00110010 ("32"). The five first bits of the last char (o) is padded with zeros (shown in bold).
Messages encoded this way can then be added as payload to “AT+CMGS” command as has been shown in one of my previous posts.
The received message can be read from the memory location ,where it resides ,using the AT command : “AT+CMGR”.This command will return an octet stream from the modem.For extracting useful information from the octet stream read from the modem memory a decompression method is required.An example decoding the octet stream for "hello" back to septets is shown in Table 2.

Table 2 : Decompressing octet stream into septets
For getting septets back from octet stream,the leading 1 (shown in bold) from first octet is removed and appended at the back of second septet,meanwhile two leading zeros from second septet are discarded.The fifth octet (06) loses its leading zero padding and leading 1111 received from fourth octet is appended at its end.

For further details regarding PDU mode you can consult application note titled "Interfacing GSM Modems" available at the website of ATmel .

3. Text Mode for SMS

Text mode for sending SMS is simpler and easier to implement as compared with PDU mode.Unlike PDU mode,text mode is not supported by all mobile phones.In text mode you do not need to do bit level manipulations for sending SMS message.

(under construction...)

Sending SMS in PDU Mode though GSM modem connected with PC Serial Port and operated with PIC Microcontroller model in Proteus VSM

2011-02-11T19:09:00.008+05:00

GSM modem may be operated with 'Hayes Programming Language' using 'AT Commands'.AT commands are used for operating GSM modem either when it is physically connected with serial port of PC or with serial port of micro-controller.There are two modes in which a modem can be used to send SMS to any mobile number i.e., Text Mode and PDU Mode.Sending SMS in Text Mode is easier than sending SMS in PDU mode.PDU mode for SMS is supported by almost all mobile devices but text mode for SMS is not supported by all devices.

In this post,it has been shown how a GSM modem,physically connected with serial port of PC, may be interfaced with serial port of Proteus VSM model of PIC micro-controller through COMPIM simulation module for serial port in Proteus VSM.

Figure 1 : Schematic Diagram for GSM Modem Interface in Proteus VSM

The C code for PIC micro-controller PIC18F4520 has been developed in mikroC for PIC compiler.This simulation sends the following text message in PDU mode through GSM modem to a predefined mobile number: "Hello! This is test message from Proteus VSM in PDU mode".

The GSM modem used in this simulation is WismoQuik2403A,which is interfaced with PC through serial port.This modem is shown in Figure2.

Figure 2 WismoQuik2403A GSM Modem

The C code is given below :

C-Code for PIC18F4520 :

/****************************************************************************************

* Project name:
     SMS in PDU mode
* Copyright:
     (c) M.Yasir
* Description:
     This code demonstrates how to to send SMS through PDU mode with GSM modem
* Test configuration:
     MCU:             P18F4520
     Oscillator:      HS, 8.0000 MHz
     Ext. Modules:    -
     SW:              mikroC v8.0
* NOTES:
     1-
****************************************************************************************/

#define Size 50
unsigned char TextMsg[]= "Hello! This is test message from Proteus VSM in PDU mode" ;

unsigned char Command_CMGF[]="AT+CMGF=0\r"; // AT+CMGF for selecting PDU mode
unsigned char CtrlZ=0x1A; // CTRL+Z for sedning SMS after the message has been entered
unsigned char Command_CMGS[]="AT+CMGS =";

unsigned char Command_AT[]="AT\r";

unsigned int SeptetCount = 0;

unsigned char TextMessage01[20][8];

unsigned char PDU_SMS_Message01[] ="0011000C912903508201640000AA";
// 13 (hex) octets exclding 1st octet

unsigned int i=0,j=0,k=0,m=0,q=0;// indexes

unsigned int Size_Of_PDU_SMS = 0;
unsigned char Size_Of_PDU_SMS_MSD = 0,
                     Size_Of_PDU_SMS_LSD = 0;

unsigned char a1[Size];
unsigned char mask[Size];
unsigned char aa1[Size];
unsigned char bb[Size];
unsigned char PDU_String[Size];
unsigned char msg01[Size];

unsigned char TempBuffer[8],TempBuffer01[8];

unsigned char temp=0,temp01=0;

//*** Function Prottypes ****
unsigned char Dec2ASCII(unsigned int );
unsigned int Char2ASCIIinDec(unsigned char);
unsigned int Char2ASCIIinHex(unsigned char);

unsigned char Hex2ASCII(unsigned char);

void ShiftRight( unsigned char *, unsigned int );
void GenerateMasks( unsigned int );
void BitsExtraction( unsigned int );
void Generate_PDU_Message_String( unsigned int );

void Generate_PDU_Octets( unsigned char *,unsigned int );

void Get_SeptetCount( unsigned int );

//unsigned char Dec2Hex( unsigned char );

unsigned int MessageLength = 0;
unsigned char EightChSet = 0,ExtraCh = 0;

//******** Function for converting decimal to ascii value ***********

Dec2ASCII( unsigned int Dec2Value )
{
           unsigned char ASCII_Value = 0;

           ASCII_Value = Dec2Value + 48;

           return( ASCII_Value );
}
//================================================

Char2ASCIIinDec( unsigned char Ch )
{
                 unsigned int ASCIIinDec = 0;

                 if( Ch >= ' ' && Ch <= '~')
                 {   // printable characters start from space character with
                     // ASCII value in decimal = 32, and end at tida character
                     // '~' with ASCII value in decimal = 126
                     if( Ch == ' ' )
                         ASCIIinDec = 32;
                     if ( Ch > ' ' )
                     ASCIIinDec = ( Ch - ' ') + 32;

                 }

                 return ( ASCIIinDec );
}

//================================================

Char2ASCIIinHex( unsigned char Ch )
{
                 unsigned int ASCIIinHex = 0;

                 if( Ch >= ' ' && Ch <= '~')
                 {   // printable characters start from space character with
                     // ASCII value in decimal = 32, and end at tida character
                     // '~' with ASCII value in decimal = 126
                     if( Ch == ' ' )
                         ASCIIinHex = 0x20;
                     if ( Ch > ' ' )
                     ASCIIinHex = ( Ch - ' ') + 0x20;

                 }

                 return ( ASCIIinHex );
}

//================================================

Hex2ASCII( unsigned char HexValue )
{
           unsigned char ASCII_Value;

           if( ( HexValue >= 0x00 )&& ( HexValue <= 0x09 ) )
                 ASCII_Value = ( HexValue - 0x00 ) + 0x30;
           else if( ( HexValue >= 0x0A )&& ( HexValue <= 0x0F ) )
                      ASCII_Value = ( HexValue-0x0A ) + 0x41;

           return( ASCII_Value );

}
//================================================
/*
    Dec2Hex( unsigned char DecValue )
    {
             unsigned char HexValue = 0;

             if( ( DecValue >= 0 )&& ( DecValue <= 9 ) )
                 HexValue = DecValue;
             else if( ( DecValue > 9 )&& ( DecValue <= 15 ) )
                  {
                      //HexValue = ( HexValue-0x0A ) + 0x41;
                      switch( DecValue )
                      {
                              case 10:
                                   HexValue = 'A';
                              break;
                              case 11:
                                   HexValue = 'B';
                              break;
                              case 12:
                                   HexValue = 'C';
                              break;
                              case 13:
                                   HexValue = 'D';
                              break;
                              case 14:
                                   HexValue = 'E';
                              break;
                              case 15:
                                   HexValue = 'F';
                              break;
                              default:
                                   HexValue = 0 ;


                      }
                  }
             return( HexValue );
    }

*/
//================================================

ShiftRight( unsigned char *Data , unsigned int DataLength )
{
             for( i=0; i < DataLength; i++ )
             {
                  temp = msg01[i];
                  a1[i] = temp >>i;
             }

}

//================================================
// generate mask

GenerateMasks( unsigned int DataLength )
{
                for( i = 0; i < DataLength; i++ )
                {
                     if( i == 0 )
                         mask[i] = 0x01;
                     else
                     {
                         mask[i] = ( 2*mask[i-1] ) + 0x01;
                      }
                 }

}

//================================================
// bit extraction

BitsExtraction( unsigned int DataLength )
{
                for( i=0; i<DataLength; i++ )
                {
                     if( i == 0 )
                     {
                         aa1[i] = msg01[i];
                         bb[i] =   aa1[i];
                     }
                     else
                     {
                         aa1[i] = msg01[i] & mask[i-1];
                         bb[i] = aa1[i];
                         aa1[i] = msg01[i] << (8-i);
                     }
                 }
}

//================================================
// generate PDU string

Generate_PDU_Message_String( unsigned int DataLength )
{
        for( i=0; i<DataLength; i++ )
        {
             if( i != ( sizeof(TextMsg)-1 ) )
                 PDU_String[i] = aa1[i+1] | a1[i];

             if( i == ( sizeof(TextMsg)-1 ) )
                 PDU_String[i] = a1[ sizeof(TextMsg)-1 ];
         }

}

//================================================
// Generate PDU Octets

Generate_PDU_Octets( unsigned char *Data,unsigned int DataLength )
{
     // get ascii (in Hex) values for the characters
     for( i=0; i<DataLength; i++ )
     {
         //msg01[i] = Char2ASCIIinHex( TextMsg[i] );
         msg01[i] = Char2ASCIIinHex( *(Data+i) );
         //USART_Write( msg01[i] ); // send data via USART
     }

     //================================================
     // shift right
     ShiftRight( msg01 , DataLength );
     // shit bits of message character to right

     // generate mask
     GenerateMasks( DataLength );

     // bit extraction
     BitsExtraction( DataLength );

     // generate PDU string
     Generate_PDU_Message_String( DataLength );

     temp=0;

     for( j=0; j<DataLength; j++ )
     {
          if( PDU_String[j] != 0x00 )
          {
              temp =( PDU_String[j]& 0xF0 );
              temp=(temp>>4);

              USART_Write( Hex2ASCII( temp ) );

              temp=(PDU_String[j]& 0x0F);

              USART_Write( Hex2ASCII( temp ) );
          }

     }

}

//==================================================
// For septet count
void Get_SeptetCount( unsigned int DataLength )
{
        unsigned char TempVariable = 0;
        //==========================
        // problem is occurring here,here you have to convert
        //decimal value to hex value
        // e.g. 25d = 0x19
        // proper conversion should be done
        if( (DataLength > 9)&&(DataLength!=140) )
        {
            TempVariable = DataLength / 16;

            USART_Write( Dec2ASCII( TempVariable ) );
            // send data via USART

            TempVariable = DataLength % 16;

            if( ( TempVariable >= 0 )||( TempVariable <= 9 ) )
                 USART_Write( Dec2ASCII( TempVariable ) );
                 // send data via USART;

            if( TempVariable == 10 )
            {
                    TempVariable = 'A';
                    USART_Write( Char2ASCIIinHex( TempVariable ) );
            }
            if( TempVariable == 11 )
            {
                    TempVariable = 'B';
                    USART_Write( Char2ASCIIinHex( TempVariable ) );
            }
            if( TempVariable == 12 )
            {
                    TempVariable = 'C';
                    USART_Write( Char2ASCIIinHex( TempVariable ) );
            }
            if( TempVariable == 13 )
            {
                    TempVariable = 'D';
                    USART_Write( Char2ASCIIinHex( TempVariable ) );
            }
            if( TempVariable == 14 )
            {
                    TempVariable = 'E';
                    USART_Write( Char2ASCIIinHex( TempVariable ) );
            }
            if( TempVariable == 15 )
            {
                    TempVariable = 'F';
                    USART_Write( Char2ASCIIinHex( TempVariable ) );
            }

            //TempVariable = Dec2Hex( TempVariable );
            //Char2ASCIIinHex( unsigned char Ch )
            //USART_Write( Dec2ASCII( TempVariable ) );
            // send data via USART
            //USART_Write( Char2ASCIIinHex( TempVariable ) );
            // send data via USART
            }
            if( DataLength <= 9 )
            {

                    USART_Write('0'); // send data via USART
                    USART_Write( Dec2ASCII( DataLength ) );
                    // send data via USART

            }

            if( DataLength == 140 )
            {

                    TempVariable = '8';
                    USART_Write( Char2ASCIIinHex( TempVariable ) );
                    TempVariable = 'C';
                    USART_Write( Char2ASCIIinHex( TempVariable ) );

            }

}

//=================================================
void main()
{ // start of main Function

     PORTD = 0;
     TRISD = 0;           // PORTD is output

     USART_init( 57600 );
     // initialize USART module - ( 8 bit, 57600 baud rate, no parity bit... )

     // message01 sent as ASCII values in Hex
     for(j=0;j<sizeof(TextMsg);j++)
     USART_Write( Char2ASCIIinHex( TextMsg[j] ) );

     USART_Write( '\r' ); // send data via USART
     USART_Write( '\n' ); // send data via USART

     USART_Write( '\r' ); // send data via USART
     USART_Write( '\n' ); // send data via USART
     //================================================


     for(i=0;i<sizeof(Command_AT);i++)
     USART_Write(Command_AT[i]); // send data via USART
     //=================================================

     Delay_ms(100); // 100 msecond delay

    //==================================================
     for(i=0;i<sizeof(Command_CMGF);i++)
     USART_Write(Command_CMGF[i]);    // send data via USART

     Delay_ms(100); // 100 msecond delay

     Delay_ms(100); // 100 msecond delay
     //==================================================
     i=0;
     while( Command_CMGS[i] != '\0' )
     {
            USART_Write(Command_CMGS[i]); // send data via USART
            i++;

     }
     i=0;

     MessageLength = sizeof(TextMsg)-1;    // size of text message = septet count

     if( MessageLength >= 8 )
     {
         //if( MessageLength == 8 )

         EightChSet = MessageLength/8;
         // no of 8 charater sets in text message
         ExtraCh = MessageLength - (EightChSet*8);
         // no of charaters more after 8 chataer sets
         // over 8 charaters one hex valeu at the end
         // equals 0x00 and may be discarded
     }
     else if( MessageLength < 8 )
     {
         EightChSet =0; // no of 8 charater sets in text message
         ExtraCh = 0;     // no of charaters more after 8 chataer sets
                                  // over 8 charaters one hex valeu at the end
                                  // equals 0x00 and may be discarded
     }

     //===================================================
     // PDU message size for sending message to modem is 19
     // excluding the starting zeros '00'

     Size_Of_PDU_SMS = sizeof( PDU_SMS_Message01 ) - 1;
     // 13 octets fixed in our case

     if( MessageLength < 8 )
     {
         Size_Of_PDU_SMS = ( (Size_Of_PDU_SMS/2) - 1 )
                                             + MessageLength + 1;
         // add on for length octet

     }
     if( MessageLength == 8 )
         Size_Of_PDU_SMS = ( (Size_Of_PDU_SMS/2) - 1 )
                                             + MessageLength;
     if( MessageLength > 8 )
         Size_Of_PDU_SMS = ( (Size_Of_PDU_SMS/2) - 1 )
                                             + MessageLength + 1 - EightChSet;

     if( Size_Of_PDU_SMS <= 9 )
     USART_Write( Dec2ASCII( Size_Of_PDU_SMS ) );

     if( ( Size_Of_PDU_SMS > 9 )&& ( Size_Of_PDU_SMS <100 ) )
     {
         Size_Of_PDU_SMS_MSD = Size_Of_PDU_SMS/10;
         Size_Of_PDU_SMS_LSD = Size_Of_PDU_SMS%10;

         USART_Write( Dec2ASCII( Size_Of_PDU_SMS_MSD ) );
         USART_Write( Dec2ASCII( Size_Of_PDU_SMS_LSD ) );

     }

     if( ( Size_Of_PDU_SMS >=100 )&& ( Size_Of_PDU_SMS <=140 ) )
     {

         if( Size_Of_PDU_SMS ==100 )
         {
             USART_Write( '1' );
             USART_Write( '0' );
             USART_Write( '0' );
         }
         if( (Size_Of_PDU_SMS !=100) && (Size_Of_PDU_SMS !=140) )
         {
             temp = Size_Of_PDU_SMS/100;
             USART_Write( Dec2ASCII(temp) );

             temp = Size_Of_PDU_SMS/10;
             temp = temp%10;
             USART_Write( Dec2ASCII(temp) );

             temp = Size_Of_PDU_SMS%100;
             temp = temp%10;
             USART_Write( Dec2ASCII(temp) );

         }


     }

     USART_Write( '\r' ); // send data via USART

     //==============================================

     //==============================================
     // Initial part of part of PDU
     for( i = 0;i<( sizeof( PDU_SMS_Message01 ) - 1 );i++ )
     USART_Write( PDU_SMS_Message01[i] );

     // For septet count

     SeptetCount = sizeof( TextMsg ) - 1 ;
     Get_SeptetCount( SeptetCount );

     //==============================================

     if( MessageLength <= 8 )
     Generate_PDU_Octets( TextMsg,sizeof(TextMsg)-1 );

     // valid working code- for EightChSet*8
     //(which equals 136 for EightChSet = 17 ) characters
     if( ( MessageLength > 8 )&&( MessageLength == (EightChSet*8) ) )
     {

         for( q=0; q< EightChSet; q++ )
         {
              m = 0;
              for( j = (q*8);j< ( 8+ (q*8) );j++ )
              {
                  TempBuffer[m] = TextMsg[j]; m++;
              }

              Generate_PDU_Octets( TempBuffer,8 );
         }

     }

     // valid working code - for MessageLength !=
     //EightChSet*8, upto 140 characters
     if( ( MessageLength > 8 )&&( MessageLength != (EightChSet*8) ) )
     {

         for( q=0; q< EightChSet; q++ )
         {
              m = 0;
              for( j = (q*8);j< ( 8+ (q*8) );j++ )
              {
                  TempBuffer[m] = TextMsg[j]; m++;
              }

              Generate_PDU_Octets( TempBuffer,8 );
         }

        for( j = (EightChSet*8);j<MessageLength;j++ )
             TempBuffer[j-(EightChSet*8)] = TextMsg[j];

         Generate_PDU_Octets( TempBuffer,ExtraCh );

     }

//=================================================

     USART_Write( CtrlZ ); // Ctrl + Z

     while (1)
     {//Start of endless while loop

            PORTD^=0x0F;
            Delay_ms(100); // 100 msecond delay

     }//End of endless while loop

}//~ End of main Function

Virtual GPS Engine for simulation in Proteus

2011-02-08T21:32:00.010+05:00

This post is regarding how to read a text file,through Proteus VSM for simulation and post processing,containing unprocessed GPS data the has previously been recorded on a text file in laptop computer by GPS Engine by carrying the GPS Engine connected with Laptop in a vehicle.

I stored GPS data (without parsing in raw format) in a text file through hyper terminal in a Laptop,by connecting GPS with my laptop computer and carrying that laptop along in a moving vehicle.I needed to process that data in Proteus Simulation software.For this purpose, i would have to read that GPS data in Proteus VSM from text file for developing algorithm for parsing and post processing in micro-controller.

For this purpose you need following components:

Eltima Virtual Serial Port Driver Sofware for creating virtual serial ports.
Visualbasic6 code for reading data from Text File and sending it to Proteus COMPIM model
Proteus VSM Software

I have used Eltima Virtual Serial Port Driver and COMPIM model in Proteus to send text file (in which GPS data has been saved) through an application developed in Visual Basic6 to the COMPIM model in Proteus simulation.

The circuit schematic drawn in Proteus VSM i shown in Figure1 below :

Figure 1: Circuit Schematic

A test run of this Proteus VSM simulation is shown in the Figure2 below.

Figure 2 : Test run of Simulation

A screen shot of Eltima Software Interface for Virtual serial port connection establishment is shown in the Figure 3 below:

Figure 3 : Eltima Software Interface

The objective of this simulation is to read the GPS data stored in a text file in Proteus VSM Simulation Software,where this data can be fed to the serial port of the microcontroller simulation model for developing logic and code for real hardware to extract desired information from raw GPS data.

A screen shot of the Visual Basic6 project is shown in the Figure 4 below:

                                  Figure 4 : Screen Shot of VB project

The VB Codes for project shown in Figure4 are given below.

VB6 Code 01 (File named : ReadWrite.cls) :

Public Function ReadLine(fname As String, LineNumber As Long) _
     As String

Dim oFSO As New FileSystemObject
Dim oFSTR As Scripting.TextStream
Dim lCtr As Long

If oFSO.FileExists(fname) Then
     Set oFSTR = oFSO.OpenTextFile(fname)
     Do While Not oFSTR.AtEndOfStream
        lCtr = lCtr + 1
        If lCtr = LineNumber Then
            ReadLine = oFSTR.ReadLine
            Exit Do
        End If
        oFSTR.SkipLine
    Loop
     oFSTR.Close
     Set oFSTR = Nothing

   End If
End Function

Public Function SaveTextToFile(FileFullPath As String, _
sText As String, Optional Overwrite As Boolean = False) As _
Boolean

On Error GoTo ErrorHandler
Dim iFileNumber As Integer
iFileNumber = FreeFile

If Overwrite Then
    Open FileFullPath For Output As #iFileNumber
Else
    Open FileFullPath For Append As #iFileNumber
End If

Print #iFileNumber, sText
SaveTextToFile = True

ErrorHandler:
Close #iFileNumber
End Function

VB6 Code 02 (File named : TextFiles.cls) :

Option Explicit

Private m_sFilePath As String
Private m_lSize As Long
Private strLines() As String
Private m_lines As Long
Public completeFile As String

Private Sub ReadFile()
m_lines = 0
Dim fso As New Scripting.FileSystemObject
    Dim ts As Scripting.TextStream
    Dim str As String

    '// Store size
    m_lSize = fso.GetFile(m_sFilePath).Size

   Dim i As Long
   i = 0
           ReDim Preserve strLines(0 To 800000) As String

    '// Get number of lines
    Set ts = fso.OpenTextFile(m_sFilePath, ForReading, False)

    While Not ts.AtEndOfStream
        str = ts.ReadLine
        i = i + 1
        strLines(i - 1) = str
        m_lines = i
        'completeFile = completeFile & str
    Wend
   completeFile = Join(strLines, vbCrLf)
    '// Close file
    ts.Close

    '// Release objects
    Set ts = Nothing
    Set fso = Nothing

End Sub
Public Property Get ReadLines(n As Long, m As Long) As String
Dim buf As String
buf = ""
Dim i As Long
For i = n To m
If i >= n And i <= m Then
buf = buf & strLines(i - 1) & vbCrLf
DoEvents
End If
If i > m Then
ReadLines = buf
Exit Property
End If

Next
ReadLines = buf
End Property

Public Property Get ReadLine(ByVal n As Long) As String
If n <= 0 Then n = 1
If n >= m_lines Then n = m_lines
   ReadLine = strLines(n - 1)
End Property

Public Property Let TextFilePath(ByVal pVal As String)

    m_sFilePath = pVal
    ReadFile

End Property

Public Property Get FileSize() As Long

    FileSize = m_lSize
End Property

Public Property Get NoOfLines() As Long
    NoOfLines = m_lines
End Property

Public Sub WriteNewLine(ByVal str As String)
m_lines = m_lines + 1
ReDim Preserve strLines(0 To m_lines) As String
strLines(m_lines - 1) = str
WriteFile

End Sub
Private Sub WriteFile()
    Dim i As Long
    i = 0
    Dim fso As New Scripting.FileSystemObject
    Dim ts As Scripting.TextStream

    Set ts = fso.OpenTextFile(m_sFilePath, ForWriting, False)

    For i = 0 To m_lines - 1
        ts.WriteLine (strLines(i))
    Next
    ts.Close

    '// Release objects
    Set ts = Nothing
    Set fso = Nothing

End Sub

Private Sub WriteFileAtPosi(ByVal str As String, ByVal posi As Long)
    Dim i As Long
    i = 0
    Dim fso As New Scripting.FileSystemObject
    Dim ts As Scripting.TextStream

    Set ts = fso.OpenTextFile(m_sFilePath, ForWriting, False)

    For i = 0 To m_lines - 1
        If (i = posi) Then
        ts.WriteLine (str)
        End If
        ts.WriteLine (strLines(i))
    Next
    ts.Close

    '// Release objects
    Set ts = Nothing
    Set fso = Nothing

End Sub

Public Sub InsertNewLine(ByVal str As String, ByVal posi As Long)
    WriteFileAtPosi str, posi
    ReadFile
End Sub

Private Sub ReplaceFileAtPosi(ByVal str As String, ByVal posi As Integer)
    Dim i As Integer
    i = 0
    Dim fso As New Scripting.FileSystemObject
    Dim ts As Scripting.TextStream

    Set ts = fso.OpenTextFile(m_sFilePath, ForWriting, False)

    For i = 0 To m_lines - 1
        If (i = posi - 1) Then
        ts.WriteLine (str)
        i = i + 1
        End If
        ts.WriteLine (strLines(i))

    Next
    ts.Close

    '// Release objects
    Set ts = Nothing
    Set fso = Nothing

End Sub

Public Sub ReplaceLine(ByVal str As String, ByVal LineNum As Integer)
    ReplaceFileAtPosi str, LineNum
    ReadFile
End Sub

Public Sub DeleteLines()
    Dim i As Long
    i = 0
    Dim fso As New Scripting.FileSystemObject
    Dim ts As Scripting.TextStream

    Set ts = fso.OpenTextFile(m_sFilePath, ForWriting, False)

    For i = 5000 To m_lines - 1
        ts.WriteLine (strLines(i))
    Next
    ts.Close

    '// Release objects
    Set ts = Nothing
    Set fso = Nothing
ReadFile
End Sub

Tips on buying a potable DVD Player

2011-02-05T22:18:00.022+05:00

Technology,especially electronics and computer technology, evolves so fast and at such an enormous pace that the electronics products that were being commonly used a few years back have now become completely obsolete.This holds true especially in the case of audio and video players.Just a few years back people used to have VHS tapes and VHS players for watching movies on TV,but now we see that DVD and DVD player have taken the place of VHS tape and VHS player.VHS tapes have become almost obsolete now.Further development in this regard is that Blue Ray Disc is next in line to take place of DVD.No wonder the DVDs may become obsolete after about a couple of years.So it is highly advisable to do some research and maket survey before you actually decide to buy some electronics or computer related product otherwise lest you should regret after making a purchase.

This article discusses some of the salient features and factors that you should consider while buying a DVD player.In my view the following are some of the important factors that you should consider while buying a DVD player:

1. How much is your budget?

First and the foremost factor that dictates the quality and features that the DVD player ,that you plan to buy, is supposed to equipped with is how much you can afford to invest in buying a DVD player.So in layman's term quality obviously comes at a price.The bigger the price the better the quality and features the DVD player will be equipped with.Also there is always a limit to how much you can afford to invest in buying any thing from the market.So ,while buying a DVD player,inevitably you will have to make a trade-off between how much you can afford and the quality and features that you are interested in.Therefore,before buying a DVD player,it is recommended that first you should figure out your budgetary constraints and then you should do a market survey about the options available in the market.

2.Brand of DVD Player

Some techies hold the opinion that brand of DVD player does not matter provided that the DVD player is being sold with a warranty of one year. I personally do not agree fully with this opinion.I think brand of the DVD player is a very important factor to consider.The DVD player that you intend to buy should not only be of some reputed brand available in the market but also it should be covered under one year after sale warranty,so that in case if any fault arises during the warranty period,the warranty of the DVD player may being claimed without any hassle.Though the reputed brand might cost more than any ordinary brand,but it is really worth this extra cost.In this regard,Sony,Toshiba and Samsung are some of the good brand names.

3.Remote

Remote is an essential item of the DVD player.You may need to navigate through the DVD movie while you are sitting at a distance in your bed or couch before your TV and enjoying the movie being played on the DVD player.Some techies hold the opinion that quality of remote of the DVD player is reflective of the quality of the DVD player.I think this is true as low end DVD players usually have remotes of inferior quality that break and get damaged easily if they are not handled with care.Buttons of such remotes are not good either as they are stiff to press and numbers printed on them fade away after some use.Therefor while buying a DVD player you must take into consideration the quality and functionality of the remote of the DVD player that you plan to buy.

4.Connections

Like an old-timer VHS player you need to connect your DVD player with TV.Therefore the DVD player must be equipped with connections to hook-up with TV.In order to get the best picture quality that a DVD player could offer, you should utilize the best video connection that the DVD player you buy might be equipped with.This is usually constrained by the type of input connections that your TV set is equipped with. In addition to the common VHS type audio and video connections that DVD players are ordinarily equipped with there are some new connections that you must consider:

a.Component video Out : This is supposed to be the best way to connect your DVD player with TV.This connection needs three cables to hook-up your DVD player with TV.However, downside

to this connection is that many TV sets do not support this connection.However,if your TV set supports this connection or you have plans to buy a new TV set as well,then you should make sure that the DVD player that you intend to buy should be equipped with Component video Out connection.The video being played when the DVD is hooked-up with TV set through component video out connection gives the best color fidelity and picture quality.

b.S-Video : After Component video Out connection S-video connection is supposed to be the second best connection for hooking up your DVD player with TV set.The picture quality and color reproduction accuracy offered by S-Video connection is considered inferior to what is offered by component video connection.

c.composite Video Connection : Composite Video is the most basic type of connection,comprising a single RCA cable, between the video player (VHS VCR, DVD player,analog camcorders etc.) and the display (Digital TV-HDTV Set or analog TV).This connection gives picture of inferior quality as compared with component video and s-video connections.There this connection should only be used if both of the above mentioned options are not available.Despite its lower quality performance as compared with the above to connections, the picture produced by this connection this connection is way better than what you can get with a VHS VCR.

5.Special Effects

Make sure that the DVD player that you intend to buy is equipped with features for special effects like pause,slow-motion,zoom.3-d virtual surround sound,forward and reverse scan capability with multiple speeds,capability to play movie frame-by-frame both in forward and reverse direction etc.

6.Audio Features

The audio and sound quality played by the DVD player is an important feature that you should take into special consideration,particularly if you have home theater surround system or you have plans for putting together a home theater surround system.The features important in this regard are player's audio analog-to-digital conversion capability,surround features and audio outputs.

7.Ease of use

In my view the most important and usually overlooked factor about a DVD player is its ease of use.The DVD player that you like to buy should be user-friendly and easy to operate in every-day use.The DVD player should be equipped with properly designed on-screen displays and menus that should be handy for an ordinary user to operate the DVD player without much effort.Therefore,while buying a DVD player should carefully inspect the front panel of the DVD player and you should note what buttons are available on the front panel and whether the buttons on the front panel seem logically laid out or not.
It should not be a rocket science to operate the DVD player.Otherwise,if you have go through bulky user manuals to familiarize yourself with the use of your DVD player then this is never desirable.

Interfacing AVR micro-controller ATmega32 with Multimedia Card (MMC)

2011-01-31T01:18:00.005+05:00

Multimedia card (MMC) is a data storage device used mostly in mobile phones and digital camera.Multimedia cards are available in market in a wide range of data storage capacities ranging from tens of Mega Bytes (MBs) to about 2 Giga Bytes and even more.A multimedia card can be interfaced with any device either through SPI (Serial Peripheral Interface) or Multimedia protocol.SPI

The C code for writing data on MMC and reading data from MMC is given below.This code simply writes data to five sectors if MMC when upper button (active low),connected with PA0, is pressed.When the lower button (active high) ,connected with PA1, is pressed the micro-controller reads the data, that has been written earlier on five sectors, and then displays the read data on Virtual Serial Terminal.In this code sector size of MMC is 512 Bytes.

Figure 1 : Schematic diagram of Proteus simulation

C Code:

////////////////////////////////////////////////////////////////////////////////
//ICC-AVR application builder : 1/21/2007 12:37:44 AM
// Target : M32
// Crystal: 11.059Mhz
////////////////////////////////////////////////////////////////////////////////

#include <iom32v.h>
#include <macros.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

#define SPIDDR DDRB
#define SPIPORT PORTB
#define SPIPIN PINB
#define CS      0x10
#define BinToASCII(t) ((t<=9) ? (t|0x30):(t+55))
#define ASCIIToBin(t) ((t>='A'&& t<='F')?t-55:((t>='0'&& t<='9') ? t-'0':0))
#define BYTELOW(v) (*((unsigned char *)(&v)))
#define BYTEHIGH(v) (*(((unsigned char *)(&v) + 1)))
#define BLOCK_SIZE   512

const unsigned char CMD0_RST_IDLE[]={0x40,0x00,0x00,0x00,0x00,0x95};
//command 0 reset all card to idle state
const unsigned char CMD1_SND_OPCND[]={0x41,0x00,0x00,0x00,0x00,0xFF};
//command 1 for read OPERATION CONDITION register
const unsigned char   CMD16_SET_BLOCKLEN[]= {0x50,0x00,0x00,0x02,0x00,0xFF};
//command 16 TO SET BLOCK LENGHT=512 BYTE TO READ & WRITE
//0x000200=512 & 0x00000010=16
const unsigned char   MSGF[] ={"\rMMC CARD INTERFACE\r"};
const unsigned char   MSG0[] ={"\rMMC CARD COMMAND 0\r"};
const unsigned char   MSG1[] ={"\rMMC CARD COMMAND 1\r"};
const unsigned char   MSGB[] ={"\rMMC CARD COMMAND BLOCK=512\r"};
const unsigned char   MSGW[] ={"\rMMC CARD SECTOR WRITE\r"};
const unsigned char   MSGR[] ={"\rMMC CARD SECTOR READ\r"};
const unsigned char   MSG[] ={"\nMMC CARD IS INITIALIZED SPI MODE\n"};
const unsigned char   CSD[] ={"\rCSD INFORMATION:\r"};
const unsigned char   CID[] ={"\rCID INFORMATION:\r"};
const unsigned char   WACK[] ={"\rWRITE ACKNOLEDGE:\r"};
const unsigned char   WNFSH[]={"\rWRITE NOT FINISH:\r"};
unsigned char TEMP;
unsigned int iSIZE;
unsigned int iSIZE1;
unsigned char BUFFER[128];

unsigned char adc_low,adc_high;
unsigned int timer0_counter=0,tcounter0=0;

unsigned char Data=65;

unsigned int RdFlag=0,WrtFlag=0;

unsigned char Button1Pressed=0,Button2Pressed=0;

/*****************************************************/
//****************** Port initialisation **********************/
/******************************************************/

void port_init(void)
{
    PORTA = 0x00;
    DDRA = 0x03;
    PORTB = 0xFF;
    DDRB = 0xFF;
    PORTC = 0x00;
     DDRC = 0x00;
     PORTD = 0x00;
   DDRD = 0x00;
}

//UART0 initialize
// desired baud rate: 57600
/* *************************************************** */

void uart0_init(void)
{
UCSRB = 0x00; //disable while setting baud rate
UCSRA = 0x00;
UCSRC = BIT(URSEL) | 0x06;
UBRRL = 0x0B; //set baud rate lo
UBRRH = 0x00; //set baud rate hi
UCSRB = 0x18;
}

////////////////////////////////////////////////////////////////////////////////
//                SPI port initilaisation                         //
////////////////////////////////////////////////////////////////////////////////

void SpiInit()
{
      DDRB = 0xB0;   // Set SCK, MOSI & SS as outputs
      SPCR = 0x53;
      PORTB = 0xEF; // clear bits MOSI, & SCK
}

//TIMER0 initialize - prescale:1024
// WGM: Normal
// desired value: 100Hz
// actual value: 100.933Hz (0.9%)
void timer0_init(void)
{
    TCCR0 = 0x00; //stop
    TCNT0 = 0x95; //set count
    OCR0 = 0x6B; //set compare
    TCCR0 = 0x05; //start timer
}

#pragma interrupt_handler timer0_ovf_isr:iv_TIM0_OVF
void timer0_ovf_isr(void)
{
    TCNT0 = 0x95; //reload counter value
   timer0_counter++;
   tcounter0++;
   if(Button1Pressed==1)
   {
       PORTA^=0x01;
       timer0_counter=0;
       Button1Pressed=0;
   }

   if(Button2Pressed==1)
   {
       PORTA^=0x02;
       tcounter0=0;
       Button2Pressed=0;
   }
}

///////////////////////// UART data receive routine //////////////////////////
unsigned char ReceiveByte(void)
{
      while(!(UCSRA & BIT(RXC)));
      return UDR;
}
///////////////////////// UART data transmit routine //////////////////////////
void SEND_CHAR_UART(char ch)
{
      while(!(UCSRA & BIT(UDRE))) ;
      UDR = ch;
}

void SendStr(const char *ch)
{
      while(*ch != 0x00)
      SEND_CHAR_UART(*ch++);
}
/*------------------------------------*/
void PRINT_ASCII (unsigned char PRNT)
{
      unsigned char PRN=0;
      PRN=PRNT>>4;
       SEND_CHAR_UART(BinToASCII(PRN));
      PRN=PRNT&0x0F;
      SEND_CHAR_UART(BinToASCII(PRN));
}

/*** SpiWriteByte() writes a byte to the SPI and waits until
it has been transmitted.This function doesn't return any value back.**/
unsigned char CHAR_SPI(unsigned char byte)
{
      SPDR = byte;
      while (!(SPSR & 0x80));
      return SPDR;
}
//**************************************
// void Delay_1ms(void)
//**************************************
void Delay_1ms(int Del)
{
      int i;
       while(Del--)
      {
           for (i=0;i<200;i++)
           WDR();
      }
}
//-----------------------------------------------------------------//
//                   MMC GET RESPONSE                //
//-----------------------------------------------------------------//
unsigned char MMC_RESPONCE(unsigned char RESPONSE )
{
       unsigned int COUNT=0xFFF; // for 64 MB card
        //unsigned int COUNT=0xFFFF; // for 1 GB
       unsigned char RESULT;
       while(COUNT!=0)
       {
              RESULT = CHAR_SPI(0xFF);
              // PRINT_ASCII (RESULT); SEND_CHAR_UART('\r');
             if(RESULT==RESPONSE)
              break;
              COUNT--;
       }
       if(COUNT==0)return 1;
       else
        return 0;
}
/************************************************/
unsigned char MMC_WAIT_FOR_WRITE_FINISH( void )
{
       unsigned char LPCNT=0xFF;
       unsigned char RESULT = 0;
       /* The delay is set to maximum considering the longest data
        block length to handle */
       while( (RESULT == 0) && LPCNT )
        {
                 RESULT = CHAR_SPI( 0XFF);
               LPCNT--;
       }
       if (LPCNT== 0 )
        return 1;    /* Failure, loop was exited due to timeout */
       else return 0; /* Normal , loop was exited before timeout */
}
/*-----------------------------------------------------------------------*/
unsigned char MMC_INIT()
{
        unsigned char LPCNT=0;
       /* start off with 80 bits of high data with card deselected */
       SPIPORT |=CS;
       for(LPCNT=0;LPCNT<10; LPCNT++)
       CHAR_SPI(0xff);
/*------------------------------------CMD 0-------------------------------*/
       SPIPORT &= ~CS;        /* select card */
       CHAR_SPI( 0X40);CHAR_SPI( 0X00);CHAR_SPI( 0X00);
       CHAR_SPI( 0X00);CHAR_SPI( 0X00);CHAR_SPI( 0X95);

       if( (MMC_RESPONCE(0x01)) == 1 )
       {
           SPIPORT |=CS;
           return 1;
       }
       SendStr( MSG0);
/*-------------------------------------------------------------------------*/
         SPIPORT |= CS;
        CHAR_SPI(0xFF);
/*----------------------------------CMD1---------------------------------*/
        SPIPORT &= ~CS;
        LPCNT=0xFF;
        do
        {
               CHAR_SPI( 0X41); CHAR_SPI( 0X00);CHAR_SPI( 0X00);
               CHAR_SPI( 0X00); CHAR_SPI( 0X00);CHAR_SPI( 0XFF);
              LPCNT--;
        } while ( (MMC_RESPONCE(0x00) != 0) && (LPCNT>0) );
       if(LPCNT==0)
       {
             SPIPORT |= CS;
             return 1;
       }

        SendStr( MSG1);
/*--------------------------------------------------------------------*/
         SPIPORT |= CS;
        CHAR_SPI(0xFF);
/*---------------------CMD16 SET BLOCK LENGTH-------------*/

       SPIPORT &= ~CS;        // select card
       CHAR_SPI( 0X50);CHAR_SPI( 0X00);CHAR_SPI( 0X00);
       CHAR_SPI( 0X02);CHAR_SPI( 0X00);CHAR_SPI( 0XFF);
       if( (MMC_RESPONCE(0x00)) == 1 )
       {
           SPIPORT |=CS;
           return 1;
       }
        SendStr( MSGB);
        SPIPORT |= CS;
        CHAR_SPI(0xFF);

        return 0;
}

/*------------------------------------------------------------*/
//unsigned char MMC_WRITE_BLOCK(unsigned long SECTOR)
/*----------------------------------------------------------- */
void GET_CSD()
{
       SPIPORT &= ~CS;
       CHAR_SPI( 0x49);CHAR_SPI( 0x00); CHAR_SPI( 0X00);
       CHAR_SPI( 0x00);CHAR_SPI( 0x00); CHAR_SPI( 0XFF);
         while ((MMC_RESPONCE(0x00)) == 1);
          while( (MMC_RESPONCE(0xFE)) == 1 );
       for(TEMP=0;TEMP<=35;TEMP++)
       BUFFER[TEMP]=CHAR_SPI(0xFF);
         SendStr(CSD);
       for(TEMP=0;TEMP<=15;TEMP++)
       PRINT_ASCII(BUFFER[TEMP]);
         SEND_CHAR_UART('\n');
         SPIPORT |= CS;       // Deselect card
}

/*------------------------------------------------------------*/
//void GET_CID()
/*----------------------------------------------------------- */
void GET_CID()
{
       SPIPORT &= ~CS;       // select card
       CHAR_SPI(0x4A);CHAR_SPI(0x00);CHAR_SPI(0X00);
       CHAR_SPI(0x00);CHAR_SPI(0x00);CHAR_SPI(0XFF);
         while ((MMC_RESPONCE(0x00)) == 1);
         while( (MMC_RESPONCE(0xFE)) == 1 );
       for(TEMP=0;TEMP<=35;TEMP++)
       BUFFER[TEMP]=CHAR_SPI(0xFF);
         SendStr(CID);
       for(TEMP=0;TEMP<=15;TEMP++)
       PRINT_ASCII(BUFFER[TEMP]);
         SEND_CHAR_UART('\n');
         SPIPORT |= CS;       // Deselect card

}

/*----------------------------------------------------*/
void INSULATOR()
{
     CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);
   CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);
   CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);
   CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);
   CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);
   CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);
   CHAR_SPI( 0xFF);CHAR_SPI( 0xFF);
}

/*------------------------------------------------------------------*/

unsigned char MMC_WRITE_BLOCK( unsigned   int SECTOR)
{

        unsigned char WRT=65;// A
       unsigned int LPCNT=0;
        unsigned long ADDRESS=0;
       ADDRESS=(unsigned long)SECTOR*BLOCK_SIZE;

/*-----------------------CMD24-----------------------------------*/
       SPIPORT &= ~CS;

       CHAR_SPI( 0x58);
       CHAR_SPI (ADDRESS>>24);CHAR_SPI (ADDRESS>>16);
       CHAR_SPI (ADDRESS>>8);CHAR_SPI (ADDRESS>>0);
       CHAR_SPI( 0xFF);


          if( (MMC_RESPONCE(0x00)) == 1 )
           {
               SPIPORT |=CS;
               return 1;
              }

           CHAR_SPI(0xFF);
           CHAR_SPI(0xFE); //start of DATABLOCK


           for(LPCNT=0;LPCNT<512; LPCNT++)
           {
                  CHAR_SPI(Data);
               if((LPCNT%32)==0)
                 {SEND_CHAR_UART('\n');SEND_CHAR_UART('\r');}
               SEND_CHAR_UART(Data);
               //CHAR_SPI(WRT);
               //SEND_CHAR_UART(WRT);
           }


           CHAR_SPI(0xFF); CHAR_SPI(0xFF);   // dummy chksum

       LPCNT= CHAR_SPI(0xFF);

       //SendStr(WACK);   PRINT_ASCII(LPCNT);
         //PRINT_ASCII((LPCNT & 0x0F)); // disabled for debugging

       if ( (LPCNT & 0x0F) != 0x05 )
          {
                       SPIPORT |=CS;
                       return 1;
           }

                   if( MMC_WAIT_FOR_WRITE_FINISH()==1)
                   //disabled for debugging
                    {
                                 SendStr(WNFSH); // disabled for debugging
                             SPIPORT |=CS;
                                return 1;
                    }
SendStr( MSGW); //disabled for debugging
/*-------------------------------------------------------------------------*/
SPIPORT |= CS;
CHAR_SPI(0xFF);
return 0;
}
/*-------------------------------------------------------------------------*/
unsigned char MMC_READ_BLOCK( unsigned long SECTOR)
{

unsigned int LPCNT=0;
unsigned long ADDRESS=0;
unsigned char mmcData=0;

ADDRESS=(unsigned long)SECTOR*BLOCK_SIZE;


/*-----------------------CMD17-----------------------------------------*/
// CMD17 READ_SINGLE_BLOCK
// Function : Single block read
// [31:0] Data address R1

       SPIPORT &= ~CS; // Deslect Card

       CHAR_SPI( 0x51);

       CHAR_SPI (ADDRESS>>24);CHAR_SPI (ADDRESS>>16);
       CHAR_SPI (ADDRESS>>8); CHAR_SPI (ADDRESS>>0);

       CHAR_SPI( 0xFF);

          if( (MMC_RESPONCE(0x00)) == 1 )
           { SPIPORT |= CS;
               return 1;
           }

           //////////////////////////////////////////////////////////////////

           //while( (MMC_RESPONCE(0xFE)) == 1 )
             // disabled for debugging
           //SEND_CHAR_UART('r'); // disabled for debugging

           //////////////////////////////////////////////////////////////////


           while( (MMC_RESPONCE(0xFE)) == 1 );
              // added for debugging         //

           for(LPCNT=0;LPCNT<512;LPCNT++)
           {


                       if((LPCNT%32)==0)
                        {SEND_CHAR_UART('\n');SEND_CHAR_UART('\r');}

                       mmcData=CHAR_SPI(0xFF);
                       SEND_CHAR_UART(mmcData); // added for debugging

              }


           CHAR_SPI(0xFF); CHAR_SPI(0xFF); //read CHKSUM
SendStr( MSGR); // disabled for debugging
/*-----------------------------------------------------------------*/
SPIPORT |= CS; // deslect card
CHAR_SPI(0xFF);

return 0;

}

//call this routine to initialize all peripherals
void init_devices(void)
{
         CLI(); //disable all interrupts
          port_init();
         uart0_init(); // for baud rate of 115200 bps
       timer0_init();
         MCUCR = 0x00; // may be disabled for debugging?????
          GICR = 0x00;
          TIMSK = (1<<TOIE0);//timer interrupt sources-timer0
          SEI(); //re-enable interrupts
          //all peripherals are now initialized}
}
////////////////////////////////////////////////////////////////////////////////
void main(void)
{

     int i=0,LPCNT=0;
     unsigned char rData;
     unsigned int SECT=1000;

     init_devices();
     SpiInit();

////////////////////////////////////////////////////////////////////////////////
   SEND_CHAR_UART(0x0D);
   SEND_CHAR_UART(0x0A);
   SendStr( MSGF);   // Transmit welcome message.
       // MSGF[]={"\rMMC CARD INTERFACE \r"};
   SEND_CHAR_UART(0x0D);
   SEND_CHAR_UART(0x0A);
////////////////////////////////////////////////////////////////////////////////
   while ( MMC_INIT() != 0);
   //{
             SendStr( MSG);
           //SEND_CHAR_UART(0x0D);
             //SEND_CHAR_UART(0x0A);
           //break; disabled for debugging
   //}
   SEND_CHAR_UART(0x0D);
   SEND_CHAR_UART(0x0A);
        // MSG[] ={"\nMMC CARD IS INITIALIZED SPI MODE \n"};

   INSULATOR();

/*----------------------------------------------------------------------*/
   SPCR = 0x50;SPSR|=0x01;
/*-----------------------------------------------------------------------*/
   GET_CSD();
   INSULATOR();
   GET_CID();
   INSULATOR();

       RdFlag=0,WrtFlag=0;

        //insert your functional code here...
    while(1)
    {//start of while loop for data read & write

              ////////////////////////// write routine ///////////////////////////

              //if( ( (PINC&0x01)!=1 )&&( ((PINC&0x02)!=0)) )
              // added for debugging
              //{Button1Pressed=0;Button2Pressed=0;RdFlag=0,
             // WrtFlag=0;SECT=1000;} // added for debugging

              if((PINC&0x01)==1)
              {Button1Pressed=1;Button2Pressed=0;
                RdFlag=0,WrtFlag=1;SECT=1000;}
              if((PINC&0x02)==0)
              {Button2Pressed=1;Button1Pressed=0;
                RdFlag=1,WrtFlag=0;SECT=1000;}

              if(WrtFlag==1)
               {//if for write button

                    /////////////////////////////////////////////////////
                    //Routines for writing data

                   MMC_WRITE_BLOCK(SECT);

                   INSULATOR();
                   Data++;
                     SECT++;
                     if(SECT>1005)
                     {
                        SECT=1000;Data=65;
                       //RdFlag=1;
                       WrtFlag=0;
                     }


              }//end of if block for write button

               ///////////////// end of write routine /////////////////////////////

              if(RdFlag==1)
              {
                      //if swicth connected to PD3 closed then read
                      ////////////////////////////////////////////////////////////////////////////
                      // Routine for reading data
                    MMC_READ_BLOCK(SECT);INSULATOR();

                         SECT++;
                         if(SECT>1005)
                         {
                           SECT=1000;
                           RdFlag=0;
                           //WrtFlag=1;
                         }

                 }// closing bracket of if block for reading data
               CHAR_SPI(0x55); // added for debugging


     }//ending bracket for while loop for read & write

}

Things to consider when buying a laptop computer

2011-01-29T01:54:00.033+05:00

Buying a laptop computer is not a child's play,especially when there so many features and options available in the market in this regard.It is indeed a big purchase to make.Most of the people who use desktop computers are not much familiar with the features and options to focus on when it comes to buying a laptop computer.Computer vendors and dealers usually twist and exaggerate facts to entice the customers into buying their products.An average user who does not has a deep understanding of the technicalities of laptop computers may easily be overwhelmed by the features and options available in laptop computers that are advertised by the vendors.so an average user who is familiar with the use of desktop computers may easily end up buying a laptop computer which might prove to be a trash later on.Therefore it is suggested to do some research in this regard before you decide on buying a laptop computer.

In my view here are a few features and options that you should concentrate on when buying a laptop computer.

1. Figure Out your requirements

The most attractive feature of a laptop computer, as compared to the desktop computer, is its portability.Portability means it can be easily carried anywhere you like.If you need to travel frequently or you work out doors and you need to carry your computer with you then you definitely need a portable laptop computer.Laptop computers are usually much more expensive as compared to the desktop computers.Roughly a laptop computer costs almost twice as much as a desktop computer does.Downside to buying a laptop computer is its lack of flexibility to be upgraded like a desktop computer.Unlike a laptop computer a desktop computer can be easily upgraded according to user's needs.The portability of a laptop computer depends upon its size and weight.The lighter in weight and smaller in size a laptop computer is the more portable it is supposed to be.However,the portability comes at the cost of reduction in computing power of the computer.The more portable a laptop computer is the lesser the computing power it is equipped with.Therefore,it is highly recommended that until unless potability and mobility of your computer are your inevitable requirements,you should not buy a laptop computer instead of a desktop computer.

1. Processor

Processor (Microprocessor) is the heart and soul of your laptop computer.The performance of your computer is greatly dependent upon the type,brand,speed and cache memory of the processor of your computer.One of the two most reputed brands of processors available in the market are Intel and AMD.You can choose either one of these two.At the moment Intel's Core 2 Duo is considered to be the best processor for laptop computers that caters to needs of an ordinary user.The choice of processor greatly depends upon the type of the application programs that you mostly like to run on your laptop computer.For gaming enthusiasts Intel's Core 2 Quad and Core i7 CPUs are a more appropriate.
The speed of the microprocessor of computer is usually expressed in terms of Giga Hertz (GHz).This is an important factor that should be considered while buying a laptop computer.This figure represents the clock speed of microprocessor.It is actually the measure of the millions of instructions a microprocessor is capable of processing in one second.The higher the clock speed of the microprocessor,in terms of GHz's, the faster is the information processing capabilities of your computer.In my opinion the speed of your processor should be at least 3GHz.
Although the processing speed of the microprocessor is a very important factor that greatly affects the performance and computing power of your computer,but it should be noted that ,its not the only factor that you should concentrate on while buying a laptop computer.There are scores of other factors like cache memory,bus speed,RAM etc., as well that greatly affect the processing power and performance of your computer.

2. RAM

RAM stands for random access memory.This is the volatile memory where your operating system,application programs and data being used in different processes currently ongoing in your computer is loaded by your processor for fast acess.Data stays in RAM as long as your PC is running.As soon as your PC is powered off all the data loaded in your RAM is lost.RAM is much faster to read from and write to as compared with other types of storage media in your computer like Hard Disc,USB disc and CD ROM etc.Whenever your PC is turned on again,operating system and other files from your hard disc are loaded again into the RAM of your computer.RAM comes in the form of computer chips.These chips plug into special connectors in your computer.RAM is usually measured in terms of Mega Bytes (MBs).The processing speed of your computer also depends upon the amount of RAM in terms of MBs and access time of the RAM installed in your computer.The access time of the RAM is the amount of time the RAM takes to write data and to read it once that request has been placed by the processor.Typical access times vary from 9 nanoseconds to 70 nanoseconds depending upon the type of RAM.
In my view at least 1GByte of RAM should be installed in your laptop computer,preferably it should be 2GBs.

3.Motherboard

Motherboard is the main circuit board of your computer which has interfaces for connection with CPU and all the peripheral devices like hard disk,CD ROM and BIOS etc., which are essential for the functioning of your computer.Motherboard also contains expansion slots and ports like serial port,USB port and parallel port etc.,for connection with peripheral devices like mouse,keyboard and display etc.The design,architecture and brand of the motherboard of your laptop computer greatly affect the performance and computational power of your computer.Usually the motherboard of the laptop computer is proprietary.You cannot just fit any motherboard in your laptop casing.Keeping in view the significance of motherboard in laptop computer,while buying a laptop computer,you must overview the salient features and architecture of the motherboard of the laptop computer that you intend to purchase.

4. Battery Life and Quality

The most important motive behind purchasing a laptop computer is its portability and mobility.A good laptop computer is considered to be one which has battery which is good enough to last for at least two hours,once it has been charged,under normal operation conditions of laptop.So you should pay special attention to the type,quality and life of the battery of your laptop computer.So there is no use buying a laptop whose battery cannot last more than thirty minutes when the battery is fully charged and laptop is being powered by the battery.

5. Display Screen

All laptop computers come with built-in LCD displays,however you can also hookup an LCD monitor externally with your laptop computer.LCD screen of your laptop computer is an important factor that dictate the cost,power consumption,size and weight of your computer.The bigger the size of the display screen of your laptop computer the bigger will be the weight,size and power consumption requirements of your laptop computer and consequently the more difficult it will be to carry your laptop along with you.So the size of the display screen of your laptop computer greatly affects the potability and mobility of your laptop computer.
So,if you are a highly mobile type of person and you have to carry your laptop a lot along with you while traveling by road or by air then you definitely need a light weight and portable laptop computer.In such a case 14 inch display screen will be good for you.Otherwise,if you do not have such constraints then 17inch display screen is a good option.In short to decide upon the size of the display screen of your laptop computer you should first figure out your needs for portability and mobility of your laptop computer.

6. Ports

One of the most important factors that you should take into consideration while buying a laptop computer is that your computer should be equipped with fairly a good number of ports to meet your potential requirements for interfacing peripheral devices with your computer.These days due to growing competition in computer market and to reduce the cost of laptop computer many manufacturers are keeping the number of ports in new designs of laptops very low which may not be enough for potential needs of the end user.So be careful while buying a laptop ,so that your laptop should not be deficient in number of ports that you may need for your applications.

7.Wireless Connectivity

The laptop computer you intend to buy should be equipped with features for wireless connectivity like bluetooth,wifi and Infra-red connection etc.Your laptop should preferably equipped with a built-in integrated wireless network card (like 802.11b/g/n)and an integrated bluetooth device.

8.Operating System

There are three well known operating systems Microsoft Windows,Mac OSX and Linux that a laptop computer may be shipped preloaded with.Each of the three operating systems has its own individual advantages and disadvantages.However,it is recommended that the laptop computer you intend to buy should be preloaded with windows operating system.Although Microsoft Windows has security related bugs and is usually infested with viruses but because of wealth of applications available for Microsoft Windows,it is deemed to be industry standard operating system.Therefore by and large Microsoft windows Operating System is a good choice for a laptop computer.

9.Hard Drive

The hard disk of the laptop computer that you intend to buy should be capacious enough to contain your essential soft-wares and back up of your important data that you may need off and on.In addition to the capacity of hard drive in terms of GBs,it is also important to take into consideration the rpm speed of the hard drive.The bigger the rpm figure the faster the hard drive will be.

10.DVD ROM Drive

Soft-wares are usually available on CD and DVD ROMs,also you need to store the back up copies of your important data and softwares by writing them on CDs and DVDs.The laptop computer you intend to buy should be equipped with a DVD ROM Drive that should not only be able to read CDs and DVDs but also it should be able to write your data on CDs and DVDs.

OpAmp based Voltage Translator Ciruit for ADC of Micro-controller

2011-01-27T20:42:00.002+05:00

All the naturally occurring phenomena like sound,temperature and pressure etc, are analog in nature.Therefore to make an micro-controller read analog signal for analog-to-digital conversion process, through built-in analog-to-digital converter (ADC), it is necessary to subject the analog signal, generated by a transducer, to some analog signal conditioning and analog signal processing using analog circuits.The micro-controller can read such a signal,generated by a transducer,only if it has been conditioned and scaled down to a range which micro-controller can read for analog-to-digital conversion.This is necessary in particular for micro-controllers like AVR,PIC and Free-scale which have built-in ADCs.These micro-controllers usually operate with 5Volts power supply.

The circuits shown in the Figure1 below is appropriate for scaling down the transducer generated voltages to 0-5 Volts range.This circuit can translate the voltage falling in some other voltage range ( like -5 to +5 Volts or -10 to +10 Volts etc.) to 0-5Volt range so that a micro- controller ,being operated from 5Volt power supply, may read this signal, through its ADC input, without getting damaged.

Figure1 : Voltage Translator Circuit Schematic Diagram

The formula for voltage translation (as shown in Figure1) is given below:

Vout = Vin (Rf/R1) - (Rf/R2)V1

VM = -V1

A typical voltage translation circuit for translating the input voltage ranging from -5V- to- +5V to the 0-5V voltage range is shown in Figure2

Figure 2 : -5V-to-+5V input Voltage Translation to 0-5Volts

A sinusoidal input voltage of frequency 1KHz and -5V-to-+5V peak-to-peak voltage has been applied to the input of this circuit,which is translated to a sinusoidal output voltage with peak-to-peak amplitude varying from 0-5 Volts.

The input and output waveform of this circuit simulated in Multisim software by NI is shown in Figure 3 below.

Figure 3 : Input and Output waveform of Voltage Translator Circuit (-5V-+5V to 0-5V)

Interfacing PIC18F4520 with serial memory through IIC or I2C Interface

2011-01-26T22:35:00.009+05:00

The Serial EEPROM Memory (AT24C512) has been interfaced with PIC18F4520 micro-controller using I2C Interface.I2C Interface is also called Two-Wire Interface (TWI).TWI is ideally suited for typical micro-controller applications.This is a multi-master single-ended serial bus interface invented by Philips.The TWI protocol allows the embedded systems designer to interconnect up to 128 different devices with only two bi-directional bus lines, one for clock (SCL) and one for data (SDA). The only external hardware component required for implementation of the bus is a single pull-up resistor for each of the TWI bus lines. All devices connected to the bus have individual addresses, and mechanisms for resolving bus contention are inherent in the TWI protocol.

The Proteus VSM simulation,Schematic diagrams and C code developed in mikroC for PIC for interfacing serial memory AT24C512 (in this simulation 24LC512 has been used) with PIC18F4520 micro-controller is given below.

Figure : Schematic Diagram

                       Figure 1 : Signal Waveform and Data written to and
                                       read from serial memory

This C code simply writes a message string "Hello this is test message to be written to serial memory!" to the serial memory and then after that message has been written to the memory the micro-controller reads that message from serial memory and displays the retrieved message to the Virtual Terminal.

C Code:

/********************************************
* Project name:
     Serial Memory (24C512) read and write test code
* Copyright:
     M.Yasir
* Description:
     This code demonstrates how to use usart library routines.
     Upon receiving data via RS232, PIC MCU immediately
     sends it back to the sender.
* Test configuration:
     MCU:             P18F4520
     Dev.Board:       -
     Oscillator:      HS, 08.0000 MHz
     Ext. Modules:    -
     SW:              mikroC v8.0.0.0
* NOTES:
     - Connect Rx jumper to RC7 and Tx jumper to RC6.
*******************************************/
//************* Macros for serial memory ***************//
#define BIT7 0x80
#define BIT6 0x40
#define BIT5 0x20
#define BIT4 0x10
#define BIT3 0x08
#define BIT2 0x04
#define BIT1 0x02
#define BIT0 0x01

#define SDA BIT1
#define SCL BIT0

#define I2C_PORT    PORTC
#define I2C_DIR   TRISC

//***********************************************//
unsigned short i;
unsigned int j=0,k=0;
unsigned char msg01[]="Hello! This is a test message from UART\n\r";
//*************** union for addressing **************//
typedef union
{
            unsigned int i;
         unsigned char uc[sizeof(unsigned int)];

} i2c_un;

i2c_un ibuffer;
//***********************************************//
//***********************************************//
//************** I2C Memory Functions *************//
/*
Send START, defined as high-to-low SDA with SCL high.
Return with SCL, SDA low.
Returns CY set ifbus is not available
*/

void start(void)
{
       // Data changes on SDA line during SCL high periods
       // indicate a start or stop condition
       // A high to low transition on SDA line while clock is
       // SCL is high is start condition
       I2C_DIR &= ~SCL; I2C_PORT |= SCL;
       //CLK_L = 1; CLK_T = OUTPUT; -
       I2C_DIR &= ~SDA; I2C_PORT |= SDA;
       //SDA_L = 1; SDA_T = OUTPUT; -

       Delay_us(1); /* One microseconds pause */

       I2C_PORT &= ~SDA;//SDA_L = 0;

       Delay_us(4); /* Four microseconds pause */

       I2C_PORT &= ~SCL;//CLK_L = 0;
}
/*
Send STOP, defined as low-to-high SDA with SCL high.SCL
expected low on entry.Return with SCL, SDA high.
*/

void stop(void)
{
     // A low to high transition of SDA line while clock SCL is
     // high is stop condition
     I2C_DIR &= ~SDA;I2C_PORT &= ~SDA;
     //SDA_L = 0; SDA_T = OUTPUT;
     Delay_us(1);
     I2C_DIR &= ~SCL; I2C_PORT |= SCL;
     //CLK_L = 1; CLK_T = OUTPUT;
     Delay_us(4);
     I2C_PORT |= SDA;//SDA_L = 1;
}
/*
The state of data line represents valid data,when after a
start condition, the data line is stable for the duration of
high period of the clock signal.The data on the line must
be changed during the low period of the clock signal.
There is one bit of data per clock pulse
*/
// function for shifting 8-bits serially out of SDA to slave
unsigned char shout(unsigned char out)
{
         unsigned char count1, ack_flag;

         I2C_DIR &= ~SDA;
        //SDA_T = OUTPUT; // set SDA as output
         for(count1=0; count1<=7; count1++)
         {
             if((out & 0x80) == 0x80)
             // Most Significant bit is shifted out first
             I2C_PORT |= SDA;//SDA_L = 1;
             // if MSB is 1 then set SDA to 1
             else
             I2C_PORT &= ~SDA;//SDA_L = 0;
             I2C_PORT |= SCL;
             //CLK_L = 1;   // Set CLK to high
             Delay_us(4);
             I2C_PORT &= ~SCL;
             //CLK_L = 0; // set SDA to low
             out <<= 1; // shift bits to left by one bit
         }

         I2C_DIR |= SDA;//SDA_T = INPUT;
         // after shifting 8 bits set SDA as input to
         // get acknowledge bit from slave
         Delay_us(1);
         I2C_PORT |= SCL;//CLK_L = 1;
         // set CLK high while getting the acknowledge
         // bit from the slave
         Delay_us(4);
         //if(RC1 == 1) //??? check this code line
         // read SDA if SDA input is 1 sent by slave then set
         // Acknowledge flag to 1 else set it to 0
         if(PORTC & 0b00000010)
            ack_flag = 1;
         else
            ack_flag = 0;

         I2C_PORT &= ~SCL;//CLK_L = 0;
        // after getting the acknowledge bit set CLK to 0

         return ack_flag;
        // return the acknowledge received from the
        // slave from the function
}
/*

Each receiving device,when addressed,is obliged to generate and
Acknowledgment signal after the reception of each byte.The master
device must generate an extra clock pulse which is associate with
the Acknowledge bit.A device that acknowledges must pull down

the SDA line during the Acknowledge clock pulse in such a way that
the SDA line is stable low during the high period of the acknowledge
related clock pulse.Setup and hold times must be taken into account.
During reads, a master must signal and end of data to the
slave by not generating and Acknowledgment bit on the last byte
that has been clocked out of the slave.In this case the slave will
leave the data line high to enable the master to generate the Stop
condition

*/
////////////////////////////////////////////////////////////////////////////////
void write_byte(unsigned int address,unsigned char data)
{
     unsigned char valid=0;
     unsigned int i;
     ibuffer.i = address;
      //error_flag = 1;
      start();
      /*
      A control byte is the first byte received following the start
     condition start.The last bit of the control byte define the
     read/write operation to be performed. 1 - for read,0 - for
     write
    */
      valid = shout(0xa0); // 10100 000 0 - A0=0,A1=0,R/W=0

      if(valid != 1)
      {// if-1
         valid = shout(ibuffer.uc[1]);
         if(valid != 1)
         { // if-2
               valid = shout(ibuffer.uc[0]);
               if(valid != 1)
               { // if-3
                  valid = shout(data);
                  if(valid != 1)
                  {
                     //errror_flag = 0;
                  }
                  else
                  {
                  }
               } // end of if-3
               else
               {
               }
         }// end of if-2
         else
         {
         }
      }// end of if-1
      else
      {
      }
    stop();
    for(i=1; i<=2500; i++) // diabled for debug
    Delay_us(4);
}
/*
Clock out an acknowledge bit (low).
SCL expected low on entry.
Return with SCL, SDA low.
*/

void ack(void)
{
      I2C_DIR &= ~SDA;I2C_PORT &= ~SDA;
      //SDA_L = 0; SDA_T = OUTPUT;
        Delay_us(1);
      I2C_DIR &= ~SCL;I2C_PORT |= SCL;
      //CLK_L = 1; CLK_T = OUTPUT;
        Delay_us(4);
      I2C_PORT &= ~SCL;//CLK_L = 0;
}
/*
Clock out a negative acknowledge bit (high).
SCL expected low on entry.
Return with SCL low, SDA high.
*/

void nack(void)
{
      I2C_DIR &= ~SDA;I2C_PORT |= SDA;
      //SDA_L = 1; SDA_T = OUTPUT;
        Delay_us(1);
      I2C_DIR &= ~SCL;I2C_PORT |= SCL;
      //CLK_L = 1; CLK_T = OUTPUT;
        Delay_us(4);
      I2C_PORT &= ~SCL;//CLK_L = 0;
}
/*
Shift in a byte from the AT24Cxx, most significant bit
first.SCL expected low on entry. Return with SCL low.
Returns received data byte in A.
*/

unsigned char shin(void)
{
         unsigned char count1, c=0;

         I2C_DIR |= SDA;//SDA_T = INPUT;
         // set SDA as input for shifting data in
         I2C_DIR &= ~SCL;I2C_PORT &= ~SCL;
         //CLK_L = 0; CLK_T = OUTPUT;
         // set clock as out put and set CLK to 0

         for(count1=0; count1<=7; count1++)
         {
                     Delay_us(4);
               I2C_PORT |= SCL;//CLK_L=1;
               c<<=1; //
                //if(RC1==1) //if(SDA_P)
               if(PORTC & 0b00000010)
               c = c | 0x01;
                     Delay_us(1);
               I2C_PORT &= ~SCL;//CLK_L = 0;
         }
         return c;
}

unsigned char read_current(void)
{
         unsigned char ch, valid;
         start();

         valid = shout(0xa1); // what does 0xa1 stand for

         if(valid != 1)
         {
               ch = shin();
               nack();
         }
         else
         {
         }
         stop();
         return ch;
}
/*
   A random read requires a 'dummy' byte write sequence to load
   in the data world address Once the device word address and data
   word address are clocked in and acknowledged by the EEPROM,
   the micro-controller must generate another start condition.The
   micro-controller now initiates a current address read by sending a
device address with read/write select bit high.The EEPROM
acknowledges the device address and serially clocks out the
data word.The micro-controller does not respond with a zero but
generates a following stop condition
*/
unsigned char read_byte(unsigned int address)
{
         unsigned char valid=0, ch=0xFF;
         ibuffer.i=address;
         start();

         valid = shout(0xa0);
         // initiation of dummy byte write sequence for random read

         if(valid != 1)
         {
               valid = shout(ibuffer.uc[1]);
               if(valid != 1)
               {
                  valid = shout(ibuffer.uc[0]);
                  if(valid != 1)
                  {
                     ch = read_current(); // current a   address read
                  }
                  else
                  {
                  }
               }
               else
               {
               }
         }
         else
         {
         }
         stop();
         return ch;
}
//*********** End of I2C Memory Functions ************//

void main()
{

     unsigned char ch;
       unsigned int m=0;
       unsigned int memAddress=0x01;

       unsigned char msg02[]="\n\rHello this is test message\
                                                  to be written to serial memory!";
     /*
     CMCON |= 0x07;            // turn off comparators
     ADCON1 |= 0x0F;           // turn off analog inputs
     //MEMCON.EBDIS = 1; // disable external memory bus
     */
     /* In itialisation of Ports and peripherals */
     PORTB = 0;
     TRISB = 0;   // PORTD is output
     TRISC = ( TRISC&0xF0 )|0x0F;
      // PORTC lower nibble as input

     USART_init(57600);
     // initialize USART module (8 bit character size,
     //57600 baud rate, no parity bit...)
     //=====================================//
     for(j=0;j<sizeof(msg01);j++)
     USART_Write(msg01[j]);

     while (1)
     {
           /*
           if ( USART_Data_Ready() )
            {
                // if data is received
                i = USART_Read(); // read the received data
                USART_Write(i);     // send data via USART
            }
            */
            for( m=0; m< sizeof(msg02);m++ )
            {
                 write_byte( memAddress, msg02[m] );
                 // writes byte to serial memory
                 memAddress++;
            }
            memAddress=0x01;

                for( m=0; m<sizeof(msg02); m++)
                {
                        ch=read_byte(memAddress);
                USART_Write(ch);
                memAddress++;
                }
                memAddress=0x01;

            PORTB = ~PORTB;
            // Bitwise negation of pins on PORTB
            //Delay_ms(100);       // 1 second delay
     }
}

Protues Simulation of Interfacing LCD LM044L with ATmega32 AVR Microcontroller

2011-01-24T23:50:00.008+05:00

This post discusses how to interface an 8-bit AVR micro-controller (ATmega32) with a 20characterx4lines LM044L LCD (Liquid Crystal display).

LCD

LCD stands for Liquid Crystal Display.It is a thin flat electronic visual display that uses the light modulating properties of Liquid Crystals (LCs) .LCD's are used in a wide range of consumer electronics devices and applications like calculators,gaming devices,watches,clocks,mobile phones,energy meters,video displays,computer monitors and television etc.LCDs have displaced Cathode Rays Tube (CRT) displays in most of the applications.

LM044L is a 20characterx4lines LCD manufactured by Hitachi.It requires a single 5V power supply for its operation.The LCD panel has a built-in HITACHI controller LSI HD44780.In the HD44780,the data can be sent in two modes :

1. 4-bit two operations mode
2. 8-bit one operation mode

so this makes it flexible either to interface with 4-bit MPU or with 8-bit MPU.

When interface data is 4-bits long,data is transferred using four buses of LCD only i.e.,DB4-DB7.In this case data buses DB0-DB3 are not used.In this mode data transfer between MPU and HD44780 completes when 4-bit data is transferred twice.Data of the higher order 4-bits (contents of DB4-DB7,when interface data is 8-bits long) is transferred first and then the lower order 4-bits (contents of DB0-DB3,when interface data is 8-bits long) are transferred.When interface is 8-bits long,data is transferred using the 8 data buses of BD0-BD7.In this simulation interface data is 8-bits long and this is why 8 data buses of BD0-BD7 have been interface with PORTB of ATmeha32 AVR micro-controller.

Further details about this LCD can be found from the website of Hitachi.

AVR Micro-controller

The AVR micro-controller used in this simulation is ATmega32.ATmega32 is a powerful RISC 8-bit microcontroller, with 32kB In-System Programmable FLASH memory, 1024 bytes EEPROM and 2KBytes of internal SRAM. Its RISC CPU core can execute almost one instruction per cycle. The core is complemented with a rich set of peripherals, including I/O ports, timers, PWM, A/D converters, etc. Details can be found at Atmel's Website.

System Description:

In this simulation the ATmega32 operates at Oscillator frequency of 7.3728Mhz.The schematic diagram of this simulation in Proteus VSM is shown in the Figure below:

Figure: Schematic Diagram of Proteus Simulation

Characters typed on the Virtual Terminal of Protues VSM appear on LCD Screen.Virtual Terminal of Proteus VSM is in a way equivalent to the Hyper Terminal Software provided with Windows XP,which is used to read from or write data to the Serial port of PC.
The 8-data lines of LCD D0-D7 have been interfaced with PORTB of ATmega32.The control signals of LCD i.e.,RS,RW and E, are interface with PORTC0,PORTC1 and PORTC2 respectively. Serial port of ATmega32 is interfaced with Virtual Module of Proteus VSM.This is equivalent to interfacing ATmega32 with serial port of PC in real hardware.

The C code developed in ImageCraft C Compiler for AVR is give below :

//ICC-AVR application builder : 5/29/2009 5:58:38 PM
// Target : M32
// Crystal: 7.3728Mhz
// one instruction cycle = 0.1356 usec
// 8insc=1.08usec
#include <iom32v.h>
#include <macros.h>

/* defining pins for control signals */
#define RS    0x01   /* register select DR/IR: 1/0*/
#define RW   0x02   /* read/write: 1/0 */
#define E       0x04   /* enable/disable:: 1/0*/
#define busyCheck 0x80 /* busy checking bit */

/******************* defining commands to run **********************/
unsigned char spec         = 0x38;
// for specifications as lines and char pixels i.e 5x8
unsigned char LcdCur_ON = 0x0E; // Cursor ON/OFF:: 1/0
unsigned char Lcd_Clr = 0x01;         // Clear LCD
unsigned char Curser_Right = 0x06; // cursor movement to right direction
unsigned char Curser_HOME = 0x02;
// Move cursor to home location
/**************************************************************************/
/* text to display on LCD */
unsigned char *text = " Muhammad Yasir ";
unsigned char *engr = "Engineer";

unsigned int j=0,k=0;
/* signatures of the function being to used*/
void init(void); /* LCD initialization function */
void writeCmd( unsigned char );
/* function to run the commands on LCD*/
void getReady(void);
/* function to check either LCD free or in process i.e busy */
void writeByte(unsigned char );
/* function to write data/text to LCD. getting a pointer parameter.*/
void writeString(unsigned char *);
/* function to write data/text to LCD. getting a pointer parameter.*/
void writeByte(unsigned char);
/***************************************************************************/
delay_1uSec(unsigned int);

delay_1uSec(unsigned int m) // approximately m*1uSec Delay
{
    for(j=0;j<m;j++)
    {
       for(k=0;k<8;k++)
       asm("nop");
    }
}

void port_init(void)
{
     PORTA = 0x00;
     DDRA = 0x00;
     PORTB = 0x00;
     DDRB = 0xFF;
     PORTC = 0x00;
     DDRC = 0xFF;
     PORTD = 0x00;
     DDRD = 0x00;
}

//TIMER0 initialize - prescale:8
// WGM: Normal
// desired value: 8KHz
// actual value: 8.021KHz (0.3%)
void timer0_init(void)
{
     TCCR0 = 0x00; //stop
     TCNT0 = 0x45; //set count
     OCR0 = 0xBB; //set compare
     TCCR0 = 0x02; //start timer
}

#pragma interrupt_handler timer0_ovf_isr:12
void timer0_ovf_isr(void)
{
     TCNT0 = 0x45; //reload counter value
}

//UART0 initialize
// desired baud rate: 57600
/* ************************************************************************ */

void uart0_init(void)
{
     UCSRB = 0x00; //disable while setting baud rate
     UCSRA = 0x00;
     UCSRC = BIT(URSEL) | 0x06;
     UBRRL = 0x07; //set baud rate lo
     UBRRH = 0x00; //set baud rate hi
     UCSRB = 0x18;
}

/////////////// UART data receive routine //////////////////
unsigned char ReceiveByte(void)
{
    while(!(UCSRA & BIT(RXC)));
    return UDR;
}
////////////////// UART data transmit routine ///////////////
void SEND_CHAR_UART(char ch)
{
      while(!(UCSRA & BIT(UDRE))) ;
      UDR = ch;
}
///////////////////////////////////////////////////////////////////////////////

//call this routine to initialize all peripherals
void init_devices(void)
{
     //stop errant interrupts until set up
     CLI(); //disable all interrupts
     port_init();
     timer0_init();
    uart0_init();

     MCUCR = 0x00;
     GICR = 0x00;
     TIMSK = 0x00; //timer interrupt sources
     SEI(); //re-enable interrupts
     //all peripherals are now initialized
}

//
void main(void)
{
     unsigned char ch;
    unsigned int m=0;
    init_devices();
     //insert your functional code here...

    while(1)
    {
        init(); /* call to initialization function*/
        for(m=0;m<40;m++)
        {
             ch=ReceiveByte();
             writeByte(ch);
        }

    }

}
/* init() function definition. this function sends commands to the LCD for */
void init()
{    /* initialization by calling the writeCmd(bit8) function.*/
    writeCmd(spec);
    delay_1uSec(1);
    writeCmd(LcdCur_ON);
    delay_1uSec(1);
    writeCmd(Lcd_Clr);
    delay_1uSec(1);
    writeCmd(Curser_Right);
    delay_1uSec(1);
    writeCmd(Curser_HOME);
    delay_1uSec(1);
}

/* function defination for writeCmd(bit8) */
void writeCmd(unsigned char cmd)
{
     getReady();        /* function for checking either is LCD not busy?*/
     delay_1uSec(1);
    PORTC &= ~E;
     /* make sure LCD not selected. that not be during initializing process*/
    delay_1uSec(1);
    PORTB = cmd;     /* sending commmand to port3 bcz lcd conneted to..... */
    delay_1uSec(1);
    PORTC &= ~RS; /*Select instruction register*/
    delay_1uSec(1);
    PORTC &= ~RW; /* Write select control */
    delay_1uSec(1);
    PORTC |= E;
    delay_1uSec(1);
    PORTC &= ~E;
    delay_1uSec(1);
}

/* Check busy bit7 of the port3: function defination */

void getReady()
{
    PORTC &= ~E;           /* make sure lcd is not selected */
    delay_1uSec(1);
    PORTB |=busyCheck; /* Make input Bit */
    delay_1uSec(1);
    PORTC &= ~RS;         /* Command Register select */
    delay_1uSec(1);
    PORTC |= RW;            /* Read from LCD */
    delay_1uSec(1);
    while ( (PINB & busyCheck) != 0x80)
    {
        PORTC &= ~E;
        delay_1uSec(1);
        PORTC |= E;
        delay_1uSec(1);
    }
    PORTC |= E;
    delay_1uSec(1);
}
/* function defination to display data on LCD*/
void writeString(unsigned char *str)
{
    unsigned char i;
    unsigned int j;
    getReady();
    delay_1uSec(1);
    PORTC &= ~E; /* make sure lcd is not selected    */
    delay_1uSec(1);
    for( i = 0; str[i] !='\0'; i++ )
    {
            PORTB=str[i];
            delay_1uSec(1);
            PORTC |= RS;
            delay_1uSec(1);
            PORTC &= ~RW;
            delay_1uSec(1);
            PORTC |= E;
            delay_1uSec(1);
            PORTC &= ~E;
            delay_1uSec(2000);

    }

    ////////////////////////////////////
}

/* function defination to display data on LCD*/
void writeByte(unsigned char Byte)
{
     unsigned char i;
    unsigned int j;
    getReady();
    delay_1uSec(1);
    PORTC &= ~E; /* make sure lcd is not selected    */
    delay_1uSec(1);

    PORTB=Byte;
    delay_1uSec(1);
    PORTC |= RS;
    delay_1uSec(1);
    PORTC &= ~RW;
    delay_1uSec(1);
    PORTC |= E;
    delay_1uSec(1);
    PORTC &= ~E;
    delay_1uSec(2000);

    ////////////////////////////////////
}

Speech Generation using Pulse Width Modulation (PWM) with AVR Microcontroller

2011-01-18T02:43:00.000+05:00

Introduction

With advancement in microcontroller technology it has now become possible to generate speech using Pulse Width Modulation (PWM) feature of AVR microcontroller instead of using some specialized audio chip or DSP processor. This article discusses basic mechanism behind speech generation using Pulse Width Modulation (PWM) with 8-bit AVR microcontroller ATmega8535 has been utilized for generating speech from the speech samples that have been recorded, through Analog-to-digital Conversion, over Multimedia Card in SPI mode. For getting speech samples built-in Analog to digital converter of ATmega8535 has been utilized.

Overview

The heart and soul of this digital voice recording playback system is an Atmel ATmega8535 microcontroller.ATmega8535 is a powerful RISC 8-bit microcontroller, with 8kB In-System Programmable FLASH memory, 512 bytes EEPROM and 512 bytes of internal SRAM. Its RISC CPU core can execute almost one instruction per cycle. The core is complemented with a rich set of peripherals, including I/O ports, timers, PWM, A/D converters, etc. Details can be found at Atmel's Website.

Figure1: Block Diagram

Multimedia Card has been interfaced with AVR microcontroller through SPI port using SPI protocol. Multimedia Card is commonly used in mobile phones for storing audio, video and image files. Multimedia Card is commonly available in market in a wide range of memory capacities ranging from tens of megabytes of storage capacity to about 2GB and even more. Four LEDs and four push button switches have been added to the system. One push button switch is for recording the speech data on Multimedia Card while the other push button switch is for play back of the recorded sound through PWM. One LED blinks while speech data is being recorded over Multimedia Card, while other LED blinks when recorded data is being played back by MCU through PWM. While the other two push buttons and other two LEDs are for potential use so that features like fast forward and rewind may be added to this system. Speech data for almost 20 seconds is recorded on the Multimedia Card which is subsequently played back by pressing the play button. The audio is picked up by a condenser microphone, and amplified by an LM386 based amplifier. The amplified signal is then filtered and passed to the built-in Analog-to-Digital Converter of ATmega8535.The analog speech input signal is sampled by Analog-to-Digital Converter at a frequency of 8kHz.Each of the speech samples generated by the A/D converter of MCU comprises 10-bits. The 10-bit speech samples are scaled down to-8 bit samples before storage. During playback, the samples stored in the Multimedia Card are sent to the MCU's PWM module, which produces approximately a 16 KHz (here which is actually 15.686 KHz) PWM signal whose pulse width is proportional to the amplitude of the speech sample. This PWM signal is filtered, amplified, and then passed to a loudspeaker for playback. The loud speaker is driven by the amplifier circuit based on LM386.The loud speaker used for this system is an 8Ω and 0.5W loud speaker.

Input Amplifier and Filter

The LM386 has been used as an input amplifier. The LM386 is a power amplifier designed for use in low voltage consumer applications. The gain is internally set to 20 to keep external part count low. Pins 1 and 8 serve for gain control. With pins 1 and 8 open, the 1.35 kW internal resistor sets the gain at 20 (26 dB). If a capacitor is put from pin 1 to 8, bypassing the 1.35 kW resistor, the gain will go up to 200 (46 dB). If a resistor is placed in series with the capacitor, the gain can be set to any value from 20 to 200.The inputs are ground referenced while the output automatically biases to one-half the supply voltage. The quiescent power drain is only 24 mill watts when operating from a 6 volt supply, making the LM386 ideal for battery operation.

When using the LM386 with higher gains (bypassing the 1.35 kW resistor between pins 1 and 8) it is necessary to bypass the unused input, preventing degradation of gain and possible instabilities. This is done with a 0.1 μF capacitor or a short to ground depending on the dc source resistance on the driven input.

Figure2: Input Amplifier and Filter

The condenser microphone is biased using a resistor (R1) and the DC component blocked by a capacitor (C1).The variable resistor RV1 serves for volume control. While variable resistor placed in series with capacitor C2 serves for gain control of the amplifier. Maximum amplifier gain of 200 may be obtained by setting the variable resistor RV2 value to 0.The amplifier section is followed by a voltage level-shifter and an anti-aliasing filter. The anti-aliasing filter is a simple single-stage RC filter comprising R1 and C3.R4 protects the amplifier from any damage if the output is short-circuited. Different sub-circuits of the input amplifier and filter section are marked in the Figure 2 above.

Speech Generation through PWM

Pulse Width Modulation (PWM) modules, which produces basically digital waveforms, can be used as cheap Digital-to-Analog (D/A) converters with only a few external components. A wide variety of micro-controller applications exist that need analog output but do not require high resolution D/A converters. Some speech applications (talk back units, speech synthesis systems in toys, etc.) also do not require high resolution D/A converters. For these applications, Pulse Width Modulated outputs may be converted to analog outputs. Conversion of PWM signals to analog waveforms involves the use of low-pass filters.

Speech signal is generated from the recorded speech samples by Pulse Width Modulation. The width of the PWM output signal is proportional to the amplitude of the speech sample. The PWM output signal proportional to the amplitude of the speech sample is generated by operating the Timer1/Counter1 of the ATmega835 in Phase Correct PWM mode. In a typical PWM signal, the base frequency is fixed, but the pulse width is a variable. The pulse width is directly proportional to the amplitude of the original un-modulated signal. In other words, in a PWM signal, the frequency of the waveform is a constant while the duty cycle varies (from 0% to 100%) according to the amplitude of the original signal. A typical PWM signal is shown in Figure 2.

Figure 3: A Typical PWM Waveform

A Fourier analysis of a typical PWM signal (such as the one depicted in Figure 3) shows that there is a strong peak at frequency Fn = 1/T. Other strong harmonics also exist at F = K/T, where K is an integer. These peaks are unwanted noise and should be eliminated. This requires that the PWM signal be low-pass filtered

To generate PWM signal from speech samples, for playback of recorded speech, PWM module of ATmega8535 has been utilized in Phase Correct 8-bit mode (or mode1).The phase correct PWM mode is based on a dual-slope operation. This mode provides a high resolution phase correct PWM waveform generation option. For the PWM, 16-bit Timer/Counter1 is used with PWM output on OC1B pin. To compare value with Timer/Counter1 TCNT1 count value, compare register OCR1B has been used, which is loaded with the speech sample to be compared with TCNT1 either in down counting or up counting of TCNT1.Initially the output compare register OCR1B is loaded with 0 as soon as the Timer/Counter1 overflows the output compare register OCR1B is loaded with the speech sample. Depending on the mode of operation used, the counter is cleared, incremented, or decremented at each timer clock (clkT1).The clkT1 has been generated from an internal clock source without pre-scaling by configuring the Timer/Counter Control Register B (TCCR1B).The timing sequence of the Timer/Counter1 is determined by setting the Waveform Generation Mode bits (WGM13:0) located in the Timer/Counter Control Registers A and B (TCCR1A and TCCR1B). For running PWM at the highest possible frequency, the PWM clock divider is set to 1.In this article Waveform Generation Mode1 has been chosen at the highest possible frequency.

The counter counts repeatedly from BOTTOM (0x0000) to TOP (0x00FF) and then from TOP to BOTTOM. In non-inverting Compare Output mode, the Output Compare (OC1A/ OC1B) is cleared on the Compare Match between TCNT1 and OCR1A/OCR1B while up-counting and set on the Compare Match while down counting. In inverting Output Compare mode, the operation is inverted. The PWM resolution for the phase correct PWM mode has been fixed to 8-bit.The PWM resolution can be calculated in bits by using the following formula:

RPCPW = (log (TOP+1)) ∕ Iog(2)

In phase correct PWM mode implemented in this article, the counter is incremented until the counter value matches the fixed value 0x00FF, which is actually the TOP value. When the counter has reached the TOP it changes the count direction. The TCNT1 value will be equal to TOP for one timer clock cycle. The Timer/Counter Overflow Flag (TOV1) is set each time the counter reaches BOTTOM. The interrupt flags can be used to generate an interrupt each time the counter reaches the TOP or BOTTOM value. The OCR1B register, used for comparing value with TCNT1 value, is updated every time with speech sample amplitude value, whenever the timer/counter1 overflow interrupt occurs.

In this article, the compare units,while operating in phase correct PWM mode allow generation of PWM waveform on OC1B pin. Also non-inverted PWM has been generated by setting the corresponding configuration registers. The PWM waveform is generated by clearing the OC1B Register at the Compare Match between OCR1B and TCNT1 when the counter increments, and setting the OC1B Register at Compare Match between OCR1B and TCNT1 when the counter decrements. The PWM frequency for the output when using phase-correct PWM can be calculated by the following equation:

fOCnxPCPWM = (fClk_I/O) ∕ (2.N.TOP)

The “N” variable represents the pre-scalar divider (which has been chosen to be 1).

The Output Filter

The output filter section consists of a 5^th order, low pass Chebychev filter and a unary-gain amplifier. The filter is made up by two stagger-tuned, second-order Chebychev filters ( R6, R7, R8, C7, C8 and R8,R9,R10,C9,C10) and a passive first-order filter (R10,C11).The cut-off frequencies of these three filters are slightly shifted against each other (“staggered”) to limit pass-band ripple of the whole filter circuit. The overall cut-off frequency is set to 4000 Hz, which is roughly one-quarter of the PWM frequency (15,686 Hz). This ensures that almost the entire audio spectrum is passed through, but the PWM carrier (at 15,686 Hz) is cut off. This filter has been designed using Circuit Wizard of NI Multisim 11.0 Software by National Instruments. The unary-gain prevents the circuit from getting feedback from the output. The capacitor C12 ,shown in Figure5 blocks any DC component to the speaker.

Figure 4: Output Filter

The filter and amplifier circuits are based on Operational Amplifier (OpAmp) LM324, which is being operated by single power supply of +5V; instead of utilizing dual power supply. This saves from the trouble of provision for dual power supply to operate OpAmps like 741.

Power Amplifier

The power amplifier is a low-power design. This design is based on the LM386 monolithic power amplifier IC from National Semiconductor. This chip is capable of delivering 1W of output power.

Figure 5: Power Amplifier

It is a high-efficiency power amplifier, which is ideal for battery operated applications. The variable resistor RV3 shown in Figure 5 above serves for volume control. The effects of speaker impedance are canceled by the Zobel network connected on the output side of LM386 power amplifier.

The speaker connected with this system is 0.5W and 8 Ohm speaker. This amplifier can easily operate this speaker to play the sound generated by micro-controller using PWM.

Analysis of Code and Algorithm

The primary focus of this article is speech generation using PWM, analog filters and amplifiers. Since speech may also be played back real-time simultaneously while the A/D converted samples are being taken from the analog input signal. Therefore, to keep the discussion simple and to the point, the analysis of code and algorithm is based only on Analog-to-digital conversion of input analog speech signal and simultaneous playback of the digital samples, without storing them in flash memory, through Pulse Width Modulation (PWM).So, in this analysis, the segment of the code that deals with recording of A/D converted speech samples on MMC would not be discussed, although this segment of the code has also been implemented.

Therefore, to perform the above mentioned operations, analog-to-digital converted speech samples are taken by the built-in ADC of ATmega8535 and simultaneously played back through PWM when a push-button (Play button) switch is pressed. The delay in play back of the digital speech samples taken from input analog speech signal is too small to be detected by human ear. The flow chart of this Algorithm is shown in the Figure 6.

The software that runs on the 8535 MCU is written in C. It is designed for the ImageCraft C compiler for the AVR. It is interrupt driven, and makes use of the MCU's inbuilt timers to provide the sampling rate clock. Thus, a stable sampling frequency is produced. All operations of the software are based on this interrupts.

The following steps are performed in this program code represented by Figure6:

1. Initialization of PORTs

a. Lower nibble of PORTC is initialized as output for interfacing with LEDs.

b. Pin 7 of PORTA is configured for ADC input data.

c. Pin 4 of PORTD is configured for PWM output data.

d. PORTB pin0 is initialized as input to read the play button connected to it.

2. Timer1 is initialized in 8-bit Phase Correct PWM Mode and set to overflow approximately at a frequency of approximately 16 KHz (Actual value is 15,686 Hz).

3. Timer0 is initialized to generate an overflow interrupt after every 25msec approximately.

4. ADC is in initialized and configured to scan ADC sample from input i.e., analog speech signal, upon overflow interrupt of timer1.The ADC data storage variable adc_high is initially set to 0.ADC generates 10 bit sample but only 8-bit sample is saved. The lower byte of ADC data register (ADCL), containg only two bits, is assigned to the unsigned variable adc_low i.e. adc_low = ADCL, which is discarded. The higher byte of ADC data register (ADCH) is assigned to the unsigned variable adc_high i.e. adc_high=ADCH, which is used for speech recording and speech generation.

Figure 6 : Algorithm Flow Chart

5. In the main function the status of play button is continuously monitored if the play button is pressed then PWM Output driver is enabled otherwise PWM Output driver is disabled. The interrupts are awaited while monitoring the status of the input button.

6. Interrupts are serviced on the basis of interrupt priority levels as below:

a. Timer1 Overflow Interrupt has the highest priority. This interrupt may interrupt any other interrupt of lower priority in this code being serviced. Whenever this interrupt occur the PWM data compare register (OCR1B) is updated with the current value of variable adc_high defined to hold the current value of Analog-to-Digital converted sample.

b. Timer0 Overflow Interrupt has the second highest priority. Whenever this interrupt occur the lower nibble of the PORTC connected with LEDs toggles state.

c. Analog-to-Digital conversion complete Interrupt has the lowest priority. Whenever this interrupt occur the value of adc_high variable is updated with value of the currently obtained Analog-to-digital converted sample.

7. The program control goes to step 5.The steps from 5 to 6 are repeated again and again until the microcontroller is powered off.

Conclusion

The speech generated by PWM module of this system is reasonably good in quality though not of very fine quality. Much finer quality of speech may be generated through PWM if better quality output filters are designed for converting PWM signal to speech signal played back through speaker.

Audio Amplifiers for Interfacing with Micro-controller

2011-01-12T21:18:00.000+05:00

I have used the following two audio amplifier circuits in my projects for speech recording using AVR micro-controllers :

Audio Amplifier circuit based on LM324
Audio Amplifier circuit based on LM386

A brief description of these audio amplifier circuits is given below:

1. Audio Amplifier based on LM324

This circuit is based on Operational Amplifier (OpAmp) IC LM324.The LM324 series are low−cost, quad operational amplifiers with true differential inputs. They have several distinct advantages over standard operational amplifier types in single supply applications.

Figure 1 : Audio Amplifier based on LM324

The quad amplifier can operate at supply voltages as low as 3.0 V or as high as 32 V with quiescent currents about one−fifth of those associated with the MC1741 (on a per amplifier basis). The common mode input range includes the negative supply, thereby eliminating the necessity for external biasing components in many applications. The output voltage range also includes the negative power supply voltage.

The condenser microphone is biased using a fixed resistor and the DC component blocked by a capacitor. The microphone amplifier and filter is implemented using an inverting op-amp amplifier configured for a high gain. The gain is, again, adjustable. The filter is a simple single-stage RC filter. The capacitor in the feedback loop introduces a roll-off at high frequencies, giving better stability since the gain is very high.

2. Audio Amplifier based on LM386

This circuit is based on Power Amplifier LM386.There are four sub-sections of audio amplifier section. These sub-sections of the audio amplifier section are marked as a, b, c and d in Figure 2.

Figure 2 : Audio Amplifier based on LM386

The LM386 has been used as an input amplifier. The LM386 is a power amplifier designed for use in low voltage consumer applications. The gain is internally set to 20 to keep external part count low. Pins 1 and 8 serve for gain control. With pins 1 and 8 open, the 1.35 kW resistor sets the gain at 20 (26 dB). If a capacitor is put from pin 1 to 8, bypassing the 1.35 kW resistor, the gain will go up to 200 (46 dB). If a resistor is placed in series with the capacitor, the gain can be set to any value from 20 to 200.The inputs are ground referenced while the output automatically biases to one-half the supply voltage. The quiescent power drain is only 24 mill watts when operating from a 6 volt supply, making the LM386 ideal for battery operation.

When using the LM386 with higher gains (bypassing the 1.35 kW resistor between pins 1 and 8) it is necessary to bypass the unused input, preventing degradation of gain and possible instabilities. This is done with a 0.1μF capacitor or a short to ground depending on the dc source resistance on the driven input.

The condenser microphone is biased using a resistor (R1) and the DC component blocked by a capacitor (C1). The amplifier section is followed by a voltage level-shifter and an anti-aliasing filter. The anti-aliasing filter is a simple single-stage RC filter comprising R4 and C3.R4 protects the amplifier from any damage if the output is short-circuited. Different sub-circuits of the input amplifier and filter section are marked in the Figure 2 above.

ADAPTIVE DIFFERENTIAL PULSE CODE MODULATION (ADPCM) USING AVR MICRCONTROLLER

2011-01-10T20:59:00.007+05:00

Abstract

Efficient and simplified speech processing algorithms like Adaptive Differential Pulse Code Modulation (ADPCM) and enhanced features of micro-controllers have made it possible to add sophisticated and complex speech processing capabilities to any 8-bit AVR micro-controller.This application note discusses the ADPCM compression and decompression algorithms, its performance and practical implementation using an 8-bit AVR micro-controller (ATmega8535).

Key words: Step Size, Quantization, Adaptive Quantization, Inverse Quantizer, ADPCM.

Introduction

Analysis of speech samples, obtained from analog to digital conversion process, reveals that a high correlation is found between consecutive speech samples. The ADPCM algorithm takes advantage of this high correlation property of speech data. This algorithm does not encode the actual speech samples. This algorithm actually encodes the difference between a predicted speech sample and the actual speech sample. This speech encoding provides an efficient compression with a significant reduction in the number of bits per sample. The quality of speech signal is also significantly preserved by this speech processing algorithm. The practical implementation of ADPCM algorithm discussed in this application note is based upon Interactive Multimedia Associations (IMA) recommended practices for enhancing digital audio capability in multimedia systems revision 3.00. The IMA ADPCM Reference algorithm, upon which this article is based, has significantly reduced the mathematical complexity of the original International Telecommunication Union (ITU) Family G.721 ADPCM algorithm by simplifying many operations and using the look up tables where appropriate. The IMA, the Digital Audio Technical Working Group, is a trade association which includes technical representatives from different companies like CompaqÒ, Apple ComputerÒ, Hewlett-PackardÒ, IntelÒ, MicrosoftÒ, SonyÒ, and Texas InstrumentsÒ  to name a few. This association is working towards developing standards for high quality audio data exchange between computing machines. The speech compression and decompression algorithms discussed in this article were implemented by Rodger Richey of Microchip Technology Inc. on 8-bit PIC microcontroller. The algorithms and idea has been taken from an article by Rodger Richey of Microchip Technology Inc. Unlike Rodger Richey’s article this article discusses implementation of Speech compression algorithm on 8-bit AVR microcontroller, while decompression algorithm is implemented in Turbo C on PC side.

Compression

The input signal s_i to the speech encoder is supposed to be the 16-bit 2’s complement speech sample. For a 16-bit speech sample the range of available values is -32768 to +32767.Fig.1 shows the block diagram for ADPCM compression algorithm. For the next iteration of the encoder, the predicted sample s_p and the quantizer step size index are saved in a structure. For this iterative process, the quantization step size index and the predicted sample s_pare initially set to zero. The input s_i to the speech encoder is supposed to be a 16-bit 2’s complement speech sample, while the value returned by the speech encoder is an 8-bit number which contains the 4-bit sign magnitude ADPCM code.

The difference d is produced by subtracting the predicted sample s_p from the input signal s_i. The 4-bit ADPCM value t is obtained by performing adaptive quantization on the difference obtained in the previous step. Using that ADPCM value the encoder and decoder update their internal

Figure 1: ADPCM Encoder Block diagram

variables. The encoder actually contains a full decoder embedded inside it. This ensures synchronization between encoder and decoder without requiring any additional data. The dotted lines shown in Fig.1 show the block comprising the embedded decoder. The ADPCM value is used by the embedded decoder to update the inverse quantizer, which in turn produces a dequantized version d_q of the difference d. To simplify the speech compression process a fixed predictor has been used instead of an adaptive predictor, which significantly reduces the amount of data memory and instruction cycles required. A weighted average of the last six dequantized difference values and the last two predicted values are used by the adaptive predictor of ITU G.721 for its adjustment and updating according to the value of each input sample. At this point, new predicted sample s_r is obtained by adding the dequantized difference d_q to the predicted sample s_p. Finally, the new predicted sample s_r is saved in s_p.

Algorithm 1 is a step-by-step description of the ADPCMEncoder function.

Algorithm 1: ADPCM Encoder Algorithm Step-by-step [6]

ADPCMEncoder takes a 16-bit signed number (Speech sample,-32768 to +32767) returns an 8-bit number containing the 4-bit ADPCM Code(0-15).
Restore the previous values of the predicted sample (s_p) and the quantizer step size index.Find the quantizer step size (q) from a lookup table using the quantizer step size index.
Compute the difference(d) between the actual sample (s_i) and the predicted sample (s_p).
Set the sign bit of the ADPCM code(t) if necessary and find the absolute value of difference(d).
Save quantizer step size(q) in a temporary variable.
Quantize the difference(d) into the ADPCM code(t)using the quantizer step size(q).
Inverse quantize the ADPCM code (t) into a predicted difference (d_q) using the quantizer step size (q).
Fixed predictor computes new predicted sample(s_r) by adding the old predicted sample (s_p) to the predicted difference(d_q).
Check for overflow of the new predicted sample (s_r). s_r, which is a signed 16-bit sample, must be in the range of -32768 to +32767.
Find the new quantizer step size(q) by adding the previous index and a look up table using the ADPCM code (t ).
Check for overflow of the new quantizer step size index.
Save the new predicted sample (s_r) and quantizer step size index for next iteration.
Return the ADPCM code (t).

This function requires five 16 bit variables and two 8-bit variables. Some optimizations can be made in this code by combining steps 7 and 8.

Decompression

The input to the speech decoder is supposed to be an 8-bit number containing the 4-bit ADPCM data in sign magnitude format. The allowable values for t range from 0 to 15, where 7 = 0x07 and -7 = 0x0F.The block diagram of the ADPCM decompression is shown in Figure 2.For the next iteration of the decoder, the predicted sample value s_p and the quantizer step size index are saved in a structure. The quantizer step size index and the predicted sample (s_p) are initially set to zero. A 4-bit sign magnitude ADPCM code is fed as an input to the ADPCMDecoder() function, which in turn produces a 16-bit 2’s complement speech sample. The decoder is same as the one used by the encoder routine. For updating the inverse quantizer it uses the ADPCM value, which in turn produces the difference d_q. The output sample s_r is produced by adding the difference d_q to the predicted sample s_p. For next iteration of the decoder the output sample s_r is saved into the predicted sample.

Figure 2: ADPCM Decoder Block Diagram

The Function ADPCMDecoder function is listed in Algorithm 2.

Algorithm 2: ADPCM Decoder Algorithm Step-by-step [6]

ADPCMDencoder takes an 8-bit signed number containing the 4-bit ADPCM Code (0-15) and returns a 16-bit signed number (Speech Sample,-32768 to +32767).
Restore the previous values of the predicted sample (s_p) and the quantizer step size index.
Find the quantizer step size (q) from a lookup table using the quantizer step size index..
Inverse quantize the ADPCM code (t) into a predicted difference (d_q) using the quantizer step size (q).
Fixed predictor computes new predicted sample (s_r) by adding the old predicted sample (s_p) to the predicted difference (d_q).
Check for overflow of the new predicted sample (s_r).s_r, which is a signed 16-bit sample, must be in the range of -32768 to +32767.
Find the new quantizer step size (q) by adding the previous index and a lookup table using the ADPCM code (t).
Check for overflow of the new quantizer step size index.
Save the new predicted sample (s_r) and quantizer step size index for next iteration.
Return the new sample (s_r).

This function requires three 16-bit variables and one 8-bit variable.

Performance

In this application note we have used AVR ATmega8535 microcontroller. The ATmega8535 is a low-power CMOS 8-bit microcontroller based on the AVR enhanced RISC architecture. By executing instructions in a single clock cycle, the ATmega8535 achieves throughputs approaching 1 MIPS per MHz allowing the system designer to optimize power consumption versus processing speed .The external oscillator frequency that we have chosen is 7.3728 MHz. This oscillator generates a baud rate for serial communication with PC with very little error in baud rate. The sampling rate chosen for Analog-to-Digital Conversion process is 8 kHz per sample. With this sampling rate the microcontroller has a time span of 125 µs seconds between two consecutive samples taken from ADC. So during this time span of 125 µs, considering the maximum code size, the microcontroller is not only required to compress and pack two speech data samples but also it has to transmit the compressed speech samples to the PC through serial port. The maximum instruction cycles taken by all the routines, including speech compression (281 instruction cycles), packing two compressed speech data sample in a single byte (5 instruction cycles), ISR for Timer0 over flow (5 instruction cycles), ISR for ADC (105 instruction cycles) and ISR for serial communication (40 instruction cycles) are approximately 473 instruction cycles.

Considering single-clock cycle execution per instruction and 7.3728 MHz operating frequency, it may be noted that single instruction cycle takes 0.1356µs and 473 instruction cycles would take approximately 64.1547 µs. A single instruction cycle for AVR 8535 takes one clock cycle of external oscillator, this external oscillator frequency not only generates a good error free baud rate for serial communication with PC, but it is also more than sufficient for implementing ADPCM speech compression algorithm.

Application

The hardware for this application note implements only the compression algorithm, while the decompression algorithm is implemented in PC using Turbo C.

In order to implement the audio recording, the following components need to be added to the application hardware:

A microphone with anti-aliasing filter
Amplifier with adjustable gain
Built-in A/D converter and Timer of AVR 8535 micro-controller

The conversion time for this application has been chosen to be 52µs.The sampling rate used by A/D converter is 8 kHz which takes input sample every 125µs. In this way the effective bandwidth of the input speech data is 4 kHz which is sufficient enough for human speech recording. The compiler used for this data compression and decompression application is ICC AVR version 7.14. For simulation of the speech compression code AVR Studio4 has been used. AVR Studio is an Integrated Development Environment (IDE) for writing and debugging AVR applications in Windows.

The audio data is fed as input to the built-in ADC of the AVR micro-controller from microphone after filtering and amplification. The micro-controller generates the digital samples from analog audio input through Analog-to-Digital conversion process and then compresses the speech samples and then serially transmits the two compressed speech samples per byte. The speech data is recorded on PC in a binary file through Hyper Terminal. The binary file is used by the ADPCM speech decompression algorithm implemented in Turbo C. A Program written in Visual C++ is used on the PC side for converting the recorded and decompressed speech data to audio file.

Conclusion

The final results of the application hardware using the ATmega8535 are:

· Compression

The ADPCM compression routine compresses 10 bits of uncompressed data sample to 4 bits of compressed data. This ADPCM compression routine actually takes 16 bit input and generates a 4-bit ADPCM code. In this way, it gives almost 60% compression of single input speech sample.
281 instruction cycles to encode single data sample to ADPCM compressed sample.
Upon compiling the compression code in ICCAVR7.14 compiler, the compiler shows the device to be 15% full.

· Decompression

It has been implemented on PC using Turbo C which receives compressed data bytes through serial port decompress the received data and write the decompressed data in binary File.
Visual C++ program is used for transforming binary file to wave file
Baud Rate used for receiving data at serial port is 115200 Bps
Data format used for serial communication is: 8bits per sample, 1 start bit, 1 stop bit & no parity.

References:

1. Recommended Practices for Enhancing Digital Audio Compatibility in Multimedia Systems, Revision 3.00, Interactive Multimedia Association, October 21, 1992.

2. Digital Audio Special Edition Proceedings, Volume 2, Issue 2, Interactive Multimedia Association, May 1992.

3. Panos E. Papamichalis Ph.D., Practical Approaches to Speech Coding, Prentice-Hall Inc.,Englewood Cliffs, N.J, 1987.

4. Adaptive Differential Pulse-Code Modulation, Digital Signal Processing Applications using the ADSP-2100 Family, Volume 1, Analog Devices, Prentice-Hall, Englewood Cliffs, N.J., 1992.

5. 32-kbits/s ADPCM with the TMS32010, Digital Signal Processing Applications with the TMS320 Family, SPRA012, Jay Reimer, Mike McMahan, and Masud Arjmand, Texas Instruments , 1986.

6. Adaptive Differential Pulse Code Modulation using PICmicro™ Microcontrollers, by Rodger Richy Microchip Technology Inc.

7. Data sheet of ATmega8535 from website of Atmel (www.atmel.com)

C-Codes

1. The C-Code for ADPCM Speech Compression developed in Image Craft Compiler for AVR written for ATmega8535,is given below :

//**********************************************//
// ICC-AVR application builder : 1/21/2007 12:37:44 AM
// Target : M8535
// Crystal: 8.0000Mhz
// Crystal: 7.3728Mhz
//
//
#include<iom8535v.h>
#include<macros.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"pcadpcm.h"

/***********************************************/

unsigned char adc_low, adc_high;
unsigned int timer0_counter=0;
unsigned int adc_counter=2;
unsigned int uart0_counter=0;

void USART_Transmit(void);
short sample;
unsigned int flag00=0,flag01=0;
//unsigned char data00=0,data01=0;
unsigned short data,data00=0,data01=0;

unsigned char code;

/********** Table of index changes *********/
signed char IndexTable[16] = {
                                            -1, -1, -1, -1, 2, 4, 6, 8,
                                              -1, -1, -1, -1, 2, 4, 6, 8,
                                    };

/*** Quantizer step size lookup table ***/
int StepSizeTable[89] = {
                                      7, 8, 9, 10, 11, 12, 13,
                                        14, 16, 17, 19, 21, 23,
                                        25, 28, 31, 34, 37, 41,
                                        45,50, 55,60,66,73, 80,
                                        88,97,107,118,130,143,
                                        157, 173, 190, 209,230,
                                        253, 279, 307,337, 371,
                                        408, 449, 494, 544, 598,
                                        658, 724, 796,876, 963,
                                        1060, 1166, 1282,1411,
                                        1552, 1707, 1878, 2066,
                                        2272, 2499, 2749,3024,
                                        3327, 3660, 4026, 4428,
                                        4871, 5358,5894, 6484,
                                        7132, 7845, 8630, 9493,
                                        10442,11487,12635,13899,
                                        15289,16818,18500,20350,
                                        22385,24623,27086,29794,
                                        32767
                            };

/************************************//
//********** Port initialisation **********//
/***********************************//

void port_init(void)
{

     PORTA = 0x80;
     DDRA   = 0x00;
     PORTB = 0x00;
     DDRB   = 0x00;
     PORTC = 0x00;
    DDRC   = 0x90;
     PORTD = 0x00;
     DDRD   = 0x80;

}
//////////////////////////////////////////////////////////////////
/****** uart initialization **********/
/////////////////////////////////////////////////////////////////
//
// UART0 initialize
// desired baud rate: 115200

void uart0_init(unsigned int baud)
{
     UCSRB = 0x00; //disable while setting baud rate
     UCSRA = 0x00;
     /* Set baud rate */
     UBRRH = (unsigned char)(baud>>8);
      UBRRL = (unsigned char)baud;
     /* Enable Receiver and Transmitter */
     UCSRB = (1<<RXEN)|(1<<TXEN);
      /* Set frame format: 8data, 2 stop bit */
      /* Set frame format: 8data, 1 stop bit */
     UCSRC = (1<<URSEL)|(3<<UCSZ0);
}

//////////////////////////////////////////////////////////////
//
// TIMER0 initialize - prescale:8
// WGM: Normal
// desired value: 8KHz
// actual value: 8.000KHz (0.0%)
//

void timer0_init(void)
{

     TCCR0 = 0x00; //stop
     TCNT0 = 0x8d; //set count
     //OCR0 = 0x7D; //set compare
     TCCR0 = 0x02; //start timer

}
///////////////////////////////////////////////////////////////////////
// For 8 kHz sampling rate,the timer needs to
// overflow after every 125 micro secs intervals.
// Every Timer overflow after 125 us triggers the
// ADC to take sample.ADC produces 10 bit digital
// sample out of which lower 2 bits are discarded
//

#pragma interrupt_handler timer0_ovf_isr:10
void timer0_ovf_isr(void)
{
   TCNT0 = 0x8d; //reload counter value

     //TIMER0 has overflowed
     /****************************/

     //USART_Transmit(adc_high);
     timer0_counter++;//
       if(timer0_counter == 250)
       {
        PORTD^=0x80;
            timer0_counter=0;
       }

}

////////////////////////////////////////////////////////////
// ADC initialize
// Conversion time: 52uS
//////////////////////////////////////////////////////////

void adc_init(void)
{

     ADCSRA = 0x00; //disable adc
     ACSR = 0x80;
      ADMUX = (1<<REFS0)|(1<<ADLAR)|0x07;
      //select adc input 7, AVCC
      SFIOR = (SFIOR&0X0F)|(1<<ADTS2);
     //select Timer0 Over flow Trig
     ADCSRA = (1<<ADEN)|(1<<ADATE)|(1<<ADIE)
                         |(1<<ADPS1)|(1<<ADIF);

     adc_high=0;

}

#pragma interrupt_handler adc_isr:15
void adc_isr(void)
{

    //conversion complete
     adc_low=ADCL;
     //Read 2 low bits first (important)
     adc_high=ADCH;
     //read 8 high bits and shift into top byte

    data= adc_high ;
    data=data<<8;

    data = ( data & 0xFF00 )+
                ( adc_low & 0xC0 );

    //PORTB^=0x01;

     if(adc_counter%2==0)
     {
           //data00=adc_high;
             data00=data;
           flag00=1;
     }
    if(adc_counter%2!=0)
     {

            //data01=adc_high;
             data01=data;
           flag01=1;

          }

    adc_counter++;//

}

////////////////////////////////////////////////////////////////

#pragma interrupt_handler
               uart0_udre_isr:13
void uart0_udre_isr(void)
{

     //character transferred to shift register
     //so UDR is now empty
    //UDR=adc_high;
     UDR=code;
    // USART I/O Data Register –UDR
     UCSRB = (1<<RXEN)|(1<<TXEN);

    uart0_counter++;//

}

/////////////////////////////////////////////////////////////////////////

// this function is not used
void USART_Transmit()
// the argument data seems to be surplus
// in this code
{

//UCSRB = 0x38;

   /* Wait for empty transmit buffer */
   while ( !( UCSRA & (1<<UDRE)) );

   /* Put data into buffer, sends the data */
   //UDR = data;
   // variable data now seems to be surplus

}

/*********************************/

unsigned char USART_Receive( void )
{
     /* Wait for data to be received */
    while ( !(UCSRA & (1<<RXC)) )
    ;
    /* Get and return received data
    from buffer */
    return UDR;
}

/***********************************/

//call this routine to initialize all peripherals
void init_devices(void)
{
     unsigned int baud=3;//baud rate=115200 bps
     //stop errant interrupts until set up
     CLI(); //disable all interrupts
     port_init();
     adc_init();
     //timer1_init();
     timer0_init();
     uart0_init(baud);
     MCUCR = 0x00;
     GICR = 0x00;
      TIMSK = (1<<TOIE0);
      //timer interrupt sources-timer0
     SEI(); //re-enable interrupts
     //all peripherals are now initialized
}
//
void main(void)
{

    struct ADPCMstate state;
      // This structure is defined in header
      // file pcadpcm.h
     state.prevsample=0;
      // Initially previous sample and previous
     state.previndex=0;
      // index both are taken as 0

     init_devices();

     //insert your functional code here...
     while(1)
     {

        if(flag00==1)
        {
              PORTB^=0x02;
            //sample=(data00-128)<<8; //
           sample=(data00-128); //
           flag00=0;
           code=ADPCMEncoder(sample,&state);
           code= (code<<4) & 0xf0;
        }

        else if(flag01==1)
        {
              //PORTB^=0x04;
            //sample = (data01-128)<<8; //
           sample = (data01-128); //
           flag01=0;
           code|= ADPCMEncoder(sample,&state)
                       & 0x0f;

           UCSRB = 0x38;

         }

    }//while(1)
}

//****************************************//
//** ADPCMEncoder - ADPCM encoder routine **//
//***************************************//
//* Input variables: *
//* short sample - 16-bit signed speech sample *
//* struct ADPCMstate *state - ADPCM structure *
//* Return variables: *
//* char - 8-bit number containing the 4-bit
// ADPCM code *
//**************************************//

char ADPCMEncoder( short sample , struct ADPCMstate *state )
{

    int code;/* ADPCM output value */
    int diff;/* Difference between sample and
    the predicted sample */
    int step;/* Quantizer step size */
    int predsample;/* Output of ADPCM predictor */
    int diffq;/* Dequantized predicted difference */
    int index;/* Index into step size table */
    /* Restore previous values of predicted sample and
   quantizer step size index */
    predsample = (int)(state->prevsample);
    // Restore the previous values of predicted
   // sample (sp)
    index = state->previndex;
    // & the quantizer step size index   (which are
    // initially taken to be 0 )
    step = StepSizeTable[index];
    /* Find the quantizer step size (q) from a table lookup
     using the quantizer step size index*/
    /* Compute the difference (d) between the acutal sample
    (sample si) and the predicted sample (predsample sp) */
    diff = sample - predsample;

    if(diff >= 0)
       // Set the sign bit of ADPCM code (t) if necessary
       // & find the absolute value of difference (d)
       code = 0;
    else
    {
       code = 8;
       diff = -diff;
    }
    /* Quantize the difference into the 4-bit ADPCM code
    using the quantizer step size    */
    /* Inverse quantize the ADPCM code into a predicted
    difference using the quantizer step size */
    diffq = step >> 3;
    if( diff >= step )
    {
        code |= 4;
        diff -= step;
        diffq += step;
    }
    step >>= 1;
    if( diff >= step )
    {
        code |= 2;
        diff -= step;
        diffq += step;
    }
    step >>= 1;
    if( diff >= step )
    {
        code |= 1;
        diffq += step;
    }
    /* Fixed predictor computes new predicted sample by
    adding the old predicted sample to predicted difference*/
    if( code & 8 )
        predsample -= diffq;
    else
        predsample += diffq;
    /* Check for overflow of the new predicted sample*/
    if( predsample > 32766 )
        predsample = 32767;
    else if( predsample < -32767 )
        predsample = -32767;
    /* Find new quantizer stepsize index by adding the
    old index to a table lookup using the ADPCM code*/
    index += IndexTable[code];
    /* Check for overflow of the new quantizer
    step size index*/
    if( index < 0 )
        index = 0;
    if( index > 88 )
        index = 88;
    /* Save the predicted sample and quantizer step
    size index for next iteration*/
    state->prevsample = (short)predsample;
    state->previndex = index;
    /* Return the new ADPCM code*/
    return ( code & 0x0f );

}

2. The header file "pcadpcm.h is given below":

/***************************************
* This header file contains the ADPCM structure *
* definition and the function prototypes. *
***************************************/
struct ADPCMstate {
short prevsample;/* Predicted sample */
int previndex;/* Index into step size table */
};
/* Function prototype for the ADPCM Encoder routine */
char ADPCMEncoder(short , struct ADPCMstate *);
/* Function prototype for the ADPCM Decoder routine */
int ADPCMDecoder(char , struct ADPCMstate *);

3. The C code implemented in TuboC for decoding the compressed and encoded speech data recorded on PC by interfacing serial port of PC with micro-controller is given below:

#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<dos.h>
#include <stdlib.h>
#include "pcadpcm.h"

//////////////////////////////////////////////////////////////////////////////

/* Table of index changes */
signed char IndexTable[16] = {
-1, -1, -1, -1, 2, 4, 6, 8,
-1, -1, -1, -1, 2, 4, 6, 8,
};
/* Quantizer step size lookup table */
int StepSizeTable[89] = {
7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
19, 21, 23, 25, 28, 31, 34, 37, 41,
45,50, 55, 60, 66, 73, 80, 88, 97,
107, 118,130, 143, 157, 173, 190,
209, 230, 253, 279, 307,337, 371,
408, 449, 494, 544, 598, 658, 724,
796,876, 963, 1060, 1166, 1282,
1411, 1552, 1707, 1878, 2066,
2272, 2499, 2749, 3024, 3327,
3660, 4026, 4428, 4871, 5358,
5894, 6484, 7132, 7845, 8630,
9493, 10442, 11487, 12635, 13899,
15289, 16818, 18500, 20350, 22385,
24623, 27086, 29794, 32767
};
//////////////////////////////////////////////////////////////////////////

void main(void)
{

    FILE *fpin,*fpout;
    char ch;
    short sample;
    unsigned char sample8;
    char code;

    struct ADPCMstate state;
    state.prevsample=0;
    state.previndex=0;
    clrscr();

    fpin=fopen("c:\\ee.bin","rb");
    if(fpin==NULL)exit(1);
    fpout=fopen("c:\\ee01.bin","wb");

    //ADPCM Decoder
    printf("ADPCM decoding in progress\n");
    /* Read & unpack input codes and process them */

    while(fread(&code,sizeof(char),1,fpin)==1)
    {

        // Send upper 4-bits of code to decoder
        sample=ADPCMDecoder((code>>4)&0x0f,&state);
        sample8=(unsigned char)((sample>>8)&0xff) + 128;
        fwrite(&sample8,sizeof(char),1,fpout);
        // Send the lower 4-bits of code to decoder
        sample=ADPCMDecoder(code&0x0f,&state);
        //write sample for lower 4-bits of code
        sample8=(unsigned char)((sample>>8)&0xff) + 128;
        fwrite(&sample8,sizeof(char),1,fpout);

    }

    fclose(fpin);
    fclose(fpout);
    //getch();

}

/************************************************
* ADPCMDecoder - ADPCM decoder routine *
*************************************************
* Input variables: *
* char code - 8-bit number containing the 4-bit ADPCM code *
* struct ADPCMstate *state - ADPCM structure *
* Return variables: *
* int - 16-bit signed speech sample *
**********************************************/
int ADPCMDecoder(char code, struct ADPCMstate *state)
{
    int step;/* Quantizer step size */
    int predsample;/* Output of ADPCM predictor */
    int diffq;/* Dequantized predicted difference */
    int index;/* Index into step size table */
    /* Restore previous values of predicted sample and
   quantizer step size index */
    predsample = (int)(state->prevsample);
    index = state->previndex;
    /* Find quantizer step size from lookup table
    using index*/
    step = StepSizeTable[index];
    /* Inverse quantize the ADPCM code into a difference
    using the quantizer step size */
    diffq = step >> 3;
    if( code & 4 )
    diffq += step;
    if( code & 2 )
    diffq += step >> 1;
    if( code & 1 )
    diffq += step >> 2;
    /* Add the difference to the predicted sample */
    if( code & 8 )
    predsample -= diffq;
    else
    predsample += diffq;
    /* Check for overflow of the new predicted sample */
    if( predsample > 32767 )
    predsample = 32767;
    else if( predsample < -32767 )
    predsample = -32767;
    /* Find new quantizer step size by adding the old
   index and a table lookup using the ADPCM code*/
    index += IndexTable[code];
    /* Check for overflow of the new quantizer step
    size index */
    if( index < 0 )
    index = 0;
    if( index > 88 )
    index = 88;
    /* Save predicted sample and quantizer step size
   index for next iteration */
   state->prevsample = (short)predsample;
   state->previndex = index;
    /* Return the new speech sample */
    return( predsample );}

Things to consider when buying a digital Camera

2011-01-09T23:04:00.002+05:00

Buying a digital camera is not a child's play.It is indeed a difficult purchase to make especially when there are myriads of features and choices available in the digital cameras being sold in the market.If you are new to this area or if you are a first time buyer then you may easily get overwhelmed by the options available in this regard.So you must do some homework and research to decide upon which digital camera is appropriate for you,lest you should regret after purchasing the camera. Therefore,while buying a digital camera,it is suggested to keep in view the the following points:

How much you can afford?

I think the most important factor which dictates which type of camera you should buy is how much cost you can afford to buy a camera.Obviously,the greater the features and functions a camera is equipped with the higher the cost of camera is supposed to be.Therefore,the only choice you are left with is to make a trade-off between how much price you can afford and how many features you want the camera of your choice to be equipped with.So you should carefully figure out your budget and the features of the camera that are inevitable for you to make this purchase.

Mega-pixels?

The resolution of a digital camera is measure of the quality of the photo images it can produce.The resolution of a digital camera is stated in terms of mega-pixels.So mega-pixels of a digital camera is one of the most important factors that govern the quality of photo images produced by your digital camera.The greater the number of mega-pixels the higher is the resolution of digital camera and obviously the higher is the price of the camera. Only a camera with a higher number of mega-pixels can produce finer quality of photos which can be enlarged and edited without losing image quality.Therefore,here too, you are bound to make a trade-off between the cost and the mega-pixels of camera.The yardstick to decide on the number of mega-pixels of a digital camera, that suits your requirement, is : what is the maximum size of the print that you want to get from the pictures taken with your camera?.If you are interested in print size of about 8x10 or 8x12, then any camera with resolution between 6 to 10 mega-pixels will be sufficient for you. But if you want the print size to be bigger i.e., 12x18 or 12x20 or more, then the minimum number of mega-pixels that your camera should be equipped with is 8 mega-pixels.

Type of Photographer you are

Your photography skills and the type of photographs that you are interested to take with your digital camera is an important factor that you should take into consideration while buying a digital camera.If you are just a amateur or occasional photographer, who likes to take pictures on special occasions only,like parties and get-together, then you do not need a very high resolution camera.In that case any digital camera of some reputed brand,like Canon,Sony or Yashika etc., with resolution ranging from 6 to 10 mega-pixels will be good enough for you. If you are a professionally skilled photographer or a photography enthusiast then any ordinary digital camera will not just do for you. In that case you will need a high quality and high resolution digital camera equipped with advanced features like good optical zoom,face recognition and adjustment for light intensity etc., to capture high resolution and good quality pictures that could be enlarged, edited with software and printed without losing the image quality and resolution.

Image and Video Storage Capacity

I think a good digital camera should be equipped with enough data storage capacity,either built-in or in the form of externally connected memory card,to contain at least a few hundred photo images of high resolution.It is always preferable to have a digital camera equipped with good enough built-in memory as well as a slot for connecting memory card so that data storage capacity of the camera may be enhanced anytime according to your needs.As far as i know,almost all digital cameras available in market come equipped with feature to add additional memory in the form of memory cards.I think this feature is inevitable.

Interface with Computer

No matter how huge is the data storage capacity of your digital camera, ultimately you need to transfer your pictures and videos made by your camera to the computer either for back up or for editing and printing.Therefore your camera must be equipped with the feature to interface with computer either by cable or by blue-tooth connection.

Zooming Feature

Zooming feature of a digital camera is one of the most important factors that greatly affects the quality of pictures taken by the camera,therefore,while buying a digital camera you must take this factor into consideration.Most of the people do not understand the difference between optical zoom and digital zoom.Most of the people think that both optical and digital zoom are the same.This is rather the most commonly misunderstood concepts about the zooming feature of a digital camera.Both of these terms should not be intermingled.In optical zoom lenses of a digital camera move physically to bring the image of a distant object closer to your eyes.Optical zoom is equivalent to physically getting closer to the distant object and viewing the object from a close distance to improve image clarity and quality.while unlike optical zoom in digital zoom the camera simply magnifies the pixels of the captured image to show you a larger image without maintaining the image quality and clarity.So when buying a digital camera you should always pay more attention to optical zoom rather than digital zoom.However,it is recommended the a digital camera should be equipped with features for both good optical zoom and digital zoom.The higher the optical zoom of a digital camera the better the camera is.

Battery Type

The type of batteries your camera operates with and the life of batteries, in terms of number of shots taken with your camera,is an important feature of a digital camera that should never be overlooked.Digital cameras operate with batteries and they suck batteries like a blood sucking vampire.Good quality batteries, especially the type of batteries recommended by the manufacturer, are really expensive.So it always better to have a camera which can operate with rechargeable batteries,so that whenever your camera runs down its batteries they may be recharged instead of buying new ones.Though the initial cost of rechargeable batteries is much higher than that of non-rechargeable batteries and you also need a battery charger but your camera is really worth this investment as you are saved from the trouble of buying new batteries every time your camera runs down its batteries.Two types of rechargeable battery options are available for digital cameras i.e., Lithium-ion and NiMH.Both types of batteries have their own advantages and disadvantages.I personally recommend AA size NiMH rechargeable batteries as they can be easily purchased from anywhere in the world.whenever your batteries go dead and if you do not have AC or Dc power to recharge your batteries and you don't have spare batteries either then in that case you can easily install AA disposable batteries in your camera in place of your rechargeable dead batteries.This is not the case with Li-ion battery pack, which is proprietary.You cannot just substitute AA disposable cells for your Li-Ion battery pack if your battery goes dead in such a situation.

Portability

A digital camera should be light in weight and small in size so that it may easily fit in your jeans pocket and may be easily carried any where for taking pictures.A digital camera should be portable like cell phone.

LCD

LCD stands for Liquid Crystal Display.It is a small display screen located at the back side of your camera.This screen helps you preview the picture being taken with your camera.Also with this screen you can view the pictures and videos already recorded by your camera in its memory.LCD sucks a lot of battery power,therefore, it is suggested that along with LCD the digital camera should also be equipped with good optical view finder so that while taking snap shots dependence on LCD and power consumption of LCD may reduced.

Ease of use

A digital camera should be easy too use so that any casual user may easily operate it without poring over bulky user manuals.For a casual user a portable and easy to operate camera equipped with sophisticated features, like automatic adjustment for light intensity, focus and face recognition etc., which does not require much knowledge and skills in photography, is a suitable option.

These are a few guidelines,discussed above, which may be helpful for a person not much familiar with the art and technology of photography in buying a good point-and-shoot type digital camera.However,if you are a professionally skilled photographer then you need to consider a lot of other features as well.So choice of a digital camera depends solely upon your photography skills and your area of application.

Career Networking for Career Development

2011-01-09T22:48:00.002+05:00

Advancement in teconolgy and modern means of communications have geatly affected our lifestyle.Advanced means of communication like internet ,mobile phones and satellite communication etc., have turned this world into a global village.These days staying connected with your contacts is quite easy.Apart from all this, scoial and career networking communities on the internet like LinkedIn,Facebook and Orkut etc. are also playing a great role in getting people in touch with one another who are living different in parts of the world together.So no one can afford to stay aloof and isolated.To advance in your career and grow your business you must be a part of an active career and social network.

Career networking is a means of maintaining a rich network of contacts comprising those people who are,one way or the other, related with your career and profession.Career networking is a way of using your contacts and the people you know for your own professional growth an advancement in career.It does not mean merely exploiting your contacts for your own personal gains,it is,rather a relationship based upon reciprocity.In other words it is a sort of give-and- take relationship.So you should not only be able to put your contacts ,in your career network, effectively to work for you own career growth but also you should be benefecial to othe people in your career network.

In the past, when there used to be no internet and mobile phones,people mostly used to rely on telephone and postal services for staying in contact with one another.So,it might have been quite difficult to maintain a good network of professional contacts.But now inerent,mobile phones and satellite communication have revolutionasied the means of communication.These days keeping in touch with your contacts is quit easy and just a matter of click of a button.Therefore, we should also benefit from modern means of communication to develop our career.

Career experts and HR professionals greatly emphasize the need to maintain an active and effective social and career network.The reason being that these days there is a growing trend in many reputed companies to hire new employees either through internet or on recommendation of their current employees.Even some companies offer incentives and bonuses to their employees,if new professionals,especially professionally skilled ones with good career profile,get hired on recommendation of their current employees.This approach is not only beneficial to the employees but also it is very useful for the company in terms of financial resources and manpower required for recruiting new employees by advertising new openings in newspapers and then conducting tests and interviews of the candidates, after shortlisting a few candidates from a huge pile of applications that the company might receive against the advertised job openings.Therefore to avoid all these hassles many companies prefer to induct new professionals on recommendation of their current employees and thus many openings in such companies are filled internally without being advertised.In such a case only those people can benefit from such opportunites who have rich and effective network of professional contacts.So in this case career and social networking play a crucial role and thus may be deemed inevitable for career growth.

Irrespective of it, whether you are currently looking for a job or not ,it is always beneficial to have a rich network of porfessional contacts for growing in your career.You may need to switch your job or you want to get a promotion in your job.In such case your effective social and professional contacts can be of great help to you.You should not only have a network of professional contacts well in place but also you should be an active and effective member of your career network.So merely maintaining a professional network is not enough,rather your career network should be active and you should keep in touch with your contacts on regular basis,so that you may seek help from your contacts any time when you need them.

To develop a good professional and social network many professional and social networking websites like Orkut,twitter,LinkedIn,paracalls,facebook etc., exist on the internet that can be of great help in this regard.To begin with you should be a member of some reputed career and social networking websites active on the internet.Search for your class mates,colleagues and friends who are already members of career and social networking websites active on the internet.Also to develop new contacts you should actively participate in social and professional events like seminars,exhibitions,conferences and social gatherings held by your acquaintances.The more professional and social contacts you have the more resourceful you will be.Career and social networking is a stepping stone in making a headway in your career.So get ready to be an active member of an effective and active career network so that you may advance up your career ladder.