Embedded Microcontroller Programming

Understanding Processor Architecture: Machine and Assembly Language

2010-06-14T16:52:00.001+07:00

The processor understands only the machine language, whose instructions consist of strings of 1s and 0s. Machine language is closely related to the assembly language. We prefer to use the assembly language rather than the machine language. Programming in the assembly language also requires knowledge about the processor architecture.

Assembly language programming is referred to low-level programming because each assembly language instruction performs a much lower-level task compared to an instruction in a high-level language. Assembly language instructions are processor specification dependents. For example, a program written in the Intel assembly language cannot be executed on the PowerPC processor.

Here are some IA-32 assembly language examples:


inc result
mov class_size, 45
and mask1, 128
add marks, 10

The first instruction increments the variable result. This assembly language instruction is equivalent to


result++;

in C. The second instruction initializes class_size to 45. The equivalent statement in C is


class_size = 45;

The third instruction performs the bitwise and operation on mask1 and can be expressed in C as


mask1 = mask1 & 128;

The last instruction updates marks by adding 10. In C, this is equivalent to


marks = marks + 10;

We can translate the assembly language instructions to the equivalent machine language instructions. Machine language instructions are written in the hexadecimal number system. Here are some IA-32 machine language examples:

Assembly	Operation	Machine language (in hex)
nop	No operation	90
inc result	Increment	FF060A00
mov class_size, 45	Copy	C7060C002D00
and mask, 128	Logical and	80260E0080
add marks, 10	Integer addition	83060F000A

References

Guide to RISC Processors for Programmers and Engineers by Sivarama P. Dandamudi, Springer (2005), ISBN 0-387-21017-2.

P89V51 code SVN

2008-11-03T14:52:00.003+07:00

I have decided to open my small project on SDCC c code for P89V51. This project is open source. It is distributed under GNU General Public License.

How to download?

Use this command to anonymously check out the latest project source code

svn checkout http://p89v51-sdcc.googlecode.com/svn/trunk/ p89v51-sdcc-read-only

Or, please find the compressed files (.zip, .gz) from the project page

http://p89v51-sdcc.googlecode.com

If found bugs or got troubles, please feel free to report here.

---

Build Your Own ARM Cross Compiler Toolchain

2007-04-22T16:34:00.003+07:00

GNUARM is a set of open source GNU compiler for ARM microcontroller. The toolchain consists of the GNU binutils, GCC compiler set, Newlib and Insight, the graphical user interface to GNU debugger for Windows and Linux. This article will guide the building process of GNUARM toolchain only for Linux users. For Windows users, there have the installer executable EXE files already. www.scienceprog.com has a tutorial on setting up this tool on Windows environment.

Get the sources
I will demonstrate the building process for GCC-4.1 only. For the others version, you can find the GNUARM distributions files from here. Here is the list of files that are required for the installation.

binutils-2.17.tar.bz2 [13.1MB]

gcc-4.1.1.tar.bz2 [37.3MB]

newlib-1.14.0.tar.gz [7.61MB]

insight-6.5.tar.bz2 [20.4MB]

I compiled the sources code with gcc-4.1.1 on Fedora Core 6 (kernel-2.6.18). Note that I built the toolchain as root. I also wanted the arm-target stuff separate from my Linux-native stuff, so I put the toolchain in /usr/local/gnuarm.

Building Instruction

[home]# tar xvf binutils-2.17.tar.bz2
[home]# tar xvf gcc-4.1.1.tar.bz2
[home]# tar xvf newlib-1.14.0.tar.gz
[home]# tar xvf insight-6.5.tar.bz2
[home]# cd binutils-2.17
[binutils-2.17]# ./configure --target=arm-elf \
--prefix=/usr/local/gnuarm --enable-interwork --enable-multilib
[binutils-2.17]# make all install
[binutils-2.17]# export PATH="$PATH:/usr/local/gnuarm/bin"
[binutils-2.17]# cd ../gcc-4.1.1
[gcc-4.1.1]# ./configure --target=arm-elf \
--prefix=/usr/local/gnuarm --enable-interwork \
--enable-multilib --enable-languages="c,c++" \
--with-newlib --with-headers=../newlib-1.14.0/newlib/libc/include
[gcc-4.1.1]# make all-gcc install-gcc
[gcc-4.1.1]# cd ../newlib-1.14.0
[newlib-1.14.0]# ./configure --target=arm-elf \
--prefix=/usr/local/gnuarm --enable-interwork --enable-multilib
[newlib-1.14.0]# make all install
[newlib-1.14.0]# cd ../gcc-4.1.1
[gcc-4.1.1]# make all install
[gcc-4.1.1]# cd ../insight-6.5
[insight-6.5]# ./configure --target=arm-elf \
--prefix=/usr/local/gnuarm --enable-interwork --enable-multilib
[insight-6.5]# make all install

Now, I hope everthing is done. You can test by running arm-elf-gcc command in the shell.

8051 mcu, von Neumann vs Harvard Architectures

2007-04-19T17:41:00.001+07:00

We can classify computer architectures into two categories:

von Neumann architecture: computers has a single, common memory space in which both program instructions and data are stored. There is a single internal data bus that fetches both instructions and data. They can not be performed at the same time.

Harvard architecture: computers have separate memory areas for program instructions and data. There are two or more internal data buses, which allow simultaneous access to both instructions and data. The CPU fetches program instructions on the program memory bus.

The 8051 microcontrollers (MCS-51) have an 8-bit data bus. They can address 64K of external data memory and 64K of external program memory. These may be separate blocks of memory, so that up to 128K of memory can be attached to the microcontroller. Separate blocks of code and data memory are referred to as the Harvard architecture. A single block of memory may be mapped to act as both data and program memory. This is referred to as the Von Neumann architecture.

The 8051 has two separate read signals, RD# (P3.7) and PSEN#. The RD# (P3.7) is activated by clearing to logic level 0 when a byte is to be read from external data memory, PSEN#, from external program memory. All external code is fetched from external program memory. The bytes from external program memory may be read by special read instructions such as the MOVC. And there are separate instructions to read from external data memory, such as the MOVX instruction. In order to read from the same block using either the RD# signal or the PSEN# signal, the two signals are combined with a logic AND operation. This way, the output of the AND gate is low when either input is low.

By adopting the Von Neumann architecture, code may be written to memory as data bytes, and then executed as program instructions.

Further Reading

8051 von Neumann Memory Example Program (Keil)

Harvard vs von Neumann (MSP430 Discussion)

Microcontroller Programmer DIY

2007-04-12T22:35:00.002+07:00

I search about this issue for a while, "Building programmer of our own designs". I found a few of open source programmer projects so that every body can use and contribute it. Here is an opportunity of learning the microcontroller programmer designs from that open schematics.

Here is a list of Microcontroller Programmer, Do It Yourself (DIY).

8051

ATMEL 89C Series Flash Microcontroller Programmer Ver 1.1 - This programmer was designed in view of to be flexible, economical and easy to built, the programmer hardware utilizes the standard TTL series parts and no special components are used. The programmer is interfaced with the PC parallel port and there is no special requirement for the PC parallel port, so the older computers can also be used with this programmer.

Atmel 89C2051 In-Circuit Programmer Schematic - The idea is to add this circuitry to a board with already has ram at 2000 and an 82C55 I/O chip to provide ports A, B and C. This is a "beta release" schematic. Use at your own risk

ISP Flash Microcontroller Programmer Ver 3.0 - This ISP Programmer can be used either for in-system programming or as a stand-alone spi programmer for Atmel ISP programmable devices. The programming interface is compatible to STK200 ISP programmer hardware so the users of STK200 can also use the software which can program both the 8051 and AVR series devices.

Atmel AT89Cx051 programmer

PIC

PP06 PIC Programmer Software - PP06 is an open-source Production programmer for Microchip's PIC micros. Specifically designed for use in factory in-circuit programming, and development of master/slave systems it supports many pics,and is easily extended to different hardware.

Classic PIC Programmer - The classic PIC 16C84/16F84 programmer. The design is originally by David Tait and modified by Bob Blick

AVR

