Free microcontrollers software for linux

Rational PIC Assembler is an assembler for the mid-range microcontrollers from Microchip. The project uses Intel style mnemonics and target-first operand ordering. Designed to feel comfortable to PC assembly programmers.
This assembler generates code compatible with Microchips midline microcontrollers but is incompatible with their assembler. It should feel familiar to any PC assembly programmer. The instruction mnemonics and operand order are Intel style ( i.e. right, as opposed to wrong ).
Command Line Syntax
pic-asm [ -c ] [ -l filename ] [ -o filename ] input_file
-c -- console mode
an assembly source is accepted from stdin. binary code is
output on stdout. errors are output to stderr
-l filename -- specify listing file
-o filename -- specify object file
Input
The input is a sequence of line each of which contains one or more of the following fields
label instruction operands ; comment
The label and comment are optional. The operands required depend on the instruction.
The assembler is case sensitive, even for instructions.
Constants
Hex values can be specified with C-style 0x[:xdigit:]+. Binary values can be specified with 0b[01]+. Decimal values require no prefix as decimal is the default base.
Character constants are specified by enclosing a single character or escaped character within single quotes. String constants are specified by enclosing zero or more characters and escaped characters within double quotes. String constants generate one character constant for each character in the string. There is no trailing zero stored. For example:
db "Hello worldn", 0, a, b, r, n, t
Labels
A label is a sequence of alphanumeric characters ( including underbar ) that starts a line. Labels do not have colons. Labels local to the last nonlocal label can be defined by prefixing the name with a dot. For instance
; example from example-1.asm
foo call .1
.1 jmp .2
.2 jmp .1
bar call .1
.1 jmp .2
.2 jmp .1
In this example, the labels defined are foo, foo.1, foo.2, bar, bar.1, and bar.2. The first call branches to foo.1. The second call branches to bar.1. The labels local to foo can not be referenced before foo has been declared nor after bar has been declared.
Directives
Data can be declared. The declarator takes the place of the instruction and is followed by one or more expressions separated by commas. Each expression corresponds to one word in the output code regardless of the declarator type.
db - each operand is AND-ed with 0xff before being stored
dw - full 14 bit word definition
dt - each operand is AND-ed with 0xff and OR-ed with 0x3400 ( the return-with-value opcode ). This allows generation of case tables. You can add the accumulator ( w ) to the offset of the table. The processor will branch to the location in the table and return with an eight bit result
For instance:
db 1,2,3
dw 0x3fff, 0x3ff * 16 + 15, -1
dt 0b001, 0b010, 0b100
Equates are a named sequence of tokens. They can be defined with equ. For instance:
led_1 equ 0x100 | 1
led_2 equ 0x100 | 2
combo equ ( led_1 ) | ( led_2 )
The org position can be changed with org. For instance
org 0x10o
Enhancements:
- This release adds support for sophisticated macros, include files, conditional compilation, and compatibility with Microchip headers.

dsflasher is a utility to flash Dallas (Maxim) DS89C450 microcontrollers using a ROM loader.

Usage:

dsflasher -f [input filename] -p [serial port]

CANFestival GUI project is an implementation of the CANopen protocol.
CANopen SlaveLib is an implementation of the CANopen protocol for CAN bus devices.
It makes it very easy to create CANopen slave devices under Linux and on Microchips PIC microcontrollers.
Main features:
- Opensource and therefore available for everyone
- Standard-compliant
- Highly portable
- Programmed in ANSI-C (especially because of the portability)

