Tuesday, January 27, 2009

0282094700 who calls me??


Who calls me from 0282094700 Number?
  • calling you at unusual time (to early in the morning?)
  • you ring back and you can hear only fax tone...
I figured few answers to this .. (this some one my by)
  • This is not an Australian number for sure...
  • some international caller using a calling card
  • someone using skype to contact you..

Sunday, January 25, 2009

Linux Atmel AVR Tutorial


The Atmel AVR family is a set of powerful microcontrollers that were designed to be used with the C programming language. You can now compile a C program for the AVRs with gcc, then load the program onto the chip using an inexpensive programmer and free tools. For Linux users who want to work on digital electronics, robotics, and automation, these chips are the way to go. This page is a step-by-step tutorial that presents the simplest, cheapest way to start experimenting with AVRs.

Specifically, on this page you'll find instructions for assembling and programming the AVR ATmega32 using a AVR-P40-USB prototyping board from Olimex (available at Sparkfun) and an AVR programmer that can be purchased from Digi-key. The ability to install programs on your Linux computer is the only skill required. It will cost you about $60 and 50M of disk space, and you'll be up and running about three hours after you unpack the electronics.
1. Order electronic parts

Order the AVR-P40-USB from Sparkfun; buy it with the USB extension cable - this will be used for power and serial communication (total price: $37.50). Also order the ATAVRISP-ND programmer for $29 from Digi-key. As long as you are putting in Digi-key order, you'll want to get some miscellaneous electronics for future experimentation. That is however beyond the scope of this tutorial.
picture of assembly
2. Plug in

After familiarizing yourself with your new electronics, attach the rubber feet to the prototyping board, connect the usb cable to your computer, and attach the programmer via serial port as shown. The LED on the programmer will cycle through several colors and stop on green if everything is okay.
3. Install software

You'll need a computer running linux to get gcc running; you could probably also set this stuff up under cygwin. I used Slackware 10, but the same instructions should work on any modern linux system.

Get binutils-2.16 from ftp://ftp.gnu.org/gnu/binutils/. Untar the archive and make a separate directory in which to build it. From this directory, install with

../binutils-2.16/configure --target=avr --prefix=/usr/local/atmel
make install

Get gcc-core-4.0.1 from ftp://ftp.gnu.org/gnu/gcc/. Again make a separate directory and install with

export PATH=/usr/local/atmel/bin:$PATH
../gcc-4.0.1/configure --target=avr --prefix=/usr/local/atmel --enable-languages=c
make install

Get the latest avr-libc.

./configure --build=`./config.guess` --host=avr --prefix=/usr/local/atmel
make install

Get the latest Uisp, the program you will use to access the AVRISP. Install with

make install

Try a simple program

Save this code as blink.c:

#define F_CPU 10000000UL