AVR911: AVR Open-source Programmer - The AVR Open-source Programmer (AVROSP) is an AVR programmer application that replaces the AVRProg tool included in AVR Studio. It is a command-line tool, using the same syntax as the STK500 and JTAGICE command-line tools in AVR Studio.

AVR In-System Programmer - They provide details on our version of the Atmel AVR In-System Programmer (ISP). They provide schematics and printed circuit board (PCB) art to allow you to construct your own programmer.

Learn Embedded Linux with ARMulator

2007-04-09T00:05:00.002+07:00

uClinux is an excellent way to study the embedded operating systems for an engineer, student, hobbyist, Linux-enthusiast. I am interested in Embedded Linux for ARM microcontroller. Before buying a new mcu evaluation board, there is a smart way to study the Embedded Linux. That is studying it with the emulator called ARMUlator.

I tested on Fedora Core 6 Linux with GCC 3.4.x (how to install gcc 3.4 for FC6).

What you get

Here are some files you can use to put together uClinux running in the GDB/ARMulator.

gdb-5.0.tar.bz2 - The orginal gdb-5.0 archive.

gdb-5.0-uclinux-armulator-20060104.patch.gz - Patches against gdb-5.0 based heavily on the ARMulator changes from Ben Williamson with changes to behave like an Atmel AT91 device.

linux.2.4.x.gz - A precompiled uClinux kernel binaries that you can run in the emulator.

romfs.2.4.x.gz - romfs images to use with the above kernels.

Building the Debugger/Emulator


 tar xvf gdb-5.0.tar.bz2
 gunzip gdb-5.0-uclinux-armulator-20060104.patch.gz
        patch -p0 < gdb-5.0-uclinux-armulator-20060104.patch
 cd gdb-5.0
        export CC=gcc34
 ./configure --target=arm-elf
 make
 make install

Running the precompiled binaries

The ARMulator expects the romfs to be in a file called "boot.rom". You must use the matching kernel/romfs combo's.


 gunzip romfs.2.4.x
 gunzip linux.2.4.x
 ln -s romfs.2.4.x boot.rom
 arm-elf-gdb linux-2.4.x
 ...
 gdb> target sim
 ...
 gdb> load
 ...
 gdb> run

Finally, you should get something like this:

Microcontrollers and the GNU Public License (GPL)

2007-04-07T19:52:00.002+07:00

Open Source software is released according to the terms of the GNU Public License, GPL. The GPL is intended to guarantee your rights to use, modify and copy the subject software. Along with the rights comes an obligation. If you modify and subsequently distribute software covered by the GPL, you are obligated to make available the modified source code. The changes become a “derivative work” which is also subject to the terms of the GPL. This allows other users to understand the software better and to make further changes if they wish.

This works well for most software but there is at least one problem. Suppose, for example, that you write a clever application that you wish to keep proprietary. If you link it with a C library covered by the GPL, your application becomes a derivative work and thus you’re required to distribute your source code.

To get around this, and therefore promote the development of Open Source libraries, the Free Software Foundation came up with the “Library GPL.” The distinction is that a program linked to a library covered by the LGPL is not considered a derivative work and so there’s no requirement to distribute the source, although you must still distribute the source to the library itself.
Subsequently, the LGPL became known as the “Lesser GPL” because it offers less freedom to the user. So while the LGPL makes it possible to develop proprietary products using Open Source software, the FSF encourages developers to place their libraries under the GPL in the interest of maximizing openness.

Here is a list of GPL software for microcontroller developers.

SDCC: a Freeware, retargettable, optimizing ANSI - C compiler that targets the Intel 8051, Maxim 80DS390, Zilog Z80 and the Motorola 68HC08 based MCUs (GPL)

GNUPIC: a collect of GNU software for PIC microcontrollers

WinAVR: a suite of executable, open source software development tools for the Atmel AVR series on the Windows

GNUARM: GNU toolchain ARM microcontrollers

Linux for Embedded Systems

2007-04-06T19:48:00.002+07:00

For a microcontroller learner, Embedded System is a challenge. Linux are used as an operating system for the modern embedded devices. I am a one who are trying to study Linux on an embedded microcontroller, i.e., 8051 mcu and ARM. Let's start together!

This is a list of some sites that are of particular interest to embedded developers.

kernel.org – The Linux kernel archive. This is where you can download the latest kernel versions as well as virtually any previous version.

sourceforge.net – “World’s largest Open Source development website.” Provides free services to open source developers including project hosting and management, version control, bug and issue tracking, backups and archives, and communication and collaboration resources.

linuxdevices.com – A news and portal site devoted to the entire range of issues surrounding embedded Linux.

embedded-linux.org – The Embedded Linux Consortium, a nonprofit, vendor neutral trade association promoting Linux in the embedded space. Its major effort at present is the development of an embedded Linux platform specification.

embedded.com – The web site for Embedded Systems Programming magazine.
This site is not specifically oriented to Linux, but is quite useful as a more general embedded information tool.

Understanding Processor Architecture: RISC versus CISC

2007-04-05T17:39:00.002+07:00

Popular processor designs can be broadly divided into two categories: Complex Instruction Set Computers (CISC) and Reduced Instruction Set Computers (RISC). The dominant processor in the PC market, Pentium, belongs to the CISC category. However, the recent trend is to use the RISC designs. Even Intel has moved from CISC to RISC design for their 64-bit processor.

CISC systems use complex instructions. For example, adding two integers is considered a simple instruction. But, an instruction that copies an element from one array to another and automatically updates both array subscripts is considered a complex instruction. RISC systems use only simple instructions. Furthermore, RISC systems assume that the required operands are in the processor’s internal registers, not in the main memory. It turns out that characteristics like simple instructions and restrictions like register-based operands not only simplify the processor design but also result in a processor that provides improved application performance.

Several factors contributed to the popularity of CISC in the 1970s. In those days, memory was very expensive and small in capacity. Even in the mid-1970s, the price of a small 16 KB memory was about $500. So there was a need to minimize the amount of memory required to store a program. An implication of this requirement is that each processor instruction must do more, leading to complex instruction set designs. Complex instructions meant complex hardware, which was also expensive. This was a problem processor designers grappled with until Wilkes proposed microprogrammed control in the early 1950s.

Figure 1. The ISA-level architecture can be implemented either directly in hardware or through a microprogrammed control.

A microprogram is a small run-time interpreter that takes the complex instruction and generates a sequence of simple instructions that can be executed by the hardware. Thus the hardware need not be complex. Once it became possible to design such complex processors by using microprogrammed control, designers went crazy and tried to close the semantic gap between the instructions of the processor and high-level languages. This semantic gap refers to the fact that each instruction in a high-level language specifies a lot more work than an instruction in the machine language. Think of a while loop statement in a high-level language such as C, for example. If we have a processor instruction with the while loop semantics, we could just use one machine language instruction. This explains why most CISC designs use microprogrammed control, as shown in Figure 1.

RISC designs, on the other hand, eliminate the microprogram layer and use the hardware to directly execute instructions. Here is another reason why RISC processors can potentially give improved performance. One advantage of using microprogrammed control is that we can implement variations on the basic ISA architecture by simply modifying the microprogram; there is no need to change the underlying hardware. Thus it is possible to come up with cheaper versions as well as high-performance processors for the same family of processors.

References

Guide to RISC Processors for Programmers and Engineers by Sivarama P. Dandamudi, Springer (2005), ISBN 0-387-21017-2.

ASEM-51 step-by-step Installation on Windows XP

2007-04-03T14:36:00.002+07:00

Last time I wrote an installation for ASEM-51, a two-pass macro assembler for the Intel MCS-51 family of microcontrollers, using the batch file INSTALL.BAT. For someone who do not like anything that is running automatically, or things are not quite clear, here is an step-by-step installation guide for ASEM-51.

The files we require are ASEM-51 v1.3 for DOS/Windows (599 kB) and a collection of the latest MCU files (188 kB).

1. Create a new directory on your harddisk, e.g. C:\ASEM51 and unpack all files of the ASEM-51 package into this directory (see Figure 1.).

Figure 1.

