The Javelin Stamp is a single board computer that's designed to function as an easy-to use programmable brain for electronic products and projects. it's about the size and shape of a commemorative postage stamp. It is programmed using software on a PC and a subset of Sun Microsystems Java programming language. After the program is downloaded to the Javelin, it can run the program without any further help from the PC. The Javelin can be programmed and re-programmed up to one million times.

Some of the other features that set the Javelin apart from BASIC Stamps are:

• The instruction codes for the Javelin are fetched and executed from a parallel SRAM instead of a serial EEPROM.
• The Javelin has 32k of RAM/program memory with a flat architecture. No more program banks, and no more tight squeezes with variable space.
• The Javelin has built in Virtual Peripherals (VPs) that take care of serial communication, pulse width modulation and tracking time in the background.
• Serial communication is buffered as a background process. When writing programs, all you have to do is periodically check the buffer.
• The Javelin Stamp Integrated Development Environment (Javelin Stamp IDE) software is a significant departure from a simple Editor and messages window combination. When used with the
• Javelin connected to a PC by a serial cable, this software can be used as a highly integrated in-circuit debugging system that allows you to run code, set breakpoints and view variable values,
• memory usage, I/O pin states and more. There is also no need for emulators; the Javelin can be placed directly into the circuit and debugged there.
• Delta-sigma A/D conversion.
• D/A conversion is accomplished in the background as a continuous pulse train delivered by an I/O pin. The pulse width modulation VP can also be used for generating pulse trains, frequencies, and D/A conversions in the background while your foreground code is free to perform other tasks
   

MCS51 Introduction
The Philips 8XC51/31 is a high-performance static 80C51 design fabricated with Philips high-density CMOS technology with operation from 2.7V to 5.5V. The 8XC51/31 contains a 4k ? 8 ROM, a 128 ? 8 RAM, 32 I/O lines, three 16-bit counter/timers, a six-source, four-priority level nested interrupt structure, a serial I/O port for either multi-processor communications, I/O expansion or full duplex UART, and on-chip oscillator and clock circuits. In addition, the device is a low power static design which offers a wide range of operating frequencies down to zero. Two software selectable modes of power reduction?idle mode and power-down mode are available. The idle mode freezes the CPU while allowing the RAM, timers, serial port, and interrupt system to continue functioning. The power-down mode saves the RAM contents but freezes the oscillator, causing all other chip functions to be inoperative. Since the design is static, the clock can be stopped without loss of user data and then the execution resumed from the point the clock was stopped.

FEATURES
- 8051 Central Processing Unit
- 4k ? 8 ROM (80C51)
- 128 ? 8 RAM
- Three 16-bit counter/timers
- Full duplex serial channel
- Boolean processor
- Full static operation
- Low voltage (2.7V to 5.5V@ 16MHz) operation
- Memory addressing capability
- 64k ROM and 64k RAM
- Power control modes:
- Clock can be stopped and resumed
- Idle mode
- Power-down mode
- CMOS and TTL compatible
- Three speed ranges at VCC = 5V
- 0 to 16MHz
- 0 to 33MHz
- Three package styles
- Extended temperature ranges
- Dual Data Pointers
- Second DPTR register
- Security bits:
- ROM (2 bits)
- OTP/EPROM (3 bits)
- Encryption array?64 bytes
- 4 level priority interrupt
- 6 interrupt sources
- Four 8-bit I/O ports
- Full?duplex enhanced UART
- Framing error detection
- Automatic address recognition
- Programmable clock out
- Asynchronous port reset
- Low EMI (inhibit ALE)
- Wake-up from Power Down by an external interrupt (8XC51)

 

A PIC microcontroller is a processor with built in memory and RAM and you can use it to control your projects (or build projects around it). So it saves you building a circuit that has separate external RAM, ROM and peripheral chips.

What this really means for you is that you have a very powerful device that has many useful built in modules e.g.

• EEPROM.
• Timers.
• Analogue comparators.
• UART.

Even with just these four modules (note these are just example modules - there are more) you can make up many projects e.g.:

