Design with Microcontrollers

microSD ATmega32 Data-Logger

2011-05-10T05:29:00.000-07:00

Hi friends,

aim of this project is to present a way to store a large quantity of data into microSD card in files with FAT32 format. Here, ATmega32 is used for data collection and microSD interface. The data is received from in-build 8-channel ADC of ATmega32. One channel is used for reading temperature from LM35 sensor and remaining channels are used for simply reading voltages and storing them.

This project can be used to interface 8 different sensors with ADC of ATmega32, similar to the LM35 used here. The data is stored in CSV (comma separated values) format, which can be read using a PC/Laptop with Microsoft Excel or other compatible software. A snapshot of the excel file is given later in this post.

This project is an example of how to use the microSD FAT32 library presented in my earlier post. In that post, the files were created using hyper-terminal and entering data with the PC keyboard, since that demonstrates the file creation and it's easy to debug. But many users have requested to make the file creation independent of the terminal, done inside the microcontroller, so I'm showing here how to use those functions independent of terminal. If you have directly landed on this page, it would be more helpful if you visit the original post first as it would be a better starting place for learning SD or FAT32 functions.

Here is the schematic (click on the images for larger view or download PDF):

The project contains RTC interface (for date and time storage), RS232 (for connection with PC) and a microSD module. Here, the hyper-terminal connection is required only for setting RTC date and time. Once the date/time are set, the RS232 connection is not required anymore for normal data-logging operation (It can be used for debugging purpose if there is a problem).

The microSD module used here is from eXtreme Electronics.
The module is shown in the figure here. Other than the microSD socket, this low-cost module also contains on-board 3.3v regulator for the microSD card, a 5v-3.3v level converter and other safety features required for the card. This module is used here as it provides a stable interface and makes the the card compatible with 5v supply and 5v signals of microcontroller.

The module is available at: http://store.extremeelectronics.co.in/MicroSD-TF-Module.html

The schematic also shows two LEDs and a push-button. The LEDs are used for indications of power and recording and the push-button is used to start-stop recording.

Operation of the circuit:
-----------------------------------------------
For setting RTC date/time (or for debugging mode):

Connect the microSD module, insert the microSD card
Connect the RS232 cable with the circuit. Set-up hyper terminal with 19200 baud, no parity, 8-bit data, 1 stop-bit and flow-control as 'None'
Connect the power cable and power on the circuit while keeping the push-button pressed
Green LED will glow in the circuit board
A menu will be displayed on the Hyper terminal as shown in the figure below. Select desired option and follow the displayed instructions
When date/time is set or debugging done, select option '0' to come out of the menu and start functioning a s data-logger
At this point, the RS232 cable can be removed

Operation as Data-Logger:

Connect the power cable and power on the circuit
Green LED will glow
Whenever the data-logging is required, press the push-button
Red LED will glow, indicating that the recording has started
To stop recording, press the push-button again, recording will stop and red LED will turn off
Files stored in the card can be read using a PC card-reader or using hyper-terminal with the circuit started in debugging mode

The operation is very simple as it uses just one push-button and an LED indication. In case of any error in accessing the card, red LED will blink continuously. In such a case, you can start circuit in debug mode (with terminal) and see the error messages.

Files are stored with the date as a name and .CSV extension. For example, data-logging done on 10 May 2011 would be stored in "10052011.CSV" file. Since the date is the name of file, everyday a single file is created and all the data recording done in a day goes into single file, no matter how many times the recording is stopped/started. First column of the file shows date, second shows time and next 8 columns show data from the 8 channels.

A file created during testing is shown in the figure below, where 5 sec interval was set for measurements (click on the image to enlarge it). Here channel-0 was used for LM35 temperature sensor, and remaining channels measure voltage. 5v was connected to channel-1 and 3v Li cell was connected to channel-3 (Channel 2 & 4 show some small voltages due to noise from voltages connected to nearby channels, which can be corrected by using bypass caps).

The interval between two measurement cycles is defined in main.c file, which can be set as per the user requirement. Basically, the program forms a dataString in every measurement cycle and appends this string to the file, if the file already exists or it creates a new file (for example, during the first recording in a day). You may go through the comments in the source code file for more info.

Note: Make sure that RTC circuit is properly connected, otherwise the code will simply hang waiting for receiving date & time from RTC

Download project files
--------------------------------------
The source code is written in AVR-GCC format using winAVR with AVRStudio-4, complete AVRStudio project folder can be downloaded from here:

- Download Source Code

Download schematic:
- Schematic (PDF)
- Schematic (EAGLE)

References:
--------------
Visit my earlier post for the references on SD card & FAT32 which are given at the end of the post

microSD FAT32 testing using Visual C++

2010-12-07T21:58:00.000-08:00

Hi friends,

this post presents a way for testing and learning the FAT32 system on microSD/ SDHC cards without building the hardware with microcontroller, thanks to Henry Yiu.

This project uses the FAT32 library available in my previous post, but does away with the microcontroller part. So, you can use this code with a PC and USB card reader and get insight of the FAT32 data structure by accessing data from the card in raw as well as in FAT format.

This code can be used as a confidence building step for those who are not comfortable with directly building the hardware part. Once the FAT is understood, one can go ahead with development of hardware and customization of the software.

This may look like hardcore software thing, but it's not so. It can be tested by anybody with little knowledge of programming and determination to understand the FAT / sd card formats.

Step by step procedure for testing of the code is explained later.