2. Unpack MCUFILES into a directory (see Figure 2). Move the *.MCU you want to C:\ASEM51\MCU (see Figure 3). Here I move the P89V51RD2.MCU only.

Figure 2.

Figure 3.

3. Edit System Variable: Start-->right click on My Computer-->Properties. On System Properties click Advanced Tab then click Environment Variables. On System variables select Path then click Edit and append ;C:\ASEM51 in Variable value (see Figure 4).

Figure 4.

4. Define ASEM51INC environment variable: On System variables (from 3) click New the fill Variable name with ASEM51INC and Variable value with C:\ASEM51\MCU (see Figure 5).

Figure 5.

5. Click OK and close all windows.

6. You can test by typing asem in Command Shell (Start-->Run-->cmd). You should get something like this (see Figure 6).

Figure 6.

Learning Machine Code with 8-bit Microcontrollers

2007-04-01T15:34:00.002+07:00

To understand deeply in processor architecture, we have to learn the Machine Code. I decide to select the 8051 microcontroller as a microprocessor model. A microcontroller (or MCU) is a computer-on-a-chip. They integrate many modules on one chip such as RAM, Flash memory, EEPROM, serial ports (UARTs), I²C, Serial Peripheral Interface (SPI), analog-to-digital converters (ADC), clock generator (XTAL) and more.

Humans almost never write programs directly in machine code. Instead, they use a programming language which is translated by the computer into machine code. The simplest kind of programming language is assembly language which usually has a one-to-one correspondence with the resulting machine code instructions but allows the use of mnemonics (ASCII strings) for the "op codes" (the part of the instruction which encodes the basic type of operation to perform) and names for locations in the program (branch labels) and for variables and constants.

Installing ASEM-51

ASEM-51 is a two-pass macro assembler for the Intel MCS-51 family of microcontrollers. It is running on the PC under MS-DOS, Windows and Linux. The ASEM-51 assembly language is based on the standard Intel syntax, and implements conditional assembly, macros, and include file processing. The assembler can output object code in Intel-HEX or Intel OMF-51 format as well as a detailed list file. The ASEM-51 package includes support for more than 180 8051 derivatives, a bootstrap program for MCS-51 target boards, and documentation in ASCII and HTML format. And it is free ...

The simplest way of installing ASEM-51 is copying all files of the package to your working directory, and enjoy the benefits of true plug-and-play compatibility!. Alternatively, I have set it up on Windows XP manually:

Downloads the lastest ASEM-51 for DOS/Windows (currently v1.3)

Create a new, empty directory on your harddisk (C:\ASEM51).

Unpack your ASEM-51 distribution archive into this directory, or copy all files of the ASEM-51 package into it.

Make the scratch directory default, run the batch file INSTALL.BAT provided, and follow the instructions.

Reboot your PC.

You can update MPU file by downloading http://plit.de/asem-51/mcufiles.zip.

References

Wikipedia

machine code from FOLDOC

Installing MIDE-51 and SDCC and for Win32

Understanding Processor Architecture: Simplify Computer Complexity

2007-03-27T16:21:00.001+07:00

Computers are complex systems. We study computer systems by using layers of abstraction. We use a hierarchical structure to simplify the management. Each level of management filters out unnecessary details on the lower levels and presents only an abstracted version to the higher-level management.

People can look at computer systems from several different perspectives depending on the type of their interaction. We use the concept of abstraction to look at only the details that are necessary from a particular viewpoint. For example, a computer user interacts with the system through an application program. Suppose you are interested in browsing the Internet. Your obvious choice is to interact with the system through a Web browser such as the Fire fox (FF) or Internet Explorer (IE). On the other hand, if you are a computer architect, you are interested in the internal details that do not interest a normal user of the system.

From the programmer’s viewpoint, there exists a hierarchy from low-level languages to high-level languages (see Figure 1). At the lowest level, we have the machine language that is the language understood by the machine hardware. Because digital computers use 0 and 1 as their alphabet, machine language naturally uses 1s and 0s to encode the instructions. One level up, there is the assembly language as shown in Figure 1. Assembly language does not use 1s and 0s; instead, it uses mnemonics to express the instructions. Assembly language is closely related to the machine language.

Figure 1. Abstract layers of Computer Systems

References

Guide to RISC Processors for Programmers and Engineers by Sivarama P. Dandamudi, Springer (2005), ISBN 0-387-21017-2.

Understanding Processor Architecture: ISA

2007-03-26T16:59:00.001+07:00

A programmer uses the Instruction Set Architecture (ISA) as an abstraction to understand the processor’s internal details. This abstraction suits us very well as we are interested in the logical details of the processor without getting bogged down by the myriad implementation details.

The ISA specifies how a processor functions: what instructions it executes and what interpretation is given to these instructions. If these specifications are precise, they give freedom to various chip manufacturers to implement physical designs that look functionally the same at the ISA level. Thus, if we run the same program on these different implementations, we still get the same results. For example, the Intel 32-bit ISA (IA-32) has several implementations including the Pentium processors, cheaper Celeron processors, high-performance Xeon processors, and so on.

The ISA-level abstraction provides a common platform to execute programs. If a program is written in C, a compiler translates it into the equivalent machine language program that can run on the ISA-level logical processor. Similarly, if you write your program in FORTRAN, use a FORTRAN compiler to generate code that can execute on the ISA-level logical processor.

References

Guide to RISC Processors for Programmers and Engineers by Sivarama P. Dandamudi, Springer (2005), ISBN 0-387-21017-2.

OpenServo

2007-01-26T14:08:00.000+07:00

OpenServo is an open community-based project started by Mike Thompson with the goal of creating a low-cost digital servo for robotics. The hardware and software design of the OpenServo is free for anyone to use and modify to meet their particular needs. It is currently being developed by a small group of dedicated individuals striving to maintain the very best in free, open source software and standards. We hope that you will find the OpenServo project interesting and become a member of our community.

The OpenServo is a combination of hardware and software meant to replace the original PCB internal to low-cost analog RC servos such as the Futaba S3003 or HiTec HS-311

Some features of the OpenServo include:

High performance AVR 8-bit microcontroller
Compact H-Bridge implemented with low-cost MOSFET drivers
I2C/TWI based interface for control and feedback
Control over servo position and speed
Feedback of servo position, speed, voltage and power consumption
EEPROM storage of servo configuration information
Software written in C using free development tools
I2C/TWI based bootloader and Windows GUI programmer
Total cost about $20 per servo in quantity ($10 servo hardware + $10 parts)

Information can be found on this site regarding Hardware, Software and Tools & Utilities to create your own OpenServo.

Home page: http://openservo.com/

Piklab IDE for PIC and dsPIC microcontrollers

2007-01-24T10:50:00.000+07:00

Piklab is an integrated development environment for applications based on Microchip PIC and dsPIC microcontrollers similar to the MPLAB environment. Support for several compiler and assembler toolchains, programmers, debuggers and simulators is integrated. A command-line programmer and debugger is also available.

Piklab home: http://piklab.sourceforge.net/

New book explains how to build Linux 2.6 kernels

2006-12-26T19:37:00.000+07:00

O'Reilly has published a book for Linux users interested in learning to build their own kernels. Linux Kernel in a Nutshell describes how to build and install Linux 2.6 kernels, starting with downloading the source. It was written by well-known kernel hacker Greg Kroah-Hartman.

I think, this book is a starting point when you would like to learn the Embedded Linux for a Microcontroller, also the Real Time Operating System.

Source: http://oreilly.com/emails/press/9780596100797.html

Buy Linux Kernel in a Nutshell from Amazon.com

Eclipse for SDCC

2006-12-17T21:21:00.000+07:00

Although I use MIDE-51 as a major IDE, I still seek for the best (free) IDE for developing Microcontroller Programming. The combination of Eclipse, CDT and SDCC is an alternation tools for 8051 Microcontroller C Programming.

Eclipse is an open source community whose projects are focused on building an open development platform comprised of extensible frameworks, tools and runtimes for building, deploying and managing software across the lifecycle. Eclipse is used for Enterprise Development, Embedded and Device Development, Rich Client Platform, Application Frameworks and Language IDE.