• Frequency counter - using the internal timers and reporting through UART (RS232) or output to LCD.
• Capacitance meter - analogue comparator oscillator.
• Event timer - using internal timers.
• Event data logger -capturing analogue data using an internal ADC and using the internal EEPROM for storing data (using an external I2C for high data storage capacity.
• Servo controller (Control through UART) - using the internal PWM module or using a software created PWM.
  
  The PIC Micro is one of the most popular microcontrollers and in case you were wondering the difference between a microprocessor and a microcontroller is that a microcontroller has an internal bus with in built memory and peripherals.
  
  In fact the 8 pin (DIL) version of the 12F675 has an amazing number of internal peripherals. These are:
   
• Two timers.
• One 10bit ADC with 4 selectable inputs.
• An internal oscillator (or you can use an external crystal).
• An analogue comparator.
• 1024 words of program memory.
• 64 Bytes of RAM
• 128 Bytes of EEPROM memory.
• External interrupt (as well as interrupts from internal peripherals).
• External crystal can go up to 20MHz.
• ICSP : PIC standard programming interface.
• And all of these work from within an 8 pin DIL package!
  
  In the mid-range devices the memory space ranges from 1k to 8k (18F parts have more) - this does not sound like a lot but the processor has an efficient instruction set and you can make useful projects even with 1k e.g. LM35 temperature sensing project that reports data to the serial port easily fits within 1k.
  
  Features
  
  In fact a PIC microcontroller is an amazingly powerful fully featured processor with internal RAM, EEROM FLASH memory and peripherals. One of the smallest ones occupies the space of a 555 timer but has a 10bit ADC, 1k of memory, 2 timers, high current I/O ports a comparator a watch dog timer... I could go on as there is more!
  
  Programming
  
  One of the most useful features of a PIC microcontroller is that you can re-program them as they use flash memory (if you choose a part with an F in the part number e.g. 12F675 not 12C509). You can also use the ICSP serial interface built into each PIC Microcontroller for programming and even do programming while it's still plugged into the circuit!
  
  You can either program a PIC microcontroller using assembler or a high level language and I recommend using a high level language such as C as it is much easier to use (after an initial learning curve). Once you have learned the high level language you are not forced to use the same processor e.g. you could go to an AVR or Dallas microcontroller and still use the same high level language.
  
  Input / Output - I/O
  
  A PIC Microcontroller can control outputs and react to inputs e.g. you could drive a relay or read input buttons.
  
  With the larger devices it's possible to drive LCDs or seven segment displays with very few control lines as all the work is done inside the PIC Micro.
  
  Comparing a frequency counter to discrete web designs you'll find two or three chips for the microcontroller design and ten or more for a discrete design. So using them saves prototype design effort as you can use built in peripherals to take care of lots of the circuit operation.
  
  Peripherals
  
  The PIC microcontroller has many built in peripherals and this can make using them quite daunting at first which is why I have made this introductory page with a summary of each major peripheral block.

The dsPIC30F family encompasses a wide range of performance requirements, making it an ideal architecture for anyone considering a 16-bit MCU or DSP, or even a 32-bit MCU. The devices were designed to provide a familiar look and feel to MCU users, especially users familiar with PIC? MCUs. The DSP features were seamlessly integrated to ease adoption by new users of DSP technology. Moreover, the pricing structure of dsPIC30F devices make them affordable for embedded control applications.

The dsPIC30F devices were architected from the grounds-up to provide all the features a user would expect from an industry leading 16-bit MCU. A rich instruction set, coupled with extensive addressing modes, operate on a generous set of general purpose working registers and a software stack. The result is very good C compiler efficiency. All the devices use Flash memory technology for its Program Memory and Data EEPROM, in order to provide maximum manufacturing cycle time flexibility. Fast, in-circuit self programming technology enables remote updating of Program Memoryand Data EEPROM. The high reliability of the Flash memory enables 40 years of data retention and up to one million program or erase cycles at 85 degrees Centigrade. Competitive DSP performance is enabled by a powerful set of DSP features. A single-cycle 17-by-17 Multiplier; two 40-bit accumulators and a 40-bit barrel shifter; zero overhead Do and Repeat loops; rounding or saturation of results; and special addressing mode support for circular buffers and FFT?s. The dsPIC30F architecture also supports a very flexible interrupt processing structure. Each device includes an extensive set of peripheral modules, inc luding timers, serial subsystems, and analog to digital converter channels. Some devices also contain advanced peripherals geared towards specific applications like motor control, audio, or internet connectivity. Last but by no means the least, the devices contain hardware logic that enables in-circuit debugging and Flash programming without removing the device from the board.

Arduino is a tool for making computers that can sense and control more of the physical world than your desktop computer. It's an open-source physical computing platform based on a simple microcontroller board, and a development environment for writing software for the board.

Arduino can be used to develop interactive objects, taking inputs from a variety of switches or sensors, and controlling a variety of lights, motors, and other physical outputs. Arduino projects can be stand-alone, or they can communicate with software running on your computer (e.g. Flash, Processing, MaxMSP.) The boards can be assembled by hand or purchased preassembled; the open-source IDE can be downloaded for free.

The Arduino programming language is an implementation of Wiring, a similar physical computing platform, which is based on the Processing multimedia programming environment.