Here are the Henry's words for the project:
-----------------------------------------------------------------------
When trying to build a microcontroller to access an SD card, I came across this web site which details the hardware and software of how to use an Atmel AVR microcontroller to access an SD card. But I wanted to test out the FAT32 file system code before actually building the hardware. Therefore, I wrote this code to run on Visual C++ to enable me to test the FAT32 code without actually building the hardware.

Tracing the code can reveal many compatibility problems between how the official FAT32 documentation and how Microsoft Windows actually implement the FAT32 system. There are a few interesting things I found for Windows XP. Maybe you can find more using various trace methods and many different brands of SD cards.

The things I found are, for example:

1. After adding or deleting files in Windows XP, the FSinfo next free cluster upper 16-bit is always zero.
2. Adding new files in Windows XP updates the directory structure, but does not set the next entry to empty.
3. Deleting files in Windows XP does not set the FSinfo structure next free cluster to a lower numbered cluster of the deleted file.

Recommended softwares (All the three are available for free):
---------------------------------------------------------------------------------
Microsoft Visual C++ Express
HxD Hex Editor and Disk Editor
The DevCon command-line utility functions

How to use: Only five files:
MAIN.CC, SDCARD.CC, FAT32.CC, FAT32.H, GLOBAL.H.

Use Microsoft Visual C++ Express to build these files with the default built option. Then you can step through the program to learn the boot record structure, the FAT table, and how clusters are linked together. You can also use HxD Hex Editor (Extras -> Open Physical Disk) to study the SD card content. Since data is cached in Windows, you need to unplug and plug the USB card reader for write or delete command to be visible in Windows. The DevCon utility allows you to do so without the need to actually do a hardware plug and unplug. Then you can test the FAT32 system using a batch file.

Enjoy
BR - Henry Yiu

You can download the complete project folder from here:
microSD-FAT32 with Visual C++

Many thanks to Henry for allowing to share his work

Here is the step-by-step procedure of how to use the code:
----------------------------------------------------------------------------------------
(well, this assumes that you have already done some basic background study on FAT32 and microSD cards, may be by reading a few articles on them, since some theoretical knowledge would really help in making sense of the results you get)