The CDT is Eclipse's C/C++ Development Tooling project. It is an industrial strength C/C++ IDE that also serves as a platform for others to provide value added tooling for C/C++ developers.

The eclipseSDCC project aims to provide full support for the open source Small Device C Compiler (SDCC) from within the eclipse/CDT development environment. This allows embedded 'C' applications for 8051 and Z80 devices to be developed using the fully featured eclipse IDE. EclipseSDCC supports CDT managed make projects. In managed make projects CDT manages the build process by creating and maintaining the underlaying makefiles. CDT keeps track of source dependencies and can automatically rebuild the target when needed.

To install (for Windows)

It requires Java Runtime Environment (JRE), I download only JRE not SDK and install it.
Downlaod Eclipse SDK 3.2.1 for Windows (120 MB) and extract it to c:/eclipse. In the directory it contains eclipse.exe which is an executable.
Download CDT 3.1.1 (September 29, 2006) and extract it c:/eclipse, this will prompt to replace plugins and features directory.
If you have already installed SDCC for Window, skip this step. If you have no SDCC installed, read this first.
Download eclipseSDCC-1.0.0, when you extract the file, it contains plugins and features directory. Copy the two direct to c:\eclipse.

Now the installation have been completed and you can find its manual in c:/eclipse/plugins/net.sourceforge.eclipsesdcc_1.0.0/help/index.html.

Eclipse for SDCC is quite large when compared it MIDE-51. However, you can manage project in Eclipse whereas MIDE-51 still have no this feature in the present version. Here is a screen shot, you should see this dialog.

Related Links

What's coming up, MIDE-51?

2006-12-01T16:04:00.000+07:00

MIDE-51, by Worapoht Kornkaewwattanakul, is an IDE for MCS-51 microcontroller. The toolchain supports by ASEM-51 assembler, SDCC : Small Device C Compiler, TS Controls 8051 Emulator and JSIM-51 Simulator (see installation guide).

The current version is 0.2.5.10. The author is working for next major version 0.3.0.0, which supports SDCC multiple files project style. Hopefully, he will finish this version soon.

128KB Flash 8051 MCU from Atmel

2006-11-29T19:18:00.000+07:00

AT89C51RE2, an 8051 based microcontroller with 128kbyte of flash, has been launched from Atmel. The device is an addition to the existing 16-, 32- and 64Kbyte 8051 flash family of AT89C51RB2/RC2/RD2/ED2 MCUs. This new chip offers 8kbyte of ram, two UARTs, watchdog timer, power on reset, power fail detector and up to 50 general purpose I/Os. Suited to industrial and consumer applications, the AT89C51RE2 can operate from 2.7 to 5.5V and achieves a 4MIPS throughput when running at 40MHz.

A key feature is the on chip debug capability that enables low cost emulation. The hardware debug system with Windows IDE interface allows the user to access debugging functions built into the AT89C51RE2 resulting in faster development and verification of user code in real time.

The AT89C51RE2 is available in 44-pin PLCC and VQFP packages at $4.80 for 10,000 units.

Atmel offers the AT89STK-11, a starter kit for $99, to evaluate the AT89C51RE2; designers can either run the demonstration program or their own application. A new low-cost on-chip debug tool, AT89OCD-01 will be available by the end of November 2006.

Source: www.newelectronics.co.uk and www.eetasia.com

Low-cost ARM7TDMI Evaluation Board based on STR730FZ2T6

2006-11-28T14:28:00.000+07:00

Embest announced the availablity of the STDV730F, a low-cost development board based on STR730FZ2T6, ARM7TDMI 32-BIT processor from STMicroelectronics.

Features

256 Kbytes of flash
16 Kbytes of RAM
up to 16-channel 10-bit ADC
20 timers
4xUARTs
3xCANs
SPI
I2C
DMA
RTC
PWM
112 GPIO

The board integrates a 2x16 LCD, LEDs, UART, CAN interface, buzzer, test buttons and Jtag interface to create a versatile stand-alone test platform. The board itself is provided with plenty of example programs to help you startup with your design quickly.

Source: www.embedded-computing.com

ARM offers OpenMAX DL, free video codec software library

2006-11-27T17:25:00.000+07:00

ARM has made the source code for its sample implementation of OpenMAX DL (Development Layer) audio and video codec software library freely available for download from the company’s website. ARM’s sample OpenMAX DL software library provides source code written in C for easy platform portability and code readability.

OpenMAX is a royalty-free, cross-platform API developed by the Khronos Group that provides a comprehensive media codec and application portability by enabling accelerated multimedia components to be developed, integrated and programmed across multiple operating systems and silicon platforms. [OpenMAX]

ARM said it plans to create a series of libraries including an implementation that will take full advantage of the ARMv6 architecture found in the ARM11 family and an implementation for the NEON signal processing technology found in the Cortex-A8 processor.

Source: www.electronicsweekly.com

A Real-Time Operating System (RTOS) for the 8051

2006-11-26T12:29:00.000+07:00

A real-time operating system (RTOS) is a class of operating system intended for real-time applications, including embedded systems (programmable thermostats, household appliance controllers, mobile telephones), industrial robots, spacecraft, industrial control (see SCADA), and scientific research equipment [wikipedia]. It is an advance topic in Microcontroller and Embedded Systems.

FreeRTOS.org^TM is a portable, open source, mini Real Time Kernel - a free to download RTOS. It have been ported to support several microcontroller architectures - ARM7, ARM CORTEX M3, 8051, AVR (MegaAVR), x86, PIC18, PIC24, dsPIC, HCS12, H8S, RDC, ColdFire. FreeRTOS is licensed under a modified GPL and can be used in commercial applications under this license.

For the 8051, this RTOS have been ported to Cygnal (Silicon Labs) 8051. This is the starting point for anyone who would like to study the Operating System and Embedded Design on 8051. The Cygnal port was developed on a C8051F120-TB prototyping board fitted with a 8051F120 microcontroller. The freeware SDCC compiler was used along with the Cygnal IDE.

Building and executing the RTOS demo application

After downloads the freeRTOS source file (.exe or .zip), I extract the file to C:\FreeRTOS. The demo application for Cygnal 8051 is located in C:\FreeRTOS\Demo\Cygnal. To compiler this demo, it is require SDCC (see how to install) and GNU make. For Gnu make, I download UnxUtils.zip then extract it to C:\UnxUtils and finally edit PATH to C:\UnxUtils\usr\local\wbin (see how to edit PATH on 2000 and XP). In DOS Command Shell, change directory (cd) to C:\FreeRTOS\Demo\Cygnal and type make, the final product is main.ihx which the demo real time application for Cygnal 8051. However. the size of this file is quiet big, 72k. I have succeed compiling with SDCC 2.5.x but failed for SDCC 2.6.x.

In the conclusion, The demo application of the opensource freeRTOS have been ported to Cygnal 8051 which contains the demonstration source code. This is an avenue to learn the Real Time Operating System for the others 8051 chip.

A Simulator for P89V51RD2

2006-11-21T18:24:00.000+07:00

The Philips' P89V51RD2 is a 80c51 microcontroller which provides a set of powerful features:

Timer/Counter 2
PCA (Programmable Counter Array)
Watchdog timer

uCsim, the 8051 simulator for SDCC, supports various types of 8051 family and one of them is 89C51R. I think it close to the features of P89V51RD2 microcontroller as mentioned above.

To use, enter this commands:


$s51 -t 89c51r

which prompt you to uCsim command shell. You can view the special modules supported by uCsim by enter this in the uCsim shell:


0>conf
ucsim version 0.5.4
Type of microcontroller: 89C51R CMOS
Controller has 13 hardware element(s).
timer0[0]
timer1[1]
uart[0]
port[0]
port[1]
port[2]
port[3]
irq[0]
_51_dummy[0]
timer2[2]
wdt[0]
pca[0]
_89c51r_dummy[0]

Although this simulator is based on command line, it is free and powerful for the modern 8051 chips.

uCsim home: http://mazsola.iit.uni-miskolc.hu/%7Edrdani/embedded/s51/

Installing SDCC on Fedora Core 6

2006-11-15T19:04:00.000+07:00