uLan Driver provides 9-bit message oriented communication protocol, which is transferred over RS-485 link.
Characters are transferred same way as for RS-232 asynchronous transfer except parity bit, which is used to distinguish between data characters and protocol control information. A physical layer consists of one twisted pair of leads and RS-485 transceivers.
Use of 9-bit character simplifies transfer of binary data and for intelligent controllers can lower the CPU load, because of the CPU need not to care about data characters send to other node. Producers of most microcontrollers for embedded applications know that and have implemented 9-bit extension in UARTs of most of todays MCUs. There is the list below to mention some of them:
- all Intel 8051 and 8096 based MCUs with UART
- members of Motorola 683xx family ( 68332, 68376, ... )
- Hitachi H8 microcontrollers
The driver is implemented as relatively independent layers and subsystems. Messages are prepared and received in the driver dedicated memory. This memory is divided into blocks with uniform size with atomic allocation routines.
When message is being stored into blocks, head of message with couple of data bytes is stored in the first allocated memory block. If all data cannot be stored in the first block, next blocks are allocated and linked together.
The message heads are linked in bidirectional linked lists of messages prepared for sending, processed messages and messages prepared for client notification. These lists or queues are main mechanism for transferring of messages between subsystems.
Link protocol is programmed as finite state automata with state stack, which state routines are executed by interrupt handler. State routine can return positive integer information, negative error notification or zero, which leads to wait for next interrupt. Information or error is used as input parameter when state routine is called.
When the state routine wants initiate transfer to another state routine it changes pointer to the actual state routine. If previous state routine returns nonzero value new routine is called immediately, in other case next interrupt invokes new state routine.
There is stack of callers of actual state routines which enables to constructs automata subsystems, which can be used in more places in main automata loop. Main purpose of this automata is to send or process messages coming in list of messages prepared for sending and if specified, move these messages onto list of messages prepared for client notification.
Received messages are put onto this list too. Subsystem is supervised by timeout handler, which can revitalize communication in case of die of other node. The interrupt and timeout handlers are fully SMP reentrant.
The automata subsystem uses pointers to chip driver routines for hardware port manipulation. This is only part dependent on used chip, today 82510, 16450 and OX16C950PCI. These routines can send and receive 9 bit character, connect to RS-485 line by the arbitration sequence, wait for specified time for character and initialize and close port.
File operation subsystem makes interface between OS kernel VFS and client message queues. It enables to prepare single or multi-frame messages and stores notifications of received or processed messages in clients private state structures. This part is heavily operating system dependent.
Enhancements:
- This release enables you to build the driver within the WDF framework for Windows.
- Updates to support the latest Linux 2.6.x kernels are included (tested to 2.6.19).
- Changes to allow stand-alone system-less build for ARM targets (LPC21xx) are included.
- The OMK has been selected as the default build.
- The "switch2std" script allows you to switch to the old build system.

Pyastra is a python to assembler translator. The project takes source file written in python and, if the code contains no errors, generates an assembler file.
Then you may comile it to hex-file using your favourite PIC assembler (gpasm, mpasm, or any other compatible with them).
Goals:
- to bring a python translator to the world of microcontrollers
- to support a wide range of microcontrollers and processors
- to generate compact and effective code
- to be developer- and user-friendly

KTechlab is a development and simulation environment for microcontrollers and electronic circuits, distributed under the GNU General Public License.
KTechlab consists of several well-integrated components:
- A circuit simulator, capable of simulating logic, linear devices and some nonlinear devices.
- Integration with gpsim, allowing PICs to be simulated in circuit.
- A schematic editor, which provides a rich real-time feedback of the simulation.
- A flowchart editor, allowing PIC programs to be constructed visually.
- MicroBASIC; a BASIC-like compiler for PICs, written as a companion program to KTechlab.
- An embedded Kate part, which provides a powerful editor for PIC programs.
- Integrated assembler and disassembler via gpasm and gpdasm.
Main features:
- Electronic Simulation
- PIC Simulation
- Logic Simulation
- Supported Components
- Programming
- MicroBASIC
- FlowCode
- Assembly

uIP TCP/IP stack provide TCP/IP connectivity to tiny embedded 8-bit microcontrollers, with maintained interoperability and RFC standards compliance.
uIP is an implementation of the TCP/IP protocol stack intended for small 8-bit and 16-bit microcontrollers.
uIP project provides the necessary protocols for Internet communication, with a very small code footprint and RAM requirements - the uIP code size is on the order of a few kilobytes and RAM usage is on the order of a few hundred bytes.
uIP is open source software written in the C programming language and the documentation and source code is free to use and distribute for both commercial and non-commercial use as long as proper credit is given (the full BSD-style license is here). It has been ported a wide range of 8-bit microcontrollers and is used in a large number of embedded products and projects (see the Links page for a few examples).
Main features:
- Well documented and well commented source code - nearly every other code line is a comment.
- Very small code size.
- Very low RAM usage, configurable at compile time.
- ARP, SLIP, IP, UDP, ICMP (ping) and TCP protocols.
- Includes a set of example applications: web server, web client, e-mail sender (SMTP client), Telnet server, DNS hostname resolver.
- Any number of concurrently active TCP connections, maxium amount configurable at compile time.
- Any number of passively listening (server) TCP connections, maximum amount configurable at compile time.
- Free for both commercial and non-commercial use.
- RFC compliant TCP and IP protocol implementations, including flow control, fragment reassembly and retransmission time-out estimation.
Enhancements:
- A new socket-like API, protosockets, was added.
- uIP now has rudimentary IPv6 support.
- A DHCP client was added and the Web server was rewritten with protosockets.
- Device driver structure was simplified.
- Many bugfixes were made in the TCP code.
- A uIP mailing list was started.

This is an application to compile assembler files and transfer them from Linux to the XGS (SX28/52 microcontrollers) with the SX-Key.

It requires QT 4, WINE and the SASM assembler. The 0.02 version contains just the transfer part. The newer versions also contain the rest of the IDE to compile the source code and transfer the files.