(the folder which you download already contains the .exe file, but we'll assume that it is not there, to make the procedure complete)

1. Install and open VC++ express

2. Create a new project (select 'empty project' when asked). Enter the location and project-name. Here we'll select project-name as 'sdcard', and location as desktop

3. Project window will open. Now, go back to desktop and copy the 5 files (MAIN.CC, SDCARD.CC, FAT32.CC, FAT32.H, GLOBAL.H) from the downloaded folder, into the folder created by the VC++

4. Go back to VC++ window and add the header files and source files into respective categories displayed at left side window panel. The panel will now look like this (here main file is open):

5. Now, from the top menu-line, under 'debug', select 'build solution'. This will build the project files. The build window at the bottom of the page is shown in this figure:

6. Now, select 'start debugging' under the same 'debug' menu. This is to make sure that the .exe file is generated. Okay, now you are ready with the .exe file. It will be stored in the 'debug' folder inside the project directory. In our case directory is 'sdcard' on the desktop.

7. It's time to test the .exe file. So, connect the USB card reader, insert a microSD card (make sure the card is already formatted with FAT32, you can also store some files for checking the read feature of the code)

8. Open windows command prompt. In the command prompt, go to the project directory, 'debug' folder. Now, type 'sdcard' or 'sdcard.exe'. This will display the available options. This is described in this figure:

9. Using the command shown in the above figure, you can select 'read', 'write', 'delete' etc. options, as per the command format. After every command executed, it would display 'success!'. If any error, it would display an error message. Some of the file operations are shown here:

10. Once you have performed some operations in last step by creating, deleting files, you need to remove the card and re-insert for checking out the files. (The re-inserting thing is not required if you use the DevCon utility as suggested by Henry). The files which are created will contain random data, as this code is mainly to understand FAT. What is important is that windows should not display that the file is corrupt. This figure shows the results of operations we did in the last step, by opening the card in windows after re-insert:

11. Now, the next step is to see how to use the HxD Hex Editor to understand what we did in the previous steps: Install and open the HxD. From the top menu-line, under 'extras', select 'open disk', select the drive letter of the card and press OK, or select 'physical disks' & then 'removable disk1'. This will open the card memory area, starting with the first sector of the card. Here in the first sector, you can see how the boot sector or MBR (master boot record) of your card looks like.

12. Using the 'find' menu, search for the text string, the name of any file stored in the card. This will take you to the FAT (File Allocation Table) area of the card. (you need to use 'search' option, as sometimes the FAT sector will be located far away and you'll be tired of scrolling down. Alternatively, using the boot-sector data, you can manually calculate the FAT's starting sector number and directly go there by entering the sector number in the box at upper right corner). Here you can see how files are arranged in FAT, by their names, starting cluster numbers etc. Following figure shows the occupied part of FAT and shows location of 'newfile.txt', which we created in step 9.

This is really useful in understanding the effects of creation, deletion of files on FAT table & FSinfo sector, to gain a real insight of the FAT32. And this understanding helps a lot while debugging your code when you make the actual hardware.

It also helps understanding the differences in file handling by the microcontroller FAT32 code and the windows, as you can check the card data in HxD after using either of them. It'll help in debugging by bridging in the troublesome differences.

Here are the additional testing suggestions by Henry:
------------------------------------------------------------------------

In order to start debugging, you will need to enter command lines. You can either change the #if1 to #if0 in main(), or use the Visual C++ command argument input: In Visual C++, select the "Project", then "SDCard Properties", then select "Debugging", and then "Command Argunments", then enter the command. For example:" -w2 e: test1.txt".

To trace the detail of the FAT32 system, you would go to the end of the getBootSectorData() function and select "Run to Cursor". Then you would record these two important sector numbers:

unusedSectors + reservedSectorCount = starting sector of the FAT table

firstDataSector = starting sector of the data area

Now you can open the HxD hex editor to see how these two sectors and how they are being changed by the program once you start stepping through the program. You can press F10 to single step, or F11 to step into a function, or right click on a line and set a breakpoint, then press F5 to run to the breakpoint. You need to press F5 in HxD hex editor to refresh the display in order to see any changes the program made to the SD card.

Once you have master this procedure, you can try doing file transfer between Windows XP and the program, for example, writing a file in Windows XP and reading it back by the program etc. You can also use HxD hex editior to view how Windows XP changes the card when it create or delete files on the card.

Enjoy the testing, It's really a fun!!!

SD/SDHC Card Interfacing with ATmega8 /32 (FAT32 implementation)

2009-01-31T02:56:00.000-08:00

Hi friends,
Here is my project on interfacing of SD Card (microSD). microSD cards are available very cheap nowadays, a great option for having a huge memory in any embedded system project. It is compatible with SPI bus, so the interfacing is easy. SD card adapters are also easily available in market, one can easily make a bread-board adapter by soldering few pins on it. Following figures show the SD card pin-out & the bread-board adapter design by soldering 7-pins of a breakout header on the microSD adapter (Click on images for larger view).

I had started this project with 1GB microSD card from SanDisk (later on tested with transcend cards also). The microcontroller is AVR ATmega8 or ATmega32 running at 8Mhz internal clock. MAX232 is used to interface the circuit with PC for monitoring the data. A 3.3v supply is used for powering the mega8, microSD and max232 (though the specified supply for max232 is 5v, it works comfortably at 3.3v).7 pins of the microSD are used here, shown in the figure of pin-out.

Schematic for ATmega8 is shown here (updated on 10 May 2010, SD series resistors are removed, as they were limiting the speed of SPI bus. 51k pullups are added on CMD/DAT lines. This gives better stability with different cards. Also, two 3.6v zeners are added to protect SD in case when the ISP programmer voltage levels are of 5v. these diodes are not required if your programmer has settings for 3.3v output)
(Note: VCC & GND pins of MAX232 are not shown in the schematic, but they must be connected in the actual hardware)

Following is the schematic for ATmega32, without RTC (updated on 10 May 2010):

Following is the schematic for ATmega32, with RTC (added on 17 May 2010). Here two supply voltages are used, 3.3v for SD & 5v for remaining ICs.

The aim of this project was to learn interfacing of SD card and to understand the data transfer in raw format as well as in FAT32 format. I started with raw data transfer, sending some data to any block of the microSD, reading a block of it, reading and writing multiple blocks, erasing multiple blocks. All this in raw format. I used RS232 for viewing the data read by microcontroller from SD card. The uc sends the data to HyperTerminal. Similarly, to write data to card, the data was fed thru HyperTerminal, by typing some text.

Once raw data transfer achieved, I formatted the card with windowsXP (FAT32) and loaded it with some text files, directories and other files (all stored in root directory of the card). After that I wrote the FAT32 routines to read files, get file list (using HyperTerminal again), finding the total/free memory of card. All this data is sent to HyperTerminal by the uc.

Following is the HyperTerminal window showing different options:
Options 0 to 4 are low level functions dealing with raw data. If you use option 0, 1 or 3, you may have to reformat the card before using the FAT32 routines.
0: Erases selected number of blocks strating from selected block
1: Writes data to specified SD block address. Data to be entered in HyperTerminal using PC keyboard
2: Readss data of specified SD block address. Data is displayed on HyperTerminal window
3. Writes selected number of blocks strating from selected block
4. Reads selected number of blocks strating from selected block

Here, the multiple-block functions related to options 3 & 4 are disabled due to memory constraint as that time mega8 was used for testing and these functions are not required for FAT32 testing. While testing with mega32, options 3 & 4 can be enabled by removing a macro (#define FAT_TESTING_ONLY) defined in SD_routines.h.

Options 5 to 9 are related to FAT32 . Only short file names are supported right now, 8byte name+3bytes extension. If you store a long name file in SD, it will be displayed by these routines in short name format only.
For testing these options, format the card with FAT32 file system and store some directories and text files (because text files can be read & checked thru HyperTerminal).

5: Displays list of available directories and files with size (in the root directory of the card)
6: Reads a specified file and displays the file contents on HyperTerminal
7: Create/Append file with specified name, enter text from HyperTerminal
8: Deletes any existing file with specified name
9: Displays total & free memory of the card (using FSinfo sector of the SD card)

Following figures show the HyperTerminal window when options 5 & 9 are selected:
(These figures show menu from Ver2.3 or earlier. Menu style is changed from Ver_2.4 onwards, which is shown in the update history)

Note: HyperTerminal is used here at 19200 baudrate, No parity, Flow Control 'none'.

This project needs very few components and can be done easily at home. Try it out!

Download the source code files from here:
Download here the zipped source code files modified for mega32, written in winAVR-AVRStudio.

Version 2.4.1 (RTC added for Date/Time entries) 17 May 2010/24 Apr 2011
Version 2.3 (SDHC support added) 09 May 2010
Version 2.2 (No SDHC support) 13 Sep 2009

Download EAGLE schematic file of Ver 2.4

Download/view source code files V2.1 (for ATmega8):
Following files are compiled using winAVR inside AVRStudio. This Version does not support SDHC cards. Also, append file feature is not available.
1. SD_main.c
2. SD_routines.c & SD_routines.h
3. FAT32.c & FAT32.h (Ver 2.1, last updated-13 Sep 09)
4. SPI_routines.c & SPI_routines.h
5. UART_routines.c & UART_routines.h
6. Makefile
7. HEX file (Ver 2.1, last updated-13 Sep 09)

Please put up a comment or mail me if you find a bug in the code. The updates are because of valuable suggestions & comments from the users of this code. Thanks a lot!!

Related posts:
You can visit my post of microSD ATmega32 Data-Logger, which uses modified FAT32 library for automatically creating files without using hyper terminal.
If you want to test FAT32 functions or learn more without making the microcontroller hardware, you can visit my post here: microSD-FAT32 using Visual C++)

Update History
-----------------------------------------------------------------------------
Version 2.4:
- Real Time Clock circuit support is added for time & date entries in the files. Now the current date of file creation and file update will be entered in the FAT table (can be viewed by checking file 'properties' using a PC)
(The RTC will also be useful in data-logging with time-stamp)
- Three more options added in the Hyper Terminal menu for displaying or updating RTC date & time. New menu is shown in the above figure.

Ver 2.4.1:
- Same as 2.4, with a bug fix for RTC: 'twi_init' function added to define I2C clock freq. 100K@ 16MHz (50k@8MHz). This was taking default values earlier, which was as high as 500K@8MHz, not desirable

(Note: Version 2.2, 2.3 & 2.4 are tested on ATmega32, but they can be adopted to any controller having RAM >= 1KB and Flash >= 16KB)
Current memory usage (Ver_2.4): Flash: 12908 Bytes; RAM: 700 Bytes (appx.);

Version 2.3:
- Support for SDHC cards added (tested with SanDisk & Transcend microSD and microSDHC cards). The initialization sequence and command formats are modified.
- A bug which was causing the program flow to go into infinite loop if the character number 512 in a sector was a CR (Carriage Return, '\r'), in the writeFile function. Thanks to David & Piotr M. who pointed it out in the comments.
- Code is also tested successfully at 16MHz clock (8MHz SPI clock) with for SD/SDHC cards.

Follwing are the Hyper Terminal windows showing card detection (One window shows baudrate as 38400, that was while testing for higher clock speeds, current code still uses 19200 baud and 8MHz internal clock of Mega32).

Version 2.2:
- Append file feature added. 'createFile' function replaced with writeFile, which looks for the filename first, if the given file name doesn't exist then it creates new file and writes data, but if the file already exists, then it opens it and appends the entered data.
- A bug removed which was giving error related to use of 'LONG'
- The FAT32.c & .h files are updated on 13 Sep 09 to remove a bug which was limiting file size to 32MB (Thanks to Kun-Szabo Marton who pointed it out)

Data transfer rate: 1 raw data block (512 bytes) takes 4.15ms for reading or writing (123.37 KBytes/s) at current 4 MHz SPI clock rate. If you have flash more than 8k, you can declare the SPI_receive() and SPI_transmit() functions as 'inline' functions. This will increase the transfer rate to 140 KBytes/s. These transfer rates can be further increased by using a 16MHz crystal (8 MHz SPI clock). FAT32 file reading is done at 78 to 91 KBytes/sec.

Version 2.1:
- A bug removed which stopped creating new files after 32*8 files in the root directory
- The root directory was unnecessarily getting expanded by one cluster whenever a file was created. Fixed in the new version
- Also, the fixed cluster size of 8 sectors is removed, this version will support other cluster sizes as well

Version 2.0:
- Support added for SD cards having first sector as MBR rather than the boot sector
- createFile and deleteFile functions added
- A bug fixed in reading files stord at far locations in memory also correction made to accept 8+3 char file name (by mistake, it was taking 7+3 earlier)
- FSinfo sector used for storing total free cluster count &
next free cluster number for faster file access
- Instant freeMemory display (earlier it was taking more than 30secs) using FSinfo sector. FSinfo sector is updated now whenever a file is created or deleted
- File memory size display in decimal, like windows (earlier it was in hex)
- Raw SD functions multiple block read and write, which are not required for FAT32, are disabled using FAT32_TESTING_ONLY macro for getting extra space required by createFile & deleteFile changes (you can activate it if you have more than 8k flash) Right now flash is 99.9% full
- Clock speed raised from 1Mhz to 8 MHz, new SPI speed (after SD initialization): 4MHz instead of 500K & baudrate: 19200 (for HyperTerminal) instead of 4800
-------------------------------------------------------------------------------

References:
1. Microsoft's FAT32 specification document
2. SanDisk SD mnual v1.9
3. SD-Simplified Physical Layer Spec. Ver 2.00
4. F. Foust's Application Note on SD
5. FAT32 Structure info, includes MBR details
6. Simple FAT32 Structure explanation
7. Chan's FAT library

Regards,
ccd@dharmanitech.com

IR Remote Controlled Car (PWM motor control using ATmega8)

2009-01-09T04:30:00.000-08:00

Hi Friends,
in my last post of Simple DC motor Control, I've discussed controlling a small DC motor using the PWM method with MOSFET H-bridge. The circuit was build with microcontroller ATmega8.
Here, I'm extending the same circuit to control the DC motor with IR remote control. The motor is fitted on a toy car wheels with gears, as shown in the figure above.

Following is the schematic (Click on the image to enlarge it):

The circuit uses two PWM channels of ATmega8 for controlling the speed and direction (reverse, forward) of the car, based on the command received from the IR remote. Here, a Sony TV remote was used. The IR codes were received by using TSOP1738 IR detector from Vishay. (Thanks a lot to Michael Spiceland from tinkerish.com, for helping me out with the code for IR signal decoding!).

Following buttons on the remote are used for control:
'1' : Start motor
Volume+ : Increase speed
Volume-: Reduce speed
Channel+: Forward direction
Channel-: Reverse Direction
'0': Stop motor

Check out the video (the LED blinks whenevr a key on the remote is pressed. The remote is not visible in the video as I was holding the camera and remote both!!)

The coding is done with ICCAVR compiler. It can be easily adapted to other compilers with minor changes. Complete code is given here:

View Code on Google Docs
Download source code files (zip)

Download datasheet & further info:
TSOP1738 datasheet
Info on Sony remote control codes

Thanks & Regards,
ccd@dharmanitech.com

4x4 Matrix Key-board Interfacing with ATmega32

2008-11-30T05:09:00.000-08:00

Hi guys,
Here is a project for beginners to interface a 16-key (4x4) keypad with ATmega32 using 8-pins i.e. one port of the microcontroller. This is useful particularly where we need more keys but don't want to spend more uC pins for interfacing.
The 4x4 keypad is a standard one available in the market. I've used here one from my earlier project. The LED shown in the schematic is just extra, which can be used anyway you like.
Here, the mega32 reads the code of key pressed and sends relevant character to display on LCD 2nd line. The first line displays 'WELCOME' all the time.

Download
------------------
Source Code (AVR-GCC, winAVR, AVRStudio format)
Source Code (CodeVision AVR format)
Source Code with 4-bit LCD Implementation (ICCAVR)
Source Code (ICCAVR) with Schematic on Google Docs
HEX file

Thanks!

Simple PWM DC motor control using MOSFET H-Bridge with AVR ATmega8

2008-11-22T11:31:00.001-08:00

Hi friends,
here is a very simple project of controlling a small DC-motor (taken from an old personal cassette player) with ATmega8. The ATmega8 is having three PWM channels, out of which two are used here. PWM waveforms are fed to MOSFET (RFD3055) H-bridge.
Here, direction is controlled using a two-position toggle switch and speed of the motor is controlled by two push-buttons, one for increasing the speed and other for reducing.
The schematic is geiven here (click on the image to enlarge):

When switch SW1 is closed, OC1A channel is active which will feed the PWM signal to Q1 & Q4 MOSFETs. The OC1B pin will remain low keeping the Q3 & Q2 in OFF condition. When SW1 is toggled to open position, OC1A pin will become low, making Q1 & Q4 OFF and OC1B will feed the PWM signal to Q3 & Q2, resulting in the change in the direction of current flow hrough motor. Hence, motor rotation direction will change.
The speed is controlled by Push-buttons S2 & S3. Pressing S2 will increase the speed in fixed steps. Similarly, pressing S3 will reduce the speed in fixed steps.

The closer look to the motor and the circuit:

Here on the bread-board, I've used two push-buttons but the direction control switch is replaced by a small wire which was connected to ground or kept open for changing the direction (since I was not having the toggle switch in stock at the moment). The bread-board also includes 6-pin In-System Programming connector which is not shown in the schematic.

(The InSystemProgramming (ISP) connector is shown in my earlier posts, hence omitted here!! But, if you are new to ISP, refer to my post DIY AVR Programmers to make one yourself!!)

The schematic and code for this PWM motor control can be downloaded from here:

Schematic & Code on Google Docs
Source code in CodeVision format (C file)

Download datasheet: RFD3055

Thanks!
---------
ccd@dharmanitech.com

8-Channel ADC Project with ATmega32

2008-10-20T09:53:00.000-07:00

Hi friends,
here is a small project of Analog to Digital Converter using ATmega32 which is having on-chip 8-channel ADC.
The circuit also consists of an intelligent 16x2 LCD for displaying the value of the voltage applied at each channel. There is also a push-button to scroll throgh the different channels. The schematic is as shown in the figure:

When powered on, the LCD displays"ADC Testing.." on the first line and the value of the voltage applied at the channel0 on the second line. When the push-button is pressed, the second line displays the value of channel1. Like-wise, all the channels can be checked one-by-one by pressing the push-button. The channel count will roll back to channel0 after going to channel7.

The displays shown in the pictures on top show values at channel0 and channel1. Here a AA battery was connected to channel0 and the channel1 was connected with the +5v supply.
A 9-pin connector is used for ADC, 8 ADC channel pins and 1 ground pin. (the values displayed on LCD will fluctuate for a channel if nothing is connected to that channel)

The software is created in C using ImageCraft ICCAVR compiler.
The Schematic and code for this project can be downloaded here:

Download Schematic and Code
Download HEX file

Thanks!!
-----------
ccd@dharmanitech.com

Home-made Double Layer ATmega32 PCB for RS232/RS422 Communication testing

2008-10-09T06:13:00.001-07:00

Hi guys,
after making my single layer starter's kit M32_Card, I was looking for making a double layer M32 PCB at home. So, here is my attempt to make it. Well, it didn't turn out to be as difficult as I had thought it to be earlier. I had to dump one PCB before making this one as the top-layer routine was not solder-friendly!!

I've made this one mainly for an application where RS232 & RS422 testing was required. It uses MAX232 & MAX488 ICs from for those serial communication. Selection between RS232 & RS422 is through jumpers. The board is using ATmega32 controller, just like my single layer pcb. It also has 4x4 matrix keyboard, an LCD interface, ADC connector, SPI connector (for In System Programming), a reset switch and an LED for beginner's programming. It operates with the standard 12v DC adapter.

Here is the schematic (click on the image to enlarge):

There is a small mistake here in the schematic, the RX/TX pin connections in the RS232 connector are swapped, which I found while testing the PCB. So, I had to correct it by cutting those two tracks and placing jumpers. After the correction, the communication with PC was established. The schematic is similar to the M32_Card, accept that I've removed the RTC DS1307 and placed the MAX488. Also, the individual push buttons are replaced with the 16 key matrix key-board.
Click here to get more info and for downloading code to interface the 4x4 matrix keyboard shown here

The PCB etching is done with Ferric Chloride. In making the double layer PCB, as I don't have any PTH (printed through holes) facility, I've put small pieces of single core wire into the holes and soldered both sides. Check out the top and bottom layers here

If you have an application where the circuit can not be contained in a single layer, a home-made double layer PCB is worth a try!!

Thanks!
---------
ccd@dharmanitech.com

Thermometer using DS1621 and Nokia 3310 LCD interfaced with ATmega8

2008-10-03T06:19:00.000-07:00

Hi friends,
in my last post I had discussed Nokia 3310 LCD interfacing with AVR ATmega8. It's really fun to work with this LCD.

Now, here I'm presenting one application with the same LCD: Designing a thermometer using DS1621 temperature sensor IC. DS1621 is 8-pin sensor from Maxim, with temp range of -55 to +125 degree C, which can be interfaced with microcontroller over two-wire serial i2c bus. It has operating voltage range from 2.7 to 5.5v. I'm operating it here at 3.3v, same as the one driving the LCD and ATmega8. DS1621 doesn't require any external components to measure temperature. It has got continuous or one-shot temperature reading capability to save power.
Check out the schematic:

I'm using here LM317 for getting 3.3v supply, any 3.3v rgulator can be used to replace it. The LED is only for checking the health of the circuit incase nothing comes up on display. The circuit is programmed to update temperature appx. every second.

I've taken help of LFG application for generating different sizes of fonts for the LCD, thanks o the author M.Ebrahimy. The application can be downloaded from here:
LCD Font Generator

I've created library functions for DS1621 interface with AVR using ICCAVR compiler. This functions can be used with i2c base routines discussed in my earlier posts. You can download the project source code here.

Download
------------------
HEX file
Source code (including the 3310 & DS1621 Libraries)

(Do you wanna use this HEX file but don't want my name on the display?? Well, just learn how to play with hex file from intel HEX-file tutorial, find ascii characters of my name in the hex file and replace them with yours!!)

Download Datasheets:
1. DS1621
2. ATmega8

Thanks!!
---------
Contact: ccd@dharmanitech.com

NOKIA 3310 LCD interfacing with ATmega8

2008-09-21T12:17:00.000-07:00

Hi friends,

using graphic LCD in a project gives itreally a good look and flexibility of displaying different characters and shapes. But, the graphic LCDs are quite costly.

The NOKIA 3310 LCD provides a really low-cost solution to add a small graphic display into your project and also good for learning purpose. The LCD is SPI bus compatible, saving many pins for other uses. It operates at 3.3v.

Here is a small circuit for interfacing the 3310 LCD with AVR microcontroller ATmega8. The schematic includes LCD connection with SPI port of ATmega8 with other connections required by LCD. The 3.3v is generated using adjustable voltage regulator LM317 (I was not having any 3.3v regulator at the moment). An LED is also connected with microcontroller just for making sure that the controller is working, particularly when you don't see anything on the display!

Here is the schematic and the pin details of the LCD (click on the image to enlarge it):

The connector of LCD is 'touch' type. So, I made a small connecor PCB with tracks touching to the pins of LCD. The pcb was pasted at backside of LCD using cello tapes as shown in the back-view image
.

The program routines are written in C with ICCAVR compiler. I've created a library for this display. The low-cost, easy availability has made me relly like this display.
I'm going to use it for

doing other stuffs, too!

Download
----------------
3310 Library (ICCAVR)
3310 Library (AVR-GCC, winAVR, AVRStudio)
3310 project (CodeVision AVR)

Check out my thermometer project with this display:
Thermometer with Nokia3310

Download datasheets:
1. ATmega8
2. PCD8544 - nokia 3310 display controller

Thanks!!
--------
ccd@dharmanitech.com

Using M32_Card for Data Acquisition with on-board 8 channnel ADC

2008-09-13T15:09:00.000-07:00

Hi friends,
I'm showing here one more application of the home-made M32_Card discussed in my earlier post. The microcontroller of the card is having 8-channel, 10 bit resolution ADC which can be used for analog data acquisition. Using the hyper terminal for the selection of menu, ADC can be selected to display value of the analog voltage applied to each channel (at the 9-pin header pin; 8 ADC channels & 1 GND).
The microcontroller reads the voltage at each channel and sends the data to PC via RS232 cable. At reciving end (PC), the incoming data can be converted into excel format to store the values at regular time intervals.
As shown in the screen-shot of the hyper terminal, I had connected here the 5v Vcc to Channel 0 and an Li cell to channel 7.
The M32 can also send a time impression along with the channel data using the on-board RTC DS1307 to record the voltage variation with time.

The project source code files can be downloaded from here:
Download Source Code

--------
ccd@dharmanitech.com

DIY AVR Programmers

2008-09-03T03:30:00.000-07:00

Hi guys,
for those who are trying to make AVR kit at home, an AVR programmer which can be simple to make will be really useful, as it'll avoid buying the programmer!! Here I'm giving a few webpage links on how to make a programmers yourself.

- Here is a simple AVR serial programmer, works with PC serial port, easy to make:

For complete info check out the webpage:
AVR Serial programmer from Extremeelectronics.co.in

- For using the serial programmer discussed above, a driver software is required to be installed in your pc. Download it from here:
PonyProg : AVR serial programmer

- If you are using a laptop which doesn't have serial port then you can buy a low-cost AVR USB programmer shown in the figure. Visit this webpage for buying it:

AVR USB Programmer

Here is one more option for buying a cheap USB programmer for AVR at around $15 cost:
AVR USB Programmer lite

And if you want to make an USB programmer yourself, check out here an easy to make AVR USB programmer:
DIY AVR USB Programmer

- Atmel has given a detailed document on design of In-System Programmer for AVR. It inclludes the schematic of the programmer. Download this pdf document from here:
In-System Programmer for AVR, from Atmel

- For those who like pc parallel port better, here is a page containing data on how to make a parallel port AVR programmer along with the download for the pc:
Parallel port programmer for AVR

- Here is another parallel port programmer from AVRdude:
AVRdude parallel port programmer

- One more parallel port programmer using AT90S1200 microcontroller, with schematic and the .asm file. (Note: it need a pre-programmed AT90S1200 IC). Check out more on the webpage:
Psychogenic PPI AVR Programmer

- Apart from these, some more free designs are there, you'll find them by googling!! And if you want to buy, there are plenty of them available!!!

Hope this info is useful for your project work..
Thanks!

Make-Yourself ATmega32 Starter's Kit with LCD, I2C, SPI, RTC, ADC interfaces

2008-08-30T03:01:00.000-07:00

Hi friends,
here is my home-made kit of ATmega32 microcontroller interfacing. The ATmega32 controller is rich with features like onboard 32kB in-System programmable flash, 1 KB EEPROM, 2KB SRAM, 10bit ADC (8 channel), SPI bus inteface, TWI (compatible with I2C bus) interface, an USART, analog comparator, etc. That's why I've selected it to load my kit with all those features.

This M32 card is having an LCD inteface with contrast adjustment, an RS232 port for connecting with PC, a connector for 8 analog voltage inputs to measure by ADC, a Real Time Clock IC DS1307 from maxim with battery back-up, four general purpose keys, two keys for generating interrupts and an LED.
The circuit can be powered by an easily available 12v DC adapter. The voltage regulator IC 7805 used to convert the input into regulated 5v supply.

See below the kit in powered on condition and the schematic (click to enlarge the images)

The PCB is completely home-made, using the etching technique with the Ferric Chloride chemical. If you want to know how to make a PCB yourself from your layout, visit following webpage, it's really helpful:

http://electrons.psychogenic.com/modules/arms/art/10/pcb_howto.php

The schematic and layout of the M32_card shown here are prepared using EAGLE. It's a single layer board for making the home-preparation easy. Check out the bottom layer and the layouts in the pics below:

The software for the ATmega32 controller is written using imageCraft AVR compiler. The software contains code for LCD interface, use of RTC and communication with PC with RS232 port. Using the Hyper terminal in windows, the functionality of the kit can be checked, as I've mentioned in my previous post of RTC_EEPROM interface with ATmega128.
Sown below are the pics of RTC circuit in test and related screen shot of the hyper terminal while interacting with the M32_Card

The complete source code files including new addition of ADC (check out Here) can be downloaded below.

Download
----------------
Source code
PCB files (in PDF & EAGLE formats)

Datasheets:

ATmega32 DS1307 MAX232

--------
ccd@dharmanitech.com

Interfacing RTC & serial EEPROM using i2c bus, with ATmega128 uC

2008-08-14T14:57:00.000-07:00

Hi friends,
here is my experiment with i2c bus for interfacing serial EEPROM (24C256) and RTC (DS1307) using AVR microcontroller ATmega128. The circuit is also provided with an RS232 port for connecting with PC to send commands for reading/writing EEPROM or setting date/time in RTC (Click on images to enlarge them).

Communication with PC is done through Hyper Terminal. A screen shot of the message sent to PC by microcontroller immediately after power ON is shown in the figure at the left, where the user is asked to enter choice from the menu options related to EEPROM and RTC. User can store data in EEPROM, or set RTC date and time by entering them using PC keyboard.
Hyper Terminal is used with 19200 Baud, No parity, No hardware flow control settings.

When the circuit is powered on, a welcome message is displayed on the Hyper Terminal window and a menu with 9 options (0-8) is displayed (refer to the figure). The options are explained here:

0: Erase EEPROM (fills eeprom with 0xff bytes)
1: Write EEPROM (starts writing eeprom starting with 0x0000 address)
2: Read EEPROM (reads eeprom starting with 0x0000 address)
3: Write eeprom page (writes one page of eeprom at specified page number)
4: Read eeprom page (Reads one page of eeprom at specified page number)
5: Display RTC Date (Displays current date from RTC)
6: Display RTC time (Displays current time from RTC)
7: Update RTC Date (Setting new date in RTC)
8: Update RTC time (Setting new time in RTC)

The option is selected from PC keyboard. While writing to eeprom or RTC the data is entered using PC keyboard as specified by the program.

The software routines include DS1307 library, 24C256 library & I2C library along with the main function.

The code is written in C using winAVR (inside AVRStudio). The complete project folder can be downloaded here in zip format (updated on 25-April-2009, earlier it was in ICCAVR format):

Download Complete Source code

Datasheets:
ATmega128 DS1307 FM24C256 MAX232

Thanks!

(last updated on 25-April-2009)
---------
ccd@dharmanitech.com

opamp Precision Rectifier

2008-08-06T10:08:00.000-07:00

Hi friends,
this is a simple opamp precision rectifier. Very useful in rectifying or making bipolar signals unipolar, specially in small signals where we cannot afford to have that 0.7v drop across the normal diode bridge rectifier.
The circuit shown here gives rectified output going only in the negative direction, as my application required it that way. But if you want rectified positive output, just reverse the direction of both the diodes and you'll get it!

USART-to-USB converter using FT232BM chip

2008-07-27T09:08:00.000-07:00

Hi guys,
here is an easy an popular way to start using USB in your designs without going into learning the complicated USB protocol. This circuit converts normal USART signals from any microcontroller into USB compatible signals which can be directly connected to the PC. If u r designing a circuit and u need pc interface, then this is the best way, use USB, as the RS232 ports are disappearing from PCs and laptops very fast.

This circuit is as suggested by FTDI's datasheet for the device FT232BM. It also includes an EEPROM to input your device name which will appear in PC when u connect your circuit to PC. The Tx and Rx LED indication is also provided.

Drivers for this IC are available free on FTDI's website mentioned below. The drivers create virtual serial comm ports, hence keep the USB protocol completely in background. U can program yr controller just like u r designing it for RS232 communication!!

New! (21 May 2010)

FTDI has released a RS232 to USB converter in DB9 connector package, an easiest way to migrate from RS232 to USB without any change in your PCB, you can have the footprint of DB9 female connector but place this module instead and you are USB ready!! Really cool!!!

More info: http://www.ftdichip.com

Ring Detector for Caller ID Unit

2008-07-26T10:29:00.000-07:00

Hi Friends,
this is an addition to the caller ID circuit of my previous post. For deciding whether call is received call or missed call, u need to monitor the ringing signal along with the off-hook detector signal, which is discussed in the last post. If the off-hook detector signal goes low (i.e. receiver lifted) before the ringing signal stops, then the call is labeled as received call, otherwise it is a missed call.
This small circuit converts the ringing signal (sine wave 90vrms) into 5v dc pulses which can be directly fed to microcontroller pin. The circuit outputs a pulse for each ring. The delay between two pulses is to be monitered and if it exceeds 4 sec, then ring is dead, hence, the call is missed call.!
Try it out..

Design Caller ID using DTMF decoder MT8870

2008-07-25T06:11:00.000-07:00

Hi friends,

one more circuit: DTMF decoder interface for designing Caller ID Unit. It's very simple circuit using DTMF decoder MT8870 (or CM8870). As shown in the circuit, u'll receive an interrupt ( if NAND output is connected to INT of the microcontroller) whenever u receive a call or make a call and then u can use yr program to read the digits coming out of pin 11 to 14 of the MT8870. I designed the circuit with additional features like seperating received calls, missed calls, dialled numbers along with telephone directory.

Download datasheet:

MT8870

CM8870

To determine whether number is dialled or received, u need to know whether receiver is on-hook or off-hook. following simple circuit will give u that indication:

I had used microcontroller 8951 with16x2 LCD and Dallas nvRAM for storing numbers and names. The code is in assembly language. It's really easy to make this one with lot of variations.

Check out my next post on telephone ring detector to check whether the call is received call or missed call.

----------
ccd@dharmanitech.com

Rate or Position measurement using Solid State Gyroscope

2008-07-17T11:28:00.000-07:00

updated:14/08/08

Hi friends,
here is a circuit to measure rate of a rotating object using solid state gyro ADXRS150 (used here is DIP sized evaluation version). this circuit gives output of -10v to +10v for rate upto 80 deg/sec in both the directions (i.e. -80 to +80 deg/sec). A direction o/p logic signal is also there to feed to microcontroller. Temperature of gyroscope also can be measured with onchip ADC of the microcontroller like ATmega32 (describd in previos post), which can be used for temperature compensation of the gyro o/p.

find the detailed datasheet of ADXRS150 here:
ADXRS150 Datasheet

interfacing ATmega32

2008-07-13T10:55:00.001-07:00

Hi techies!!
This is one more of my circuits, interfacing ATmega32 with an LCD and a DAC. it also includes two general purpose push-buttons and In System Programming connector. The controller is operating with 14.7456 MHz frequency crystal, convenient for generating standard baud rates (for RS422 communication whic i used in my actual project, not shown here).

The Atmel AVR controller ATmega32 is a very powerful chip with 1 MIPS/MHz throughput and contains a lots of on-chip peripherals like UART, SPI, 32bits I/O, TWI(I2C compatible), versatile timer/counters and lot more..
the LCD and DAC driver functions are written in C(using imageCraft compiler)

Download schematic & code for LCD interfacing

Enjoy!

2008-07-12T04:35:00.000-07:00

Hi all the techy guys!!! welcome to this blog!
I love designing things with microcontroller,
so here I m, to share the my ideas with you guys and to know your ideas!!
Start Blogging!!!