I have upgraded my Linux to the latest version Fedora Core 6. This version come with linux kernel 2.6.18 and gcc v4.1.1. I don't hesitate to install the SDCC to work on it. After I downloaded the latest of SDCC source, sdcc-src-xxx-xxx.tar.bz2, I installed it with this command:

$tar -xvfz sdcc-src-xxx-xxx.tar.bz2
$cd sdcc
$./configure --prefix=/usr
$make
$make install

If it succeed, you should have these directories:
/usr/bin for execute files
/usr/share/sdcc/doc for documentation
/usr/share/sdcc/include for header files
/usr/share/sdcc/lib for libraries

I tested it with this simple code, I edited with gedit:


#include <8051.h>
void min() {
unsigned char var_1;
var_1 = 0xFF;
}

then saved it, let say test.c. To compile I use this command:

$sdcc test.c

and I found the test.ihx file in that directory which is the expected output.

uCsim: the 8051 simulator for SDCC

2006-11-10T15:25:00.000+07:00

uCsim is a microcontroller simulator for SDCC. It is free and opensource under GNU GPL. Currently it supports MCS51 family. AVR core, Z80, HC08 and XA are supported by UNIX version only.

For the 8051, the recognized types are: 51, 8051, 8751, C51, 80C51, 87C51, 31, 8031, C31, 80C31, 52, 8052, 8752, C52, 80C52, 87C52, 32, 8032, C32, 80C32, 51R, 51RA, 51RB, 51RC, C51R, C51RA, C51RB, C51RC, 89C51R, 251, C251, DS390, DS390F.

uCsim is available for two platforms: DOS (MCS51 only) and UNIX but DOS version is not supported any more. DOS version is not finished so I call it demo version and it is available in binary only. Limitations of DOS version are:

There is no built in help available;
Some of the utilities are not working, for example calculator, bit simulator;
Serial line works in mode 1 independently of mode bits.

If you are using the latest version of SDCC on Windows, uCsim is already in your hand (C:\Program Files\SDCC\bin). If you have not installed it yet, please see my installation guide.

Starting the Simulator

There are separate programs to simulate different microcontroller families:

MCS51 family is simulated by s51
AVR family is simulated by savr
Z80 processor is simulated by sz80
XA family is simulated by sxa
HC08 processor is simulated by shc08

The program can be started using following command:

C:\> s51 [input file]

Parameter is optional. If it specified it must be the name of an Intel hex file.

For more details, please see its documentation. This is an overview and I will write about this simulator later.

Migrating from demo compilers to SDCC

2006-11-09T13:15:00.000+07:00

I found these tips from SDCC manual pages and though that it should be useful. If you would like to migrate from a demo C Compiler with the limitation of code size, such as Keil C51 and Raisonance RIDE-51, to SDCC, please consider to port your present code to SDCC by following these instructions.

check whether endianness of the compilers differs and adapt where needed.
check the device specific header files for compiler specific syntax. Eventually include the file > to allow using common header files. (see f.e. cc2510fx.h).
check whether the startup code contains the correct initialization (watchdog, peripherals).
check whether the sizes of short, int, long match.
check if some 16 or 32 bit hardware registers require a specific addressing order (least significant or most significant byte first) and adapt if needed (first and last relate to time and not to lower/upper memory location here, so this is not the same as endianness).
check whether the keyword volatile is used where needed. The compilers might differ in their optimization characteristics (as different versions of the same compiler might also use more clever optimizations this is good idea anyway). See Common interrupt pitfall: variable not declared volatile.
check that the compilers are not told to supress warnings.
check and convert compiler specific extensions (interrupts, memory areas, pragmas etc.).
check for differences in type promotion. Especially check for math operations on char or unsigned char variables. For the sake of C99 compatibility SDCC will probably promote these to int more often than other compilers. Eventually insert explicit casts to (char) or (unsigned char). Also check that the ~ operator is not used on bit variables, use the ! operator instead. See sections TIPS and Compatibility with previous versions.
check the assembly code generated for interrupt routines (f.e. for calls to possibly non-reentrant library functions).
check whether timing loops result in proper timing (or preferably consider a rewrite of the code with timer based delays instead).
check for differences in printf parameters (some compilers push (va_arg) char variables as int others push them as char. See section Compatibility with previous versions).
check the resulting memory map. Usage of different memory spaces: code, stack, data (for mcs51/ds390 additionally idata, pdata, xdata). Eventually check if unexpected library functions are included.

Using Opensource tools like SDCC should be the advantage for study propose specially for the beginner and the hobbyist. However, for the serious engineering projects, the SDCC may not be the solution. The instructs above can also turn SDCC code to others compiler.

Robot technology running fast in Japan

2006-10-20T18:03:00.001+07:00

Robot technology has been moving really fast in Japan right now. Here is a demonstration: two Manoi-AT01 humanoid robots racing against each other.

MANOI (humanoid robot) is a product of KYOSHO. Please see the Design, Mechanism and Playing Events Innovation.

High performance driving of the Remote control Segway (a self balancing robot).

2006-10-15T21:58:00.000+07:00

This video shows the self-balancing robot spinning as it drives. All that the user needs to do is use the remote control to command direction and turning direction. The microcontroller does the rest.

This is a remote control Segway (a mini self balancing robot), named the Teetering Buffalo, built at Georgia Tech by graduate students Adam Cardi, Aaron Enes, and Matt Wagner.

Aaron Enes at Georgia Tech
21 sec - Jan 13, 2006
www.prism.gatech.edu

P89LPC9381; 8-bit microcontroller with accelerated two-clock 80C51 core 4 kB 3 V byte-erasable flash with 10-bit ADC

2006-09-20T09:35:00.000+07:00

The P89LPC9381 is a single-chip microcontroller, available in low-cost packages, based on a high performance processor architecture that executes instructions in two to four clocks, six times the rate of standard 80C51 devices. Many system-level functions have been incorporated into the P89LPC9381 in order to reduce component count, board space, and system cost.

Principal features

4 kB byte-erasable flash code memory organized into 1 kB sectors and 64 B pages. Single-byte erasing allows any byte(s) to be used as non-volatile data storage.

256 B RAM data memory on-chip RAM.

8-input multiplexed 10-bit ADC. Two analog comparators with selectable inputs and reference source.

Two 16-bit counter/timers (each may be configured to toggle a port output upon timer overflow or to become a PWM output) and a 23-bit system timer that can also be used as a RTC.

Enhanced UART with fractional baud rate generator, break detect, framing error detection, and automatic address detection; 400 kHz byte-wide I2C-bus communication port and SPI communication port.

High-accuracy internal RC oscillator option allows operation without external oscillator components. The RC oscillator option is selectable and fine tunable.

2.4 V to 3.6 V VDD operating range. I/O pins are 5 V tolerant (may be pulled up or driven to 5.5 V).

28-pin TSSOP package with 23 I/O pins minimum and up to 26 I/O pins while using on-chip oscillator and reset options.

Additional features

A high performance 80C51 CPU provides instruction cycle times of 111 ns to 222 ns for all instructions except multiply and divide when executing at 18 MHz. This is six times the performance of the standard 80C51 running at the same clock frequency. A lower clock frequency for the same performance results in power savings and reduced EMI.

Serial flash ICP allows simple production coding with commercial EPROM programmers. Flash security bits prevent reading of sensitive application programs.

Serial flash ISP allows coding while the device is mounted in the end application.

In-Application Programming of the flash code memory. This allows changing the code in a running application.

Watchdog timer with separate on-chip oscillator, requiring no external components. The watchdog prescaler is selectable from eight values.

Low voltage reset (brownout detect) allows a graceful system shutdown when power fails. May optionally be configured as an interrupt.

Idle and two different power-down reduced power modes. Improved wake-up from Power-down mode (a LOW interrupt input starts execution). Typical power-down current is 1 uA (total power-down with voltage comparators disabled).

Active-LOW reset. On-chip power-on reset allows operation without external reset components. A reset counter and reset glitch suppression circuitry prevent spurious and incomplete resets. A software reset function is also available.

Configurable on-chip oscillator with frequency range options selected by user programmed flash configuration bits. Oscillator options support frequencies from 20 kHz to the maximum operating frequency of 18 MHz.