void delayms(uint16_t millis) {
uint16_t loop;
while ( millis ) {

int main(void) {
DDRB |= 1< while(1) {
PORTB &= ~(1< delayms(100);
PORTB |= 1< delayms(900);
return 0;

And save this as Makefile:

CFLAGS=-g -Os -Wall -mcall-prologues -mmcu=atmega32

program : $(TARGET).hex
$(UISP) -dprog=stk500 -dserial=/dev/ttyS1 --erase -dpart=atmega32
$(UISP) -dprog=stk500 -dserial=/dev/ttyS1 --upload -dpart=atmega32 \
if=$(TARGET).hex -v=2
%.obj : %.o
$(CC) $(CFLAGS) $< -o $@

%.hex : %.obj
$(OBJ2HEX) -R .eeprom -O ihex $< $@

clean :
rm -f *.hex *.obj *.o

With the programmer plugged in, type make. Your LED should now start to blink!
Further reading

* The avr-gcc homepage contains essential documentation on the software base you need to use to write programs for the ATmega32. This is where to look for the definition of predefined functions like sbi.
* The offical Atmel page on ATmega32 has the complete manual.
* The gcc documentation has lots of help on compiler options.
* The AVR Freaks page on ATmega32 links to lots of information about the chip and related software and hardware.

Atmel AVR Microcontroller on Linux

You'll enjoy the programming ease and built-in peripherals of the new generation of microcontrollers. Best of all, with these tools you can develop for the popular AVR series using a Linux host.

Whether you are creating a small Internet appliance, some hardware instrumentation, data loggers or an army of autonomous robots to do your bidding, in numerous situations you need the flexibility of a programmable computer. In many cases, a general-purpose system, such as the workhorse sitting under your desk, doesn't meet size, cost or power-consumption constraints and is simply overkill. What you need is a microcontroller.

This article provides step-by-step instructions for setting up a complete development system for the Atmel AVR series of microcontrollers, using free software and Linux. The detailed instructions provided here will allow you to transform your Linux system into a complete AVR development environment. This article walks you through all the steps of building, debugging and installing a simple program.

What Is a Microcontroller?

When all the electronic components required to make a central processing unit (CPU)—instruction decoder, arithmetic/logic unit, registers and so on—are integrated into a single chip, you have a microprocessor. When, in turn, you bundle this CPU with supporting components, memory and I/O peripherals, you've got a microcomputer. Extending the integration and miniaturization even further, you can combine all the elements of a microcomputer onto a single integrated circuit—behold the microcontroller.

The semiconductor industry evolves rapidly, making it difficult to provide an accurate and complete definition of the term microcontroller. Consider this: some microcontroller chips have capacities and clock speeds that surpass the 74KB of program memory and 4KB of RAM available to the 30kg Apollo Lunar Module computer. You can expect today's screamer PCs to be running tomorrow's embedded applications, with the definition of microcontroller shifting accordingly.

Microcontrollers all have a microprocessor core, memory and I/O interfaces, and many have additional peripherals onboard. The specific configuration of a particular chip influences its physical packaging, number of pins and cost. If you are accustomed to working with microcomputers, you may feel that microcontrollers are tight spots. They have a handful of kilobytes of program ROM and in the area of 256 bytes of RAM. Don't fret though; a lot can be done in this space, as the MIT Instrumentation Lab demonstrated when developing the Apollo Lunar Module software that controls its moon landing, return from the surface and rendezvous in orbit.

AVR Microcontrollers

The AVRs are 8-bit RISC platforms with a Harvard architecture (program and data memory are separate). Figure 1 details the ATtiny26 AVR chip internal organization. Like each member of a family, it has its own particular combination of I/O and peripherals, but it shares a basic architecture and instruction set with all the other AVRs. The ATtiny26 has 2KB of program Flash memory, 128 bytes of onboard SRAM and EEPROM, two 8-bit counters and pulse-width modulators, 11 interrupts, 16 I/O pins spread over two 8-bit ports, an 11-channel 10-bit analog-to-digital converter and more—all on a single tiny 20-pin DIP.

A number of factors make the AVR microcontrollers a good choice, especially for beginners. AVRs are:

  • Easy to code for: AVRs were designed from the ground up to allow easy and efficient programming in high-level languages, with a particular focus on C.

  • Easy to program: the combination of onboard reprogrammable Flash program memory and the in-system programming interface keeps the process of transferring software to the microcontroller simple and cheap.

  • Powerful and inexpensive: AVRs pack a lot of power (1 MIPS/MHz, clocks up to 16MHz) and space (up to 128K of Flash program memory and 4K of EEPROM and SRAM) at low prices. Most AVRs even include additional peripherals, such as UARTs and analog-to-digital converters.

  • Hobbyist-friendly: most of the chips in the AVR family come in easy-to-use 8-, 20-, 28- or 40-pin dual in-line packages (DIPs) and can be ordered in unit quantities from a number of distributors.

Figure 1. ATtiny26 Block Diagram


The processor core, composed of the components in the upper-left portion of Figure 1, includes elements to read the program memory and to decode and execute the instructions within that memory. The CPU also can fetch and store data to and from the EEPROM, SRAM and the 32 registers. The registers act as extremely efficient storage for 8-bit values (1 byte), and the ALU (arithmetic/logic unit) can operate directly on each of the 32 registers. This AVR features a RAM-based stack. In a few other AVRs, which don't have any SRAM, the stack is hardware-based, limiting the stack depth to three.

Most instructions take only a single clock cycle to execute, and there is no internal clock division on AVRs. The CPU fetches and decodes the next instruction as it is executing the current instruction. These combined facts mean that AVRs can reach performances of nearly 1 MIPS (million instructions per second) per MHz. With clock rates of up to 16MHz, you can choose the right balance of speed, power consumption and electromagnetic noise for your particular application.


Program space is a contiguous block of Flash memory, 16-bits wide that can be erased/rewritten 10,000 times. You can design your circuit to allow firmware upgrades in-circuit, using in-system programming.

All AVRs have some EEPROM, and most have SRAM; both are 8-bits wide. The EEPROM is designed to withstand at least 100,000 erase/write cycles. EEPROM is useful because it can be written from within your embedded program to retain data, even without a power supply, or during programming, such as for production-line calibration.

I/O and Peripherals

All AVRs, from the tiny 8-pin DIPs to the 44-pin Megas, have at least one data port. Data ports allow for input or output of logic-level data. The AVR ports are bidirectional, allowing you to set them for input or output on a pin-by-pin basis.

Many of the AVRs include additional hardware peripherals, such as UARTs for serial communication and calibrated RC oscillators used as internal system clocks. The external pins often serve two or more purposes, and how they are used depends on how you've configured the microcontroller. For instance, Figure 1 shows that certain I/O lines from both ports can be used with the multiplexed A/D converter.

Development Workstation Setup

The set of tools described here isn't the only one available, but it allows you to do basically anything, and the tools function well together. The toolkit is comprised of Binutils, GCC, AVR Libc and our Makefile template to write and build programs for the AVR microcontrollers; GDB and simulavr to debug your software; and avrdude as well as a hardware programmer to transfer your software to the microcontrollers. See the on-line Resources for download URLs for all software.

Fortunately, the recent versions of all these tools include support for the AVR platform, so installation is straightforward. We assume you've chosen to install everything under /usr/local/AVR.


Download a fresh copy of the current binutils source by following the link in the Resources. Untar the source, move into the binutils-X.XX directory and run:

$ ./configure --prefix=/usr/local/AVR --target=avr
$ make
# make install

The /usr/local/AVR/bin directory now contains AVR versions of ld, as, ar and the other binutils executables. Add the /usr/local/AVR/bin directory to your PATH now. You can apply the modification system-wide by adding:


to the /etc/profile file. Make sure the directory is in your PATH and that the change has taken effect before proceeding.


After retrieving a recent release of the Gnu Compiler Collection from a mirror, run the following commands from within the unpacked top-level source directory:

$ ./configure --prefix=/usr/local/AVR \
--target=avr --enable-languages="c,c++" \
$ make
# make install

This builds C and C++ compilers for AVR targets and installs avr-gcc and avr-g++ in /usr/local/AVR/bin.

AVR Libc

The AVR Libc package provides a subset of the standard C library for AVR microcontrollers, including math, I/O and string processing utilities. It also takes care of basic AVR startup procedures, such as initializing the interrupt vector table, stack pointer and so forth. To install, get the latest release of the library and run the following from the top-level source directory:

$ unset CC
$ PREFIX=/usr/local/AVR ./doconf
$ ./domake
# ./domake install
Makefile Template

The Psychogenic team has created a standard Makefile template that simplifies AVR project management. You can customize it easily for all your assembly, C and C++ AVR projects. It provides everything for a host of make targets, from compilation and upload to the microcontroller to debugging aids, such as source code intermixed with disassembly, and helpful gdbinit files. A detailed discussion of the template is available, and the Makefile template is available as Listing 1 on the Linux Journal FTP site (see Resources). Store the template with the other AVR tools, moving it to /usr/local/AVR/Makefile.tpl.

GDB and SimulAVR

Using avr-gdb and simulavr in tandem, you can run your software on a choice of AVR microcontrollers through the simulator, while using GDB to step through and observe the executing code. Acquire the simulavr source from the project site and perform the installation:

$ ./configure --prefix=/usr/local/AVR \
$ make # make install

Install GDB, built for AVR targets, by compiling the source as follows:

$ ./configure --target=avr \
$ make
# make install

When you finally have a program ready for testing on actual hardware, you need some way to upload the data and write it to the microcontroller's Flash program memory. AVRDUDE and a compatible hardware programmer are the last components of the development kit. Grab a copy of the AVRDUDE source and install it with:

$ ./configure --prefix=/usr/local/AVR
$ make
# make install

You now have installed every software component required for a complete AVR development environment. All you need is the physical means to transfer programs to microcontrollers.

AVRDUDE supports a number of different hardware programmer configurations. The simplest systems are described on the AVRDUDE site and are comprised of little more than a parallel port connector, a ceramic oscillator and a DIP socket. These are powered directly off the computer's port and may not work for everyone.

Figure 2. Home-Brew PPI Programmer PCB

A step up in complexity, independently powered, buffered in-system programmers can be built easily (see Resources). Two programmers requiring only a few parts are discussed on the Psychogenic Web page, which describes the schematics, provides artwork and has complete instructions on creating your own printed circuit boards (as depicted in Figure 2) for the programmers.

Figure 3. Atmel STK500 Development Kit

A number of commercial solutions also are available. If you're interested in easily programming a wide selection of the AVR family, go with Atmel's STK500 kit. More than a simple programmer, the STK500 is a starter kit that allows you to program the microcontrollers and easily prototype new designs. It includes a number of LEDs and switches, an oscillator, RS-232 interface and other niceties that easily can be interfaced with your target chip.

A Complete AVR Project

Our focus here is on the development system rather than on programming for the AVR platform. The AVR Libc documentation is a good place to start for information on programming AVRs in Assembly, C and C++.

The Hello World program of the microcontroller universe is the classic flashing LEDs. A slightly different take on this theme, which Knight Rider fans should appreciate, is available on the Linux Journal FTP site, where you can download C (Listing 2) or C++ (Listing 3) versions of an example program that cycles each of eight light-emitting diodes (LEDs) back and forth.

Building the Program

Create a project directory—for instance, ~/helloavr/—and retrieve the program, saving Listing 2 as ~/helloavr/kr.c and Listing 3 as ~/helloavr/kitt.cpp. Also, copy the Makefile template, /usr/local/AVR/Makefile.tpl, to ~/helloavr/Makefile.

Using this Makefile is easy and makes compilation a snap. Open the Makefile in your favourite editor and modify the configuration section, near the top of the file, so that the MCU, PROJECTNAME and PRJSRC variables are set as shown in Listing 4. The MCU variable determines the AVR family member for which we are compiling the program, and the PRJSRC variable lists all the Assembly, C and C++ source files used in the project.

Once you've configured the Makefile, compiling and linking the program is as simple as typing make.

You can perform the compilation and linking steps manually instead, by issuing:

  $ avr-gcc -I.  -g -mmcu=at90s8515 -Os       \
-fpack-struct -fshort-enums \
-funsigned-bitfields -funsigned-char \
-Wall -Wstrict-prototypes -c kr.c

$ avr-gcc -o helloavr.out kr.o

The most notable difference is the addition of the required -mmcu command-line argument, used to specify the target microcontroller. Either method compiles kr.c and creates the helloavr.out ELF-format program. This file cannot be executed on your development station but is used later during the debugging stage.

You also can build the C++ version of the program by doing a make clean, changing the Makefile PRJSRC variable to kitt.cpp and then issuing another make.

Debugging the Program

A Makefile target that is interesting, whether for sanity checking, optimization, low-level debugging or simply to get to know the AVR internals, is disasm. Running: $ make disasm prints some information concerning the program, such as its text/data/bss size, to the console and creates helloavr.s. This file contains a disassembled version of the executable, intermixed with the original C source code. A peek inside reveals AVR Libc and avr-gcc's work behind the scenes, initializing the interrupt vector table and data, followed by the Assembly and C versions of the program.

Now we use GDB as a source-level debugger with simulavr running as a remote target. To do so, launch simulavr in the background and create a suitable gdbinit file:

$ simulavr --gdbserver --device at90s8515  &
$ make gdbinit

Running make in this manner creates gdbinit-helloavr, a file containing instructions for setting up GDB correctly, such that it connects to a simulavr, loads the compiled program, inserts a breakpoint and begins execution. Launch avr-gdb using the command:

$ avr-gdb -x gdbinit-helloavr

and you are presented with the GDB prompt; program execution is halted before the first instruction in main(). Set a breakpoint on line 71, using b 71, and enter C (continue) a few times. Every time you step over the instruction on line 71:

71       PORTB = ~currentValue;

~currentValue is output through PORTB. You should see a message to that effect, for example, writing 0xff to 0x0038. When you are done, issue a quit and kill the simulavr process, which is running in the background.

Installing the Program

If you've built or purchased the programmer hardware, you can install and test the software on a real AT90S8515 chip. Configure the avrdude section in the Makefile by setting the AVRDUDE_PROGRAMMERID and AVRDUDE_PORT variables, as explained in the comments above. Use:


for an STK500 programmer connected to the first serial port. Ensure that the programmer is connected to the appropriate port, insert the microcontroller in the programmer, apply power and type make writeflash. This generates the hex file used by AVRDUDE and writes its contents to the chip's Flash program memory.

Figure 4. HelloAVR Program Test Circuit

For those using the STK500 development kit, simply connect PORTB to the eight onboard LEDs using the ten-wire cable (as illustrated in Figure 3), and watch das blinkenlights. You can set up your own test hardware by constructing the schematic shown in Figure 4, which connects LEDs with suitable limiting resistors such that each pin of PORTB can activate one by going low and sinking current.

Where to from Here?

You've seen the flashing LEDs? Congratulate yourself; you are ready to begin creating your own AVR designs and software. See Resources for loads of AVR-related information and projects. There's almost no limit to what you can do.

Atmel shares a number of interesting project ideas through its AVR application notes, where it details implementation of stepper motor controllers, IR remote control receivers and transmitters and even an embedded Web server. One amazing project, ContikiOS (see Resources), distributes an open-source Internet-enabled, multitasking, graphical operating system that has been ported to the AVR and uses a version of the VNC server instead of a regular screen.

Enjoy experimenting with these versatile microcontrollers, be sure to share your discoveries and good luck building that robot horde!

Resources for this article: www.linuxjournal.com/article/7920.

Patrick Deegan was converted to IT and free software after being in contact with Linux while a student in the joint Math and Physics program at McGill U. Torn between working in physics, electronics and software development, Pat was bound to cofound Psychogenic, where he now gets to spend many days (and nights) playing with all three.


ordinal 56 could not be located in the dynamic link library iertutil.dll

This kind of problem happens when you use some funny registry mechanic or remove ie6 or ie7.

Solution :

1. download iertutil.dll from web site

2. copy this file to c:\windows\system

3. restart your PC

Internet will be accessible and if you have other problem like this the reinstall Internet explorer.

ordinal 14 could not be located in the dynamic link library iertutil.dll

This kind of problem happens when you use some funny registry mechanic or remove ie6 or ie7.

Solution :

1. download iertutil.dll from web site

2. copy this file to c:\windows\system

3. restart your PC

Internet will be accessible and if you have other problem like this the reinstall Internet explorer.

Wallpaper Changer Apps For Linux


wallpaper-changer-ubuntu" align="left">Webilder is one of the best wallpaper changers for Linux. Not only does it change your wallpaper at regular intervals but it can also download images directly from Flickr and WebShots (requires a paid account) and add them to your collection.

When downloading from Flickr, you can configure it to download photos that match the tags you specified, or just to download the most interesting photo of the day.

If you run out of tags idea, you can also check out the Webilder channel to see what others are downloading and add their tags to your Webilder.


In addition, Webilder also comes with a simple photo browser where you can preview the image in full screen and decide if you want to use it as the wallpaper.


I like Wallpapoz the best, for the simple reason that it allows me to specify a different set of wallpapers for each workspace. When I change workspace, the wallpaper also changes accordingly. With this feature, you can configure each workspace to display a different ‘mood’ of wallpaper.

The first workspace may display those ‘Get back to work’ kinds of wallpaper that constantly remind you to finish up your work. The second workspace may be made up of relaxing, soothing wallpaper where you can listen to your music with peace. The trick is, when you are bored with your work, simply switch the workspace and change your mood instantly.

I am not sure if this works for you, but it is definitely working for me.


The current version of this app is 0.4.1 and works well in most Linux distros with GNOME desktop. This will also be the last stable version as the developer has decided to quit the development.


Desktop drapesDrapes is a simple wallpaper changer that sit quietly in the notification area and changes your wallpaper every once in a while. A good thing about Drapes is that you can specify a folder for it to monitor. When you add a new wallpaper into the folder, Drapes will pick it up and add it to its database.

Generally, this is a simple wallpaper changer that performs what it’s supposed to do - change wallpapers at regular intervals. If you just want a set it once and leave it kind of wallpaper-changing app, then this is most suitable for you.

If you are using Ubuntu, Drapes is included in the repository and you can easily install via the Synaptic Package Manager. If that is too troublesome for you, click here to install it.


Wallpaper-Tray is another simple wallpaper changer that does only the basic stuff. You specify the location of your wallpapers, set the time interval and you are good to go. No surprises.

wallpaper-tray : wallpaper changer download

There is one interesting feature though - Wallpaper Search tool. You type in some text in the search bar and it will search your filesystem and display all the images with file names similar to your search term. You can then select from the results the image that you want to set as the wallpaper.

Wallpaper-Tray is also available in the Ubuntu repository.

Wallpaper Changer Screenlet

screenlet-wallpaper-changer If you have already installed Screenlets in your system, you can also use the Wallpaper Changer Screenlet to change your wallpaper at regular intervals. Same as Webilder, it allows you to download the interesting picture of the day from Flickr. It can also retrieve images from art.gnome.org and Google Images.

There is no installation required for this app. You just need to download the tar file and extract it to the Screenlets folder (usually located in /home/username/.Screenlets). You can then activate the app via the Screenlets main menu.

While this app works fine as a wallpaper changer, its interface is rather unpolished and can be hard to manage at times. I would advise you to use this app only if you have already installed Screenlets.

Did I miss out any wallpaper changer app for Linux? Do let me know and I will add it to the list.

Ref :-- http://www.makeuseof.com/tag/5-wallpaper-changer-apps-for-linux/

On top of this there are few other alternatives as follows

1. nitrogen

2. feh

3. gnome-wallchanger

Thursday, January 22, 2009

Run your car without any maintenance for more then 100 years

The Cadillac WTF

Posted in TECH by gizmodo on Jan 16, 05:00AM

The Cadillac WTF

Caddillac WTF
Caddillac WTF
Caddillac WTF
Caddillac WTF
Caddillac WTF
Caddillac WTF

The appropriately titled Cadillac World Thorium Fuel or "WTF" has features you are not going to find anywhere else. It runs on clean Thorium nuclear fuel and offers maintenance-free service for 100 years or more.

Not only that, each wheel is actually six individually powered wheels aligned side by side. Now that's an absurd level of redundancy you can trust. Unfortunately, this design is only in the concept stages at the moment, but if you can hang around until the year 8000 or so, you just might be able to pick one up. In the meantime, these pretty pictures will have to do. [Coroflot]

by Sean Fallon, GIZMODO