Oscillator fail detect. The watchdog timer has a separate fully on-chip oscillator allowing it to perform an oscillator fail detect function.

Programmable port output configuration options: quasi-bidirectional, open-drain, push-pull, input-only.

Port 'input pattern match' detect. Port 0 may generate an interrupt when the value of the pins match or do not match a programmable pattern.

LED drive capability (20 mA) on all port pins. A maximum limit is specified for the entire chip.

Controlled slew rate port outputs to reduce EMI. Outputs have approximately 10 ns minimum ramp times.

Only power and ground connections are required to operate the P89LPC9381 when internal reset option is selected.

Four interrupt priority levels.

Eight keypad interrupt inputs, plus two additional external interrupt inputs.

Schmitt trigger port inputs.

Second data pointer.

Emulation support.

Distance Measurement Sensor

2006-09-16T10:50:00.000+07:00

GP2Y0A21YK is General Purpose Type Distance Measuring Sensors from Sharp. (see the product page). Sharp Infrared (IR) radiation Distance Measuring Sensor use Infrared signal to measure object distance from 10 to 80 cm with analog output.

Features

Less influence on the color of reflective objects, reflectivity

Line-up of distance output/distance judgement type

Distance output type (analog voltage) : GP2Y0A21YK

Detecting distance : 10 to 80cm

Distance judgement type : GP2Y0D21YK

Judgement distance : 24cm

(Adjustable within the range of 10 to 80cm [Optionally available])

External control circuit is unnecessary

Low cost

Applications

Personal computers

Cars

Copiers

Robots

The output of this sensor is analog therefore it need Analog to Digital Converter (ADC) to interface the 8051. I use ads7841 as ADC (see this article).

The graph of Analog voltage output versus distance to reflective object are shown in Fig.1. When I plot Analog voltage output versus inverse number distance, I found the linear relation shown in Fig.2.

Fig. 1 Analog voltage output (V) versus distance to reflective object (cm).

Fig. 2 Analog voltage output (V) versus inverse number distance (1/cm).

The linear equation is y = 20.99x + 0.19, where y is voltage output and x invert distance. Notice that the voltage output I can trust are about 0.4 to 2.8 V.

This is an example code how to interface the distance sensor to 8051. I use SDCC as C Compiler.


  #include <8051.h>

 #include "ads7841.h"

  void main()

 {

     float x,y; // Distance and Analog voltage output


     y = analog(0); // Read volt out if the sensor connect to channel 0 of ADS7841


     y = 0.00122*y; // Convert BCD to DEC by multiply voltage by 5/4096



     if ( (y > 0.4) && (y < 2.8) ) {

        x = (y-0.19)/20.99; // Solve the linear equation

        x = 1/x; // Inverse back get distance in cm.

    }

 }

Source:
test_irsensor.c
characteristic.txt (For plot with Spreadsheet)

Related Links
GP2Y0A21YK/GP2Y0D21YK Datasheet
Analog to Digital (ADS7841) Interfacing

Servo Motor Control

2006-09-16T10:41:00.001+07:00

Servos

Servos are DC motors with built in gearing and feedback control loop circuitry. And no motor drivers required. They are extremely popular with robot, RC plane, and RC boat builders. Most servo motors can rotate about 90 to 180 degrees. Some rotate through a full 360 degrees or more.

However, servos are unable to continually rotate, meaning they can't be used for driving wheels, unless they are modified (how to modify), but their precision positioning makes them ideal for robot legs and arms, rack and pinion steering, and sensor scanners to name a few. Since servos are fully self contained, the velocity and angle control loops are very easy to impliment, while prices remain very affordable. To use a servo, simply connect the black wire to ground, the red to a 4.8-6V source, and the yellow/white wire to a signal generator (such as from your microcontroller). Vary the square wave pulse width from 1-2 ms and your servo is now position/velocity controlled.

PWM

Pulse width modulation (PWM) is a powerful technique for controlling analog circuits with a processor's digital outputs. PWM is employed in a wide variety of applications, ranging from measurement and communications to power control and conversion. The general concept is to simply send an ordinary logic square wave to your servo at a specific wave length, and your servo goes to a particular angle (or velocity if your servo is modified). The wavelength directly maps to servo angle.The standard time vs angle is represented in this chart:

Figure: Pulse for controlling a Servo motor

Programmable Counter Array (PCA)

The PCA is a special modules in Philips P89V51RD2 which includes a special 16-bit Timer that has five 16-bit capture/compare modules associated with it. Each of the modules can be programmed to operate in one of four modes: rising and/or falling edge capture, software timer, high-speed output, or pulse width modulator. Each module has a pin associated with it in port 1.
Module 0 is connected to P1.3 (CEX0), module 1 to P1.4 (CEX1), etc. Registers CH and CL contain current value of the free running up counting 16-bit PCA timer. The PCA timer is a common time base for all five modules and can be programmed to run at: 1/6 the oscillator frequency, 1/2 the oscillator frequency, the Timer 0 overflow, or the input on the ECI pin (P1.2). The timer count source is determined from the CPS1 and CPS0 bits in the CMOD SFR.

In the CMOD SFR there are three additional bits associated with the PCA. They are CIDL which allows the PCA to stop during idle mode, WDTE which enables or disables the Watchdog function on module 4, and ECF which when set causes an interrupt and the PCA overflow flag CF (in the CCON SFR) to be set when the PCA timer overflows. The Watchdog timer function is implemented in module 4 of PCA. Here, we are interested only PWM mode.

8051 Pulse width modulator mode

All of the PCA modules can be used as PWM outputs. Output frequency depends on the source for the PCA timer. All of the modules will have the same frequency of output because they all share one and only PCA timer. The duty cycle of each module is independently variable using the module's capture register CCAPnL.When the value of the PCA CL SFR is less than the value in the module's CCAPnL SFR the output will be low, when it is equal to or greater than the output will be high. When CL overflows from FF to 00, CCAPnL is reloaded with the value in CCAPnH. this allows updating the PWM without glitches. The PWM and ECOM bits in the module's CCAPMn register must be set to enable the PWM mode. For more details see P89V51RD2 datasheet.

This is an example how to control servos with 8051 by using PWM. The schematic is shown below. I use P1.4 (CEX1) to control the left servo and P1.2 (CEX2) to control the right servo. Here, I use GWS servo motor model S03T STD. I need three states of duty cycle:

20 ms to Stop the servo

1 ms to Rotate Clockwise

2 ms to Rotate Counter-clockwise

Calculation for duty cycle (for XTAL 18.432 MHz with 6 Clock/Machine cycle)

Initial PWM Period = 20mS (18.432MHz /6-Cycle Mode)

Initial PCA Count From Timer0 Overflow

1 Cycle of Timer0 = (1/18.432MHz)x6 = 0.326 uS

Timer0 AutoReload = 240 Cycle = 78.125 uS

1 Cycle PCA = [(1/18.432MHz)x6]x240 = 78.125 uS

Period 20mS of PCA = 20ms/78.125us = 256 (CL Reload)

CL (20mS) = 256 Cycle Auto Reload

Load CCAPxH (1.0mS) = 256-13 = 243 (243,244,...,255 = 13 Cycle)

Load CCAPxH (2.0mS) = 255-26 = 230 (230,231,...,255 = 26 Cycle)

Schematic: Control RC Servos motors with 8051 PWM

Datasheet

- P89V51RD2 [pdf]

Source Code (For SDCC)

- pwm_servos.h

- test_servos.c

EEPROMs Interfacing

2006-09-16T10:34:00.001+07:00

24LC512 is a 64K x 8 (512 Kbit) Serial Electrically Erasable PROM (EEPROMs), from Microchip Technology Inc. (see the product page). It has been developed for advanced, low-power applications such as personal communications and data acquisition. This device also has a page write capability of up to 128 bytes of data.

This device is capable of both random and sequential reads up to the 512K boundary. Functional address lines allow up to eight devices on the same bus, for up to 4 Mbit address space.

This is an example how to interface 24XXX EEPROMs with 8051. I use SDCC as C Compiler. My schematic is shown below.

Schematic: 8051 interface to 24XXX EEPROMs

Datasheet
- 24LC512 [pdf]

Source Code (For SDCC)
- 24xx512.h
- test_eeprom.c

Note: require lcd.h and i2c.h

Related Links
-24LC512 Products Page
-Interfacing I2C EEPROM (24LC256) with MCS-51 (KEIL C51)

Real Time Clock Interfacing

2006-09-10T10:15:00.001+07:00

DS1307, a 64 x 8, Serial, I2C Real-Time Clock, is a low-power, full binary-coded decimal (BCD) clock/calendar plus 56 bytes of NV SRAM. Address and data are transferred serially through an I2C, bidirectional bus. The clock/calendar provides seconds, minutes, hours, day, date, month, and year information. It a product of Maxim/Dallas Semiconductor, see the product page.

This is an example how to interface DS1307 with 8051. I use SDCC as C Compiler. My schematic is shown below.

Schematic: 8051 interface to DS1307

Datasheet
- DS1307 [pdf]

Source Code (For SDCC)
- ds1307.h
- test_ds1307.c

Note: require lcd.h and i2c.h

Related Links
- DS1307 Products Page
- Interfacing I2C RTC (DS1307) with MCS-51 (KEIL C51)

I²C Bus Interfacing

2006-09-09T23:18:00.001+07:00

I²C bus (Inter-Integrated Circuit) is a bidirectional, half duplex, two-wire, synchoronous bus, originally designed for interconnection over short distances within a piece of equipment. The I2C bus uses two lines called Serial Clock Line (SCL) and Serial Data Lines (SDA). Both lines are pulled high via a resistor (Rpu) as shown in Figure below. The bus is defined by Philips, see more details.

Three speed modes are specified: Standard; 100kbps [Bits per Second], Fast mode; 400kbps, High speed mode 3.4Mbps. I2C, due to its two-wire nature (one clock, one data) can only communicate half-duplex. The maximum bus capacitance is 400pF, which sets the maximum number of devices on the bus and the maximum line length.

The interface uses 8 bit long bytes, MSB (Most Significant Bit) first, with each device having a unique address. Any device may be a Transmitter or Receiver, and a Master or Slave. The Slave is any device addressed by the Master. A system may have more than one Master, although only one may me active at any time.

Data and clock are sent from the Master: valid while the clock line is high. The link may have multiple Masters and Slaves on the bus, but only one Master may be active at any one time. Slaves may receive or transmit data to the master.

This is an example how to interface I²C with 8051. I use SDCC as C Compiler. My schematic is shown below. I set P2.6 as SCL and P2.7 as SDA.

Schematic: I²C Bus

Datasheet
I²C-Bus Specification [pdf]

Source Code (For SDCC)
- i2c.h

Note: see DS1307 and 24LC512 for applications

Analog-to-Digital Interfacing

2006-09-08T23:02:00.001+07:00

The ADS7841 is a 4-channel, 12-bit sampling Analog-to-Digital Converter (ADC) with a synchronous serial interface. The resolution is programmable to either 8 bits or 12 bits. It is a product of Burr-Brown form Texas Instrument, see the product page.

This ADC give the 12-bit Binary Code Decimal (BCD) output value therefore the maximum value is 999 integer. If we want to convert this value to the real value, we must divide this value by 4096 (12-bit) and multiply by the maximum real ouput. Suppose the real maximum of output is 5V, the ratio should be 5/4096 = 0.00122. We can use 0.00122 multiply the output from ADS7841 to get the real ouput value.

This is an example how to interface ADS7841 with 8051. I use SDCC as C Compiler. My schematic is shown below. I still do not convert to the real value so my variables are integer.

Schematic: 8051 interface to ADS7841

Datasheet
- ADS7841 [pdf]

Source Code (For SDCC)
- ads7841.h
- test_ads7841.c

Note: require lcd.h

Related Links
- ADS7841 Products Page

LCD interfacing

2006-09-07T22:51:00.001+07:00

This is an example how to interface to the standard Hitachi-44780 LCD using an 8051 microcontroller and SDCC as C Compiler. I use a standard 16-character by 2-line LCD module, see schematic below. Here, I use 4-bit interfacing.

Schematic: 4-bit interfacing 16x2 LCD

Source Code (For SDCC)
- lcd.h
- test_lcd.c

Installing MIDE-51 and SDCC and for Win32

2006-09-06T11:20:00.000+07:00

This page is an installation guide for someone who are interested in developing 8051 microcontrllor with C-language. All of tools I selected are freeware or opensource with no limitation of number of lines of your code.

Contents

Installing MIDE-51, Editor for 8051

Installing SDCC, C Compiler for 8051

Installing ASEM-51, Assembler for 8051

Installing JSIM-51, Simulator for 8051

Installing FlashMagic, ISP for Philips MPU

Configuration

Test

1. Installing MIDE-51
MIDE-51 is freeware Integrated Development Environment (IDE) for MCS-51 microcontroller. The full package already comes with:

Assembler : ASEM-51 by W.W.Heinz (v1.3)
C compiler : SDCC: Small Device C Compiler (v2.5.4)
Simulator : TS Controls 8051 Emulator v1.0 evaluation (Owner : http://www.tscontrols.com was gone)
Simulator : JSIM-51 Simulator by Jens Altmann (v4.05)

Just downloads midepack0258.exe and executes this file, everything will setup completely.

Feature on MIDE-51:

Syntax highlighter on ASEM-51 reserved word & addition register on selected device (devices listed on ASEM51/MCU folder)

Syntax highlighter on SDCC reserved word & MCS-51 standard register

Support multi document workspace

Support standard editor feature and shortcut key such as Cut , Copy, Paste, Find, Replace and Windows tile & cascade

Editor font style and size selectable

Save recent file(s) opened in list

Shortcut to ASEM-51 html manual

Shortcut to SDCC html & PDF manual (search file on SDCC/DOC)

Report assembler & compiler message

Support drag and drop file from explorer.

Automatic save last windows position.

Support wheel mouse

Bookmark code position upto 10

Show/Hide line number on editor

However, if you would like to use the newer version of them, you can also install each package manualy. First, downloads only editor version of MIDE-51 ( MIDE51_0258.zip) and extracts it to any directory (C:\MIDE51). You should have C:\MIDE51\MIDE51.EXE. For others package, please follow these instructions.

2. Installing SDCC
SDCC is a Freeware, retargettable, optimizing ANSI - C compiler that targets the Intel 8051, Maxim 80DS390, Zilog Z80 and the Motorola 68HC08 based MCUs. Work is in progress on supporting the Microchip PIC16 and PIC18 series. The entire source code for the compiler is distributed under GPL.

To install the SDCC, download the latest version from http://sdcc.sourceforge.net/snap.php#Windows (currently v2.6.x). SDCC are available for several different operating systems. I am working on a PC running Microsoft Windows XP therefore I download the win32 self-executing SDCC install file
(sdcc-20060818-4339-setup.exe) and run the executable. By default, it will install all files to C:\Program Files\SDCC, you also can change to any directory.

When finishing installing the program, a prompt will appear asking to add the directory containing the program binaries to your PATH. I also recommend you to download the SDCC documentation (sdcc-doc-20060818-4339.zip), and extract it to your SDCC documentation directory (C:\Program Files\SDCC\doc).

3. Installing ASEM-51
ASEM-51 is a two-pass macro assembler for the Intel MCS-51 family of microcontrollers. It is running on the PC under MS-DOS, Windows and Linux. The ASEM-51 assembly language is based on the standard Intel syntax, and implements conditional assembly, macros, and include file processing. The assembler can output object code in Intel-HEX or Intel OMF-51 format as well as a detailed list file. The ASEM-51 package includes support for more than 180 8051 derivatives, a bootstrap program for MCS-51 target boards, and documentation in ASCII and HTML format. And it is free ...

The simplest way of installing ASEM-51 is copying all files of the package to your working directory, and enjoy the benefits of true plug-and-play compatibility!. Alternatively, I have set it up on Windows XP manually:

Downloads the lastest ASEM-51 for DOS/Windows (currently v1.3)

Create a new, empty directory on your harddisk (C:\ASEM51).

Unpack your ASEM-51 distribution archive into this directory, or copy all files of the ASEM-51 package into it.

Make the scratch directory default, run the batch file INSTALL.BAT provided, and follow the instructions.

Reboot your PC.

You can update MPU file by downloading http://plit.de/asem-51/mcufiles.zip.

4. Installing JSIM-51
JSIM-51 is a powerful software simulator for 8051 Microcontrollers and it's derivatives. The program simulates the processor kernel and some of the hardware functions. It was born due to all commercial products are too expensive for private users. It is free and opensource.

To install:

Download 8051.zip ( DLL for simulation of a standard-8051 , V1.017 - 09/17/1998)

Download 80320.zip ( DLL for simulation of a 80320 -Dallas , V1.019 - 10/03/2000)

Download jsim_e.zip ( english version V4.05 from 01/08/2000)

Extract all files i.e., jsim.exe, 8051.dll and 80320.dll to your directory (C:\Jsim51).

5. Installing FlashMagic ISP Software
Flash Magic is a free, powerful, feature-rich Windows application that allows easy programming of Philips Flash Microcontrollers. Its function is to download compiled HEX file to your (Philips) microcontroller.

Please download and install the current version of FlashMagic.exe here.

6. Configuration
To combine every things:

Execute MIDE-51.exe

From menu bar, Edit-->Preference (F12)

Click Tab C-Compiler, Edit your SDCC Path (C:\Program Files\SDCC)

Click Tab Assembler, Edit your ASEM-51 Path (C:\ASEM51).

Click Tab Simulaotr, Simulator Profile, select JSIM with 8051.dll, edit Execute file (Full path and filename) C:\JSIM51\jsim.exe.

Now, everything is complete

7. Test

Execute MIDE-51.exe and File-->New (Ctrl+N), edit this code

#include <p89v51rd2.h>
unsigned char i;
void main() {
i=10;
}

Save to anyname.c and then Build (F9). You will found many files in the directory, one of them is .HEX file which can be downloaded to your MCU by using FlashMagic. Or, you can simulate it by using Jsim51, Build and Sim (Shift+Ctrl+F9).

Note: I tested on my P89V51RD2 MPU. Enjoy your 8051 microcontroller.

Related Links

Product Page: http://www.semiconductors.philips.com/

Data Sheet: P89V51RB2_RC2_RD2-03.pdf

Boot Loader: p89v_lv51rd2_bl_upd_v5.zip

FlashMagic ISP Software: http://www.esacademy.com/

SDCC : http://sdcc.sourceforge.net/

MIDE-51 : http://www.opcube.com/home.html

ASEM-51 : http://plit.de/asem-51/home.htm

JSIM-51 : http://home.arcor.de/jensaltmann/jsim-e.htm

Introduction to SDCC: Small Device C Compiler

2006-09-05T11:16:00.000+07:00

SDCC is a Freeware, retargettable, optimizing ANSI - C compiler that targets the Intel 8051, Maxim 80DS390, Zilog Z80 and the Motorola 68HC08 based MCUs. Work is in progress on supporting the Microchip PIC16 and PIC18 series. AVR and gbz80 ports are no longer maintained. The entire source code for the compiler is distributed under GPL.

Some of the features include:

ASXXXX and ASLINK, a Freeware, retargettable assembler and linker.

extensive MCU specific language extensions, allowing effective use of the underlying hardware.

a host of standard optimizations such as global sub expression elimination, loop optimizations (loop invariant, strength reduction of induction variables and loop reversing ), constant folding and propagation, copy propagation, dead code elimination and jump tables for 'switch' statements.

MCU specific optimisations, including a global register allocator.

adaptable MCU specific backend that should be well suited for other 8 bit MCUs

independent rule based peep hole optimizer.

a full range of data types: char (8 bits, 1 byte), short (16 bits, 2 bytes), int (16 bits, 2 bytes), long (32 bit, 4 bytes) and float (4 byte IEEE).

the ability to add inline assembler code anywhere in a function.

the ability to report on the complexity of a function to help decide what should be re-written in assembler.

a good selection of automated regression tests.

SDCC also comes with the source level debugger SDCDB, using the current version of Daniel's s51 simulator. (Currently not available on Win32 platforms).

SDCC was written by Sandeep Dutta and released under a GPL license. Since its initial release there have been numerous bug fixes and improvements. As of December 1999, the code was moved to SourceForge where all the "users turned developers" can access the same source tree. SDCC is constantly being updated with all the users' and developers' input.

SDCC Homepage
- http://sdcc.sourceforge.net/

Philips P89V51RD2 Microcontroller

2006-09-04T11:11:00.000+07:00

I am using Philips P89V51RD2 as 8051 Microcontroller Unit (MCU). And I have been developing my code with Opensouce C Compiler SDCC. Please visit my Tools page for software preparation guides.

The P89V51RD2 is a 80C51 microcontroller with 64 kB Flash and 1024 bytes of data RAM. A key feature of the P89V51RD2 is its X2 mode option. The design engineer can choose to run the application with the conventional 80C51 clock rate (12 clocks per machine cycle) or select the X2 mode (6 clocks per machine cycle) to achieve twice the throughput at the same clock frequency. Another way to benefit from this feature is to keep the same performance by reducing the clock frequency by half, thus dramatically reducing the EMI.

The Flash program memory supports both parallel programming and in serial In-System Programming (ISP). Parallel programming mode offers gang-programming at high speed, reducing programming costs and time to market. ISP allows a device to be reprogrammed in the end product under software control. The capability to field/update the application firmware makes a wide range of applications possible.

The P89V51RD2 is also In-Application Programmable (IAP), allowing the Flash program memory to be reconfigured even while the application is running.

Features

80C51 Central Processing Unit

5 V Operating voltage from 0 MHz to 40 MHz

64 kB of on-chip Flash user code memory with ISP (In-System Programming) and IAP (In-Application Programming)

Supports 12-clock (default) or 6-clock mode selection via software or ISP

SPI (Serial Peripheral Interface) and enhanced UART

PCA (Programmable Counter Array) with PWM and Capture/Compare functions

Four 8-bit I/O ports with three high-current Port 1 pins (16 mA each)

Three 16-bit timers/counters

Programmable watchdog timer

Eight interrupt sources with four priority levels

Second DPTR register

Low EMI mode (ALE inhibit)

TTL- and CMOS-compatible logic levels

Brown-out detection

Low power modes

o Power-down mode with external interrupt wake-up

o Idle mode

DIP40 packages

Related Links
Product Page: http://www.semiconductors.philips.com/
Data Sheet: P89V51RB2_RC2_RD2-03.pdf
Boot Loader: p89v_lv51rd2_bl_upd_v5.zip
FlashMagic ISP Software: http://www.esacademy.com/

Introduction to 8051 Microcontroller

2006-09-03T11:06:00.000+07:00

The 8051 is an 8 bit microcontroller originally developed by Intel in
1980. It is the world's most popular microcontroller core, made by
many independent manufacturers (truly multi-sourced). There were 126
million 8051s (and variants) shipped in 1993!!

A typical 8051 contains:

CPU with boolean processor

5 or 6 interrupts:
2 are external

2 priority levels

2 or 3 16-bit timer/counters

programmable full-duplex serial port
(baud rate provided by one of the timers)

32 I/O lines (four 8-bit ports)

ROM/EPROM in some models

One strong point of the 8051 is the way it handles interrupts.
Vectoring to fixed 8-byte areas is convenient and efficient. Most
interrupt routines are very short (or at least they should be), and
generally can fit into the 8-byte area. Of course if your interrupt
routine is longer, you can still jump to the appropriate routine from
within the 8 byte interrupt region.

The 8051 instruction set is optimized for the one-bit operations so
often desired in real-world, real-time control applications. The
boolean processor provides direct support for bit manipulation. This
leads to more efficient programs that need to deal with binary input
and output conditions inherent in digital-control problems. Bit
addressing can be used for test pin monitoring or program control
flags.

See full information from 8051 FAQ
- http://www.faqs.org/faqs/microcontroller-faq/8051/