Digital electronics and programing

Stereo digital audio spectrum analyzer V4.0

2012-01-24T21:58:00.002+02:00

This is a stereo upgrade of previous version 3.x.

This version has multiple changes from the previous version, like:

Can handle stereo signals.
Display format is 18+1+1( to display 18 bands of frequencies and Left Right signal level) .
USB adapter for easy upgrade.
Dedicated RTC with battery back-up.
Added two usart connectors to create cascade spectrum analyzers( to create large display from boards like this ).
A microcontroller twice faster that previous and multiple hardware advantages that increase velocity of signal processing and rendering to display.

Down I posted two photos with new board design.

MikroMMB for Xmega MP3 Player

2011-09-11T13:42:00.008+03:00

This project is created in AVR GCC with 100% my own drivers and libraries , this player can play MP3, WMA and OGG files from micro SD/SDHC memory card fat16/32 formatted.

V1.3

On this firmware I made some bug fixes and I adding some functions to player:

Bug fixes:

The previous versions has a bug that forces user to put on first location of root directory the volume ID or a file or folder with the short name only.

Function's added:

A progress bar to track the melody, with the same progress bar the user can force the audio player to play file from a specified point.
Player can run now like a thread "Open player" "Close Player" when card is inserted is automatically opened the player, when SD card is removed all resources used by Audio Player will be freed.
Now you can play music from SD/SDHC card's formatted in FAT16 or FAT32(The FAT16 has a little bug, on root directory is displayed only files and directory's from first Page(512Bytes).

On this version you can play: MP3, AAC, OGG, WAV and WMA.

Download V1.3 demo version of this player.

V1.2

On this version I made some changes:

I change the navigation from the "next" "previous" button to a list box.
On this version is not capable to display bitmap's because I want to design another interface to view bitmap photo.
The VS chip data is send by a service that work inside the RTC interrupt service, in this case has a high priority to send data to VS chip.

Download V1.2 demo version of this player.

V1.1

On this version I made huge improvements.

Now you can navigate through the directories when you listen music, you can choose another melody when you listen another melody.
The player has change the listen melody with the next from the current directory, the payback is stopped after the last melody is played.
Now you can see bitmaps images in 8, 24 and 32 bit/pixel with some limitations, maximum size 240x200pixels, the maximum file size 140KB (140000bytes), the 240x200 pixels limitation is implemented to no interference with the player interface, the 140KB limitation is made because I have a bug in the bitmap library, that can't read files bigger than this value.

This version is limited to play only MP3 files, the core clock is 32Mhz.

Download V1.1 demo version of this player.

V1.0

The controller is running at 16Mhz.

On this version can't manage the power consumption.

This version can play MP3, WMA and OGG.

Download V1.0

Mikro Media for Xmega simple Lcd Touch Paint

2011-08-16T20:34:00.009+03:00

This is made with 100% my library's developed in AVR GCC because free source code for LCD display and touch screen can't be found on internet.

When you power up the board with this firmware, the board enter to touch screen calibrate, in four points, after the last point is touched the display is painted with white back ground and you can scribe through touch screen with chosen color touching the colors rectangles from right up of display.

Chosen color will appear like a rectangle painted with the same chosen color on right down of display.

If you want to clear the display, touch the black rectangle from right down of screen.

V1.1

In this firmware I add function to choose ink color and to clear display.

On this version is eliminated the previous described bug.

Download demo firmware V1.1.

V1.0

On the 1.0 firmware version is a bug caused by the capacitors connected in parallel with Q5 and Q9 that is not filtered by the firmware, but for the current work is not a critical bug :D.

Download demo firmware V1.0.

ATxmega boot loader

2011-08-16T16:38:00.010+03:00

Currently I bought a Micromedia Board ( microMMB for XMEGA ) from mikroEelektronika.

This board is perfect for general developing because can be used by programmers that don't have a programmer, because is coming with a bootloader pre-installed.

I mentioned only the bootloader because this bootloader is the problem

To upload a flash with 64KB size is taken about 10-15 minutes, or to develop a firmware is a very very long time to wait, visualizing this I developed a very fast bootloader to write only Flash and EEProm memory, only strictly necessary memories because all of other ATxmega features can be set from uploaded firmware.

In this stage I compiled eight bootloader firmwares only for ATxmega128A1 for each used hardware usart, and each firmware work with a 256000 baud transfer rate, this baud rate is set like default baud rate for the up-loader when is opened, I want to mention that the up-loader can work with atmega bootloader firmwares found here.

Version 1.0 of firmwares:

For usart 0 ( usart C0 ).

For usart 1 ( usart C1 ).

For usart 2 ( usart D0 ).

For usart 3 ( usart D1 ).

For usart 4 ( usart E0 ).

For usart 5 ( usart E1 ).

For usart 6 ( usart F0 ). can be used for Micromedia Board for XMEGA.

For usart 7 ( usart F1 ).

Download PC uploader program.

Multipurpose development board with ATxmega64A1/ATxmega128A1

2011-05-17T16:25:00.008+03:00

Features:

Main processing unit ATxmega64A1 or ATxmega128A1.
Audio decoder VS1011,1033,1053 with stereo jack 3.5mm female connector & external speakers 3 pin connector(optional).
DS1307 real time clock with battery pads.
PDI & JTAG connectors.
LB1936 dual driver for asynchronous motors (optional).
AD7414 temperature sensor for motor driver (optional).
External motors driver connector with I2C bus.
Two micro SD connectors ( one is optional ).
Four connectors with 2x3 pin to control eight servo motors, two servomotors for each connector, each connector is power interruption to minimize power consumption.
Two power jack connector 5.5/2.1mm put in series to connect two photovoltaic panels and with static commutator controlled by software to charge main accumulator.
High power step down stabilizer from accumulator voltage to 3.3V.
On-board 512KB static ram for minimizing power consumption in sleep mode.
BTM-222 Bluetooth for communication with PC or mobile phones (optional).
RFM12BP at 434Mhz for communication with one remote control for huge distance up to 5Km (optional).
RFM12BS at 868Mhz to control other wireless modules (optional).
All modules from point 13, 14 & 15 can work at the same time without interferences.
Five connectors with four pins with I2C bus and 3.3V power for future extensions.
External extension bus connector to connect future external modules to ATxmega parallel data bus, such as Displays, more motors controllers, image sensors etc.
Possibility to monitor power consumption from main accumulator.
Possibility to monitor generated power by the photovoltaic panels.
Possibility to monitor voltage of the main accumulator.
Possibility to monitor power consumption of each motor powered by on-board driver.

Applications:

Robots: contain on-board dual asynchronous motor driver and four connectors to control eight servomotors, powered from an Li-Ion accumulator and support to charge the accumulator from two photovoltaic cells or from an external source, several communication modules: Bluetooth Class1, EFM12BP for long distance communication up to 5Km and RFM12BS for low power and short distance communication up to 300m.
Audio player: contain on-board VS1011, VS1033 or VS1053, single or dual micro-SD memory card connectors with push.
Audio/Video(low quality) player.
General development application because has all possibility to connect with another controller or another peripherals to the expansion bus, the expansion connector work to speed of the external ram memory, because the expansion peripherals is mapped to address space 524288 to 1048576, maximum number of expansion peripherals is 65536.

Power supply input between 3.4V and 9.5V

Maximum supported input voltage on photovoltaic connectors and the main accumulator: 9.5V, Maximum absolute 10.5V.

Board dimension: 66.83 x 130.78mm.

This board can be bought from here.

Intel HEX to binary HEX converter

2011-02-25T22:32:00.026+02:00

This is an utility for programmers to convert Intel .hex files generated by AVR studio for example to binary hex data file, to create static or dynamic library like image of flash ROM and can be imported like data file to a project.

V1.0.5

In this version the files that is not modified ,is not recompiled, in this case if you work on memory stick not take the number of writings / deletions of memory stick for files that is not modified, or if you work with many files will not be useless to compile the files were not changed
This version can be downloaded from here.

V1.0.4

In this version I added to automatically put the "#ifndef FileName" to include only one time a library if is declared on multiple files.
This version can be downloaded from here.

V1.0.3

Added:
Now can include header file with definition constants in hex image file, in this case is no longer case to include hex image file and header file separately, you can include only hex image file, if the name of .hex file is "AA.hex" the name of header file is necessary to be "AA_Headers.inc".

When hi finish to compile all files, auto close the thread, this feature allow to include this compiler on Pre Assembling section of AVR Studio, in this case before the compilation of AVR studio, AVR Studio can launch this compiler to actualize the images of libraries, and after can compile the project with updated libraries.

Fix:
On start up auto load the path where is.

This version can be downloaded from here.

V1.0.2

Fix: no filter to .hex in 1.0.1 version.The last version of this utility can be downloaded from here (Internet explorer only).

V1.0.1

New:
Added:

On program open you can choose the base directory where is the source folder.
You can always change the working directory.
Automatic checking and downloading updates.

V1.0.0

This utility get all of the .hex files from directory that the utility has been opened /source and put converted files include directory structure to /bin.

For example the project is placed to C:/source/, and the utility in C:/

The directory structure is this:
C:/source/Math.hex
C:/source/IO_Port_Driver.hex
C:/source/IO_Uart_Driver.hex

After running of the utility all files is compiled on C:/bin/ and well see like that:

C:/bin/Math.asm
C:/bin/IO_Port_Driver.asm
C:/bin/IO_Uart_Driver.asm

The result is files .asm with data in hex format.

To create static or dynamic library's is necessary to put links to the integrated functions on top of the library, for example:

File: Math.asm

.Org 0
MathLibrary: // This is the base address of the links
Rjmp Add8x8_8
Rjmp Add16x16_16
Rjmp Add 32x32_32
Rjmp Sub 8x8_8
Rjmp Sub 16x16_16
Rjmp Sub 32x32_32
;--------------------------------//End of links
//Begin of routines
Add8x8_8:
Code......
Ret
;--------
Add16x16_16:
Code......
Ret
;--------
Add32x32_32:
Code......
Ret
;--------
Sub8x8_8:
Code......
Ret
;--------
Sub16x16_16:
Code......
Ret
;--------
Sub32x32_32:
Code......
Ret
;--------
//End of library

To define the offsets of links you can create another file with this, for example:

File: Math.inc

#define _MathLibrary (0) //Offset of base of links

#define _Add8x8_8 (0) //Link 1
#define _Add16x16_16 (1) //Link 2
#define _Add32x32_32 (2) //Link 3
#define _Sub8x8_8 (3) //Link 4
#define _Sub16x16_16 (4) //Link 5
#define _Sub32x32_32 (5) //Link 6

To import a library, on end of main file include "Math.asm" file from bin directory.

For example:

_MathLibrary_:
.Include "Math.asm"

All of the function from this library can be called like that:

Rcall _MathLibrary_ + _MathLibrary + _Sub8x8_8
Or if "_MathLibrary" base address of links is 0:
Rcall _MathLibrary_ + _Sub8x8_8

"_MathLibrary_" is address of the imported library assigned by the compiler when you build the project, and "_Sub8x8_8" is the offset of the link of the included routine in library defined in
"Math.inc"

Development board 1 for ATXMEGA A1 microcontrollers

2011-02-20T11:52:00.004+02:00

This is a very simple board to test and develop firmwares for ATXMEGA A1 micro-controllers.

This board contains only strictly necessary components for the ATXMEGA A1 micro-controller and only one extra module is added, the USB to serial adapter, the rest of modules can be added to a mother board.

This board has 89x74mm.

This is a very simple board to test and develop firmwares for ATXMEGA A1 micro-controllers.

This board contains only strictly necessary components for the ATXMEGA A1 micro-controller and only one extra module is added, the USB to serial adapter, the rest of modules can be added to a mother board.

This board has 89x74mm.

You can download gerber files and schematic from here.

ASM Compiler

2011-02-12T16:53:00.007+02:00

This is an utility for assembler programmers that allocate ram variable automatically.

With this compiler the ram memory is divided in two section:

Public variables.
Private variables.

Private variable section is started at end of public variable section.
In public variable section this compiler allocate all variables with no overlaps between them.
But in private variable section, at beginning of each functions the variable is overlapped.

an example:

If beginning of public variables section is 0x100, and end of this section is 0x1FF.
All function has beginning of private variables at 0x200.

This is good because at exit from a private function in no longer needed for allocated variables by this function, in this case the next function overlaps his variables over variables allocated by the function above.

V1.0.0

All of the next functions is macros instead functions 55,56,57,58 that is definitions.

In this version can be used the next function:

public char,Var1,null;alloc char variable in public section but is not initiated.
public char,Var1,100;alloc char variable in public section initiated with 100 value.
public uchar,Var1,null;alloc uchar variable in public section but is not initiated.
public uchar,Var1,100;alloc uchar variable in public section initiated with 100 value.
public short,Var1,null;alloc short variable in public section but is not initiated.
public short,Var1,100;alloc short variable in public section initiated with 100 value.
public ushort,Var1,null;alloc ushort variable in public section but is not initiated.
public ushort,Var1,100;alloc ushort variable in public section initiated with 100 value.
public long,Var1,null;alloc long variable in public section but is not initiated.
public long,Var1,100;alloc long variable in public section initiated with 100 value.
public ulong,Var1,null;alloc ulong variable in public section but is not initiated.
public ulong,Var1,100;alloc ulong variable in public section initiated with 100 value.
public long_long,Var1,null;alloc long_long variable in public section but is not initiated
public long_long,Var1,100;alloc long_long variable in public section initiated with 100.
public ulong_long,Var1,null;alloc long_long variable in public section but is not initiated.
public ulong_long,Var1,100;alloc long_long variable in public section initiated with 100variable.
public array,char,Var1,64;alloc array with 64 char variables in public section.
public array,uchar,Var1,64;alloc array with 64 uchar variables in public section.
public array,short,Var1,64;alloc array with 64 short variables in public section.
public array,ushort,Var1,64;alloc array with 64 ushort variables in public section.
public array,long,Var1,64;alloc array with 64 long variables in public section.
public array,ulong,Var1,64;alloc array with 64 ulong variables in public section.
public array,long_long,Var1,64;alloc array with 64 long_long variables in public section.
public array,ulong_long,Var1,64;alloc array with 64 ulong_long variables in public section.
public string,Var1,256,"Hello";alloc string variable in public section and initiate with "Hello" string.
private char,Var1,null;alloc char variable in private section but is not initiated.
private char,Var1,100;alloc char variable in private section initiated with 100 value.
private uchar,Var1,null;alloc uchar variable in private section but is not initiated.
private uchar,Var1,100;alloc uchar variable in private section initiated with 100 value.
private short,Var1,null;alloc short variable in private section but is not initiated.
private short,Var1,100;alloc short variable in private section initiated with 100 value.
private ushort,Var1,null;alloc ushort variable in private section but is not initiated.
private ushort,Var1,100;alloc ushort variable in private section initiated with 100 value.
private long,Var1,null;alloc long variable in private section but is not initiated.
private long,Var1,100;alloc long variable in private section initiated with 100 value.
private ulong,Var1,null;alloc ulong variable in private section but is not initiated.
private ulong,Var1,100;alloc ulong variable in private section initiated with 100 value.
private long_long,Var1,null;alloc long_long variable in private section but is not initiated.
private long_long,Var1,100;alloc long_long variable in private section initiated with 100.
private ulong_long,Var1,null;alloc long_long variable in private section but is not initiated.
private ulong_long,Var1,100;alloc long_long variable in private section initiated with 100variable.
private array,char,Var1,64;alloc array with 64 char variables in private section
private array,uchar,Var1,64;alloc array with 64 uchar variables in private section.
private array,short,Var1,64;alloc array with 64 short variables in private section.
private array,ushort,Var1,64;alloc array with 64 ushort variables in private section.
private array,long,Var1,64;alloc array with 64 long variables in private section.
private array,ulong,Var1,64;alloc array with 64 ulong variables in private section.
private array,long_long,Var1,64;alloc array with 64 long_long variables in private section.
private array,ulong_long,Var1,64;alloc array with 64 ulong_long variables in private section.
private string,Var6,256,"Hello";alloc string variable in private section and initiate with "Hello" string.
write_low Var1;If is not array or string this write R16 if is char or uchar,R16:R17 if is short or ushort, R16:R17:R18:R19 if is long or ulong, R16:R17:R18:R19:R20:R21:R22:R23 if is long_long or ulong_long to Var1(type of variable is autodetected).
write_high Var1;If is not array or string this write R0 if is char or uchar,R0:R1 if is short or ushort, R0:R1:R2:R3 if is long or ulong, R0:R1:R2:R3:R4:R5:R6:R7 if is long_long or ulong_long to Var1(type of variable is autodetected).
read_low Var1;If is not array or string this read from Var1 to R16 if is char or uchar,R16:R17 if is short or ushort, R16:R17:R18:R19 if is long or ulong, R16:R17:R18:R19:R20:R21:R22:R23 if is long_long or ulong_long(type of variable is autodetected).
read_high Var1;If is not array or string this read from Var1 to R0 if is char or uchar,R0:R1 if is short or ushort, R0:R1:R2:R3 if is long or ulong, R0:R1:R2:R3:R4:R5:R6:R7 if is long_long or ulong_long(type of variable is autodetected).
function(NameOfFunction);with this is declased one function(is absolute necessarily to declare like that the function because this will be reset the private variable pointer.
end_function; in this version this can be replaced by Ret instruction.
call_func(function,null);this calls a private function with no transferred variable to him.
call_func(function,Var1);this calls a private function with Var1 transfered to function, in Z is the address of Var1, this variable can be one char, uchar, short, ushort, long, ulong, array or one string, in Y is the base address function that called this function(not yet completed).

Var1 is the name of variable.

All of your stuff can be between ".include "Sys/Compiler.inc"" and ".include "Sys/Compiler_End.inc""

This compiler is at firs version 1.0.0 and can be downloaded from here.

NGW100 AVR32 SDK modified from tolchain216

2010-07-05T13:41:00.006+03:00

I recently started programming for avr32, for this reason I bought a motherboard NGW100, searching the internet for AVr32 AP7000 documentation I found the package libraries and drivers tolchain216, looking through it I noticed that this is not too arranged, so i begin to arrange libraries and drivers by category and the result can be downloaded below.

NGW100 AVR32 SDK from tolchain216 V1.0

Mp3 player with ATmega64, Vs1011 & Samsung E700 display

2010-05-20T12:04:00.039+03:00

This MP3 player is an upgrade to this player . New in this player is a new nice interface with bitmaps from media player windows 7 and windows 7 battery icons.

I preferred to use bitmaps for interface because in future i want to be possible to change the skin interface from SD card, in this case is more simple to create skins for this player.

This player can be bought from here.

V1.0.1A

A little correction for used times for back light, keyboard and battery showing.

Download MP3 PlayerV1.0.1A

V1.0.1

This version player is made to use ASM_SDK V1.0.4 and prepared to work with multiple opened files.

Download MP3_PlayerV1.0.1

From here you can download ASM_SDK.
With ASM_SDK 1.0.5 or newest version you can play from SDHC high capacity > 4GB, at the frequency of only 6 MHz you can play 320Kb/s bit rate melody's.

V1.0.0
From here you can download the first source code for this player.To compile this player is necessarily to download and include ASM SDK from here, this version is made to use ASM_SDK V1.0.3.

Micro Hex Bootloader for ATmega microcontrollers

2010-05-06T15:30:00.018+03:00

New in 1.1 version:

The boot loader from microcontroller can report 5 different errors:

LineDefError = One line is not have the defined destination.
SecondHexCharNotFound = If first hex char is found but second hex char is not found or is not one hex char.
CheckSum = If in one line is detected one check sum error.
LineMismach = After conversion from hex to bin If total length line - 5 is not equal to data bytes contained by that line.
NoMemorySelected = If user is trying to write in memory but the user is not sends the command to select Flash or EEProm memory.

Resources:

Flash = 852 Bytes For Atmega8( The fusible for jumping in boot loader is necessarily to set to 512 Words ).
Flash = 860 Bytes For Uart0 Atmega64-128( The fusible for jumping in boot loader is necessarily to set to 512 Words ).
Flash = 878 Bytes For Uart1 Atmega64-128( The fusible for jumping in boot loader is necessarily to set to 512 Words ).

From this moment the source code is ready to download for free.
To compile this boot loader is necessarily to use last ASM SDK.
This Bootloader has maximum 512Words(1KB) of flash and can work on controllers listened down:

ATmega48 Not Tested
ATmega48P Not Tested
Atmega8 Not Tested
Atmega8A Not Tested
ATmega88 Not Tested
ATmega88A Not Tested
ATmega88PA Not Tested
ATmega16 Not Tested
ATmega16A Not Tested
ATmega162 Not Tested
ATmega168 Not Tested
ATmega168A Not Tested
ATmega168PA Not Tested
ATmega32 Not Tested
ATmega32A Not Tested
ATmega64 OK
ATmega64A Not Tested
ATmega640 Not Tested
ATmega128 OK
ATmega128A Not Tested
ATmega1281 Not Tested
ATmega1280 Not Tested
ATmega2561 Not Tested
ATmega2560 Not Tested

Download Bootloader V1.1 ASM Source code and PC uploader C# source code.

First version V1.0

This is an utility that eliminate the ISP programmer for ATmega Microcontrollers and he work even on Windows Vista and Windows 7.

This boot loader is created to upload data in hex format no bin like others boot loaders, to convert from hex to bin is used an function integrated in boot loader not in up loader.

Version ( V1.0 ) is capable to write flash and eeprom (.hex and .eep) generated by AVR Studio and AVR GCC.

The .eep file is detected automatically by the program from the name of .hex file, for this reason is necessarily to select only .hex file.

When this boot loader is present on an ATmega microcontroller ,at reset is booting in boot loader and is programed to stay and wait for "BootInit" + Cr for entering in programed mode for 2 seconds, if "BootInit" + Cr is not received the boot loader jumps to address 0 in flash.

If communication is interrupted more than 2 seconds this boot loader jump to address 0 of flash.

The boot loader from microcontroller can report 4 different errors that can be appear:

LineDefError = One line is not have the defined destination.
SecondHexCharNotFound = If first hex char is found but second hex char is not found or is not one hex char.
CheckSum = If in one line is detected one check sum error.
LineMismach = After conversion from hex to bin If total length line - 5 is not equal to data bytes contained by that line.

Resources:
Flash = 952 Bytes For Uart1 ( The fusible for jumping in boot loader is necessarily to set to 512 Words ).

Down is ready to download 2 Hex demo files that contain the boot loader for ATmega64 at 16Mhz and 8Mhz at Baud rate 19200b/s for Uart1

Download PC uploader V1.0
Download BootLoader for ATmega64 8Mhz Uart1 19200b/s V1.0
Download BootLoader for ATmega64 16Mhz Uart1 19200b/s V1.0

Complete File to Hex converter

2010-05-06T15:17:00.013+03:00

I've made this converter because I've searched on the internet looking for a converter that converts one file.bmp with header in decimal or hex and i didn't find it. This converter convert a file.bmp in a file.asm with all the additions ".db" for declaration constants.

The result file contains all the bytes converted without exception.
The name of the result file is: 'name of file converted.asm' for AvrASM ex: test.bmp is saved test.bmp.asm

Because I've been asked about a AvrGcc converter, i have created a program for converting in .h files
The name of the result file is: 'the name of file converted.h' for AvrGCC ex: test.bmp is saved test.bmp.h

This is the result for AvrASM:

This is the result for AvrGCC:

FileConverterToHexAvGCC_V1.1.zip

FileConverterToHexAvrASM_V1.0.zip

FileConverterToHexAvGCC_V1.0.zip

Multifunctional 20 Band Audio Spectrum Analyzer V3.0.x

2010-05-06T13:39:00.038+03:00

This project is a version 3 firmware and hardware upgrade spectrum analyzer with 20 audio band of 20 levels each and includes other functions and utilities improvements.

From Digital electronics and programing

On future:

Option to put five, ten or more of this boards, each board filtering one frequency, rotated by ninety degrees to obtain large size of panel for disco or other purposes.
Ability to display a text message received on the serial unit.
Ability to display time during sleep.
Function to adjust the signal level manually or automatically.
Ability to wake up from standby function if signal input is detected.
Ability to enter standby mode in the absence of input signal.
Ability to export using the serial unit, the levels displayed on the local display.

And many many other functions...........

V3.1
Is renamed because is one big step from filters combined (digital & analog) to completely digital filtering.

Added functions:

Ability to enter in standby from menu.
Change from help of analog circuits to filter audio bands to completely digital filtering bands, without the help of analog filtering circuits ( this improve the stability of the displayed bands ) .

V3.0.3

Added functions:

Improve speed of way to display levels of frequencies 0,1 & 2.
Ability to set the start-up light when is connected to power supply.
Ability to set-up the horizontal way to display the levels of frequencies, normal or mirrored for stereo use, the way is memorized for start-up config.

V3.0.2

Functions:

Eleven different ways of displaying the levels of frequencies.
Five modes(ways) of display luminance.
Ability to set the star-up mode when is connected the power supply.

V3.0.0 & V3.0.1 generic versions( discarded ).

This spectrum analyzer can be bought from here.

ASM SDK

2010-05-05T19:58:00.032+03:00

V1.0.5

Added functions:

"IO_Driver_20x20LedDisplay.asm" Added function "_PaintVerticalBarToVideoRamDnLeft" display one bar with R16 col pozition and R18 Length.
"IO_Driver_20x20LedDisplay.asm" Added function "_PaintVerticalBarToVideoRamUpLeft" display one bar with R16 col pozition and R18 Length.
"IO_Driver_20x20LedDisplay.asm" Added function "_SleepDisplay" to sleep display to deactivate scanning of matriceal display.
"IO_Driver_20x20LedDisplay.asm" Added function "_WeekDisplay to resume from sleep.
"IO_Driver_20x20LedDisplay.asm" Added function "_DisplaySecondaryRam" I added a secondary ram buffer to prevent flicker when you write to video ram.
"IO_Driver_20x20LedDisplay.asm" Added function "_Display_TransferDataToDisplay_True" This allow to transfer data from secondary buffer to video ram buffer.
"IO_Driver_20x20LedDisplay.asm" Added function "_Display_TransferDataToDisplay_False" This block transfersof data from secondary buffer to video ram buffer.
"IO_Adc.inc" Added function ".Macro _Macro_Adc_Sleep" to sleep internal ADC.
"IO_Adc.inc" Added function "_Macro_Adc_Week" to resume from sleep internal ADC.

Optimizations:

"IO_SdDriver.asm" Added support for SDHC High capacity > 4GB ( tested with one Kingston SDC4/16GB 02, MicroSD 16GB Class 4)

V1.0.4

Added functions:
-In "Drivers/IO_Driver_20x20LedDisplay.asm" non multiplexed 20x20 led display.

Options:
-In "Lib/Util.inc" Option to eliminate non used memory type.

Optimizations:
-In "System/SoftTimers.asm" optimized tick function.
-One important optimization on Fat32 FFS may allow programmers to work with allocation table management library and data management library fully dynamic, now with this optimization the use can mount infinite discs on single microcontroller, the limit is only the ram memory.

Added library:
-"System/Vectors.inc"is a macro functions to help programmers to place vectors more simply.
-"Drivers/IO_ADC.asm" and "IO_ADC.inc"is a generic driver to work with internal hardware ADC.

Bug fix:
-"IO_VS1011a.asm" fix an error that "VS1011GetBitrate" function return's 0 if the table of bitrate constant is called one part on Zh and another part on Zh+1

An example to use Fat32 FFS with multiple disks:

_Fat32_IndexManagement_RamAlloc IndexManagementLibraryRamDisk1
_Fat32_IndexManagement_RamAlloc IndexManagementLibraryRamDisk2
_Fat32_DataManagement_RamAlloc RamToFat32DataPlayerDisk1
_Fat32_DataManagement_RamAlloc RamToFat32DataPlayerDisk2

_Fat32_Mount IndexManagementLibraryRamDisk1
_Fat32_Mount IndexManagementLibraryRamDisk2
_Fat32_SesionInit IndexManagementLibraryRamDisk1,RamToFat32DataPlayerDisk1
_Fat32_SesionInit IndexManagementLibraryRamDisk2,RamToFat32DataPlayerDisk2

On every change of working disks is necessary to point in Zl:Zh the data management library allocated ram like that:

_Fat32_DataManagement_GetRamAddress RamToFat32DataPlayerDisk1
Code to work with this disk...................
_Fat32_DataManagement_GetRamAddress RamToFat32DataPlayerDisk2
Code to work with this disk...................

This is cool because you can copy one file from one disk to another.

With this new optimization you can open two or more files on same disk, one example is this:

_Fat32_IndexManagement_RamAlloc IndexManagementLibraryRamDisk1
_Fat32_DataManagement_RamAlloc RamToFat32DataPlayerDisk1
_Fat32_DataManagement_RamAlloc RamToFat32DataPlayerDisk2

_Fat32_Mount IndexManagementLibraryRamDisk1
_Fat32_SesionInit IndexManagementLibraryRamDisk1,RamToFat32DataPlayerDisk1
_Fat32_SesionInit IndexManagementLibraryRamDisk1,RamToFat32DataPlayerDisk2

_Fat32_DataManagement_GetRamAddress RamToFat32DataPlayerDisk1
Code to work with this disk................... Get byte from file 1
_Fat32_DataManagement_GetRamAddress RamToFat32DataPlayerDisk2
Code to work with this disk................... Write byte to file 2

Download SDK 1.0.4

V1.0.3

-Added battery paint with 9 bitmap levels and charge bitmap,this function can be called from Dx.asm, before calling this function in R16 is necessarily to lead level:

BatteryEmpty
Battery1
Battery2
Battery3
Battery4
Battery5
Battery6
Battery7
BatteryFull
BatteryCharge

-Verified software timers from one hardware timer: this function is like timers from C,C++,C#,Delphi and others programing languages, example:

.Dseg
TimeToEsantionBattery: .Byte 8; Reserve ram for this timer
TimeToTurnOffLight: .Byte 8; Reserve ram for this timer
.Cseg

Ldi R16,Low(1000); Hardware timer tick /1000
Ldi R17,Byte2(1000)
Ldi R18,Byte3(1000)
Ldi R19,Byte4(1000)
Ldi Yl,Low(TimeToEsantionBattery)
Ldi Yh,High(TimeToEsantionBattery)
CallLib _SoftTimer,_SoftTimer_Init

Ldi R16,Low(10000); Hardware timer tick /10000
Ldi R17,Byte2(10000)
Ldi R18,Byte3(10000)
Ldi R19,Byte4(10000)
Ldi Yl,Low(TimeToTurnOffLight)
Ldi Yh,High(TimeToTurnOffLight)
CallLib _SoftTimer,_SoftTimer_Init

Main:
Wdr
Ldi Yl,Low(TimeToTurnOffLight)
Ldi Yh,High(TimeToTurnOffLight)
CallLib _SoftTimer,_SoftTimer_Tick
Rcall TurnOffLight

Ldi Yl,Low(TimeToEsantionBattery)
Ldi Yh,High(TimeToEsantionBattery)
CallLib _SoftTimer,_SoftTimer_Tick
Rcall EsantionBattery
Rjmp Main

TurnOffLight:
; Routine to execute tick
Ret
EsantionBattery:
; Routine to execute tick
Ret

To disable one timer use this example:
Ldi Yl,Low(TimeToTurnOffLight)
Ldi Yh,High(TimeToTurnOffLight)
CallLib _SoftTimer,_SoftTimer_Disable

To enable one timer use this example:
Ldi Yl,Low(TimeToTurnOffLight)
Ldi Yh,High(TimeToTurnOffLight)
CallLib _SoftTimer,_SoftTimer_Enabled

This timers is enabled when is initiated.

Download SDK 1.0.3

V1.0.2

-Added SDHC support in SD card driver,
-Added support for dynamically MBR location in Fat32 Filesystem library.

Download SDK 1.0.2

V1.0.1A

This litle update is a modification in Internal EEProm Driver file to work with more microcontrollers.

Download SDK 1.0.1A

V1.0.1

Fat32file system Read and write with 3 modes of ram allocation. OK Doc RO
BTM bluetooth driver. Not finished ( Some functions not proved )
Samsung E700 TFT color display driver. OK Doc RO
Nokia 6100 display driver. Not completed (No 24Bit ink support ) Doc RO
HD44780 display driver. Not completed ( no optimization )
External I2C EEProm driver. OK
Internal eeprom driver. OK
Macro eeprom driver. OK
Joystick 5 direction driver. OK
General IO utility driver. OK
SD card driver in SPI mode. OK
Hardware SPI driver Macro mode. OK
Software SPI driver macro mode. Not tested
Uart hardware driver in macro mode. OK
VS 10xx driver. OK
(Added) 20x20 multiplexed matrix led display with 5 x 74hc574.

Library:

Variable conversion library. OK
Direct X library to work with display drivers included in this SDK. OK
Mathematics library. Not finished ( Some functions not proved )
Utility library. OK Doc RO Doc EN

System:

Internal EEProm file system. OK
Software ram disk file system. OK
Software timers created from one hardware timer. Not tested

Dx.asm is more important graphic management file from this sdk, because this file has an numerous utility functions to display:

Function to display characters in 8x6 pix format with variable weight.
Function to display strings using function from point 1.
Function to create menu bar with catted corners full or empty, one color for margins and one for internal.
Function to paint an line with an color (not finished).
Function to paint an bitmap in 8 or 24 bit format, stored in Internal Ram memory, Internal EEProm memory, Internal Flash memory, external serial flash memory(not finished), external serial EEprom memory(not finished) or SD memory card(not finished), is necessary to store entire bitmap not converted to bin or others formats( one utility to convert an entire bitmap to hex asm or c for avr can be found here ).
Function to display an progress bar created only from bitmaps stored in one of memories from point 5, this progress bar looks like progress from last MP3 player created by me and found here.

Download SDK 1.0.1

V1.0.0
This ASM SDK created by me is a group of library and drivers that contain:
Version 1.0
Drivers:

Fat32 file system Read and write with 3 modes of ram allocation. OK Doc RO
BTM bluetooth driver. Not finished ( Some functions not proved )
Samsung E700 TFT color display driver. OK Doc RO
Nokia 6100 display driver. Not completed (No 24Bit ink support ) Doc RO
HD44780 display driver. Not completed ( no optimization )
External I2C EEProm driver. OK
Internal eeprom driver. OK
Macro eeprom driver. OK
Joystick 5 direction driver. Not tested
General IO utility driver. OK
SD card driver in SPI mode. OK
Hardware SPI driver Macro mode. Not tested
Software SPI driver macro mode. Not tested
Uart hardware driver in macro mode. OK
VS 10xx driver. OK

Library:

Variable conversion library. OK
Direct X library to work with display drivers included in this SDK. Not tested
Mathematics library. Not finished ( Some functions not tested )
Utility library. OK Doc RO Doc EN

System:

Internal EEProm file system. OK
Software ram disk file system. OK
Software timers created from one hardware timer. Not tested

Download SDK 1.0.0

MP3 player with ATmega64 VS1011a and Samsung E700 color Display

2009-04-29T12:35:00.047+03:00

This is my new mp3 player.

For this MP3 player is new: the display and a new graphical interface explorer.

Knowing that the display of the Nokia 6100 is an old and extremely poor quality, I thought to exchange it with one TFT display ( higher quality ) , by doing this I thought I make an new interface, and this is the result:

-File type played (VS1011): Decodes MPEG 1.0 & 2.0 audio layer III
(CBR, VBR, ABR); layers I & II optional;
WAV (PCM + IMA ADPCM)
-File type played (VS1033): Decodes MPEG 1 & 2 audio layer III (CBR
+VBR +ABR); layers I & II optional;
MPEG4 / 2 AAC-LC-2.0.0.0 (+PNS);
WMA4.0/4.1/7/8/9 all profiles (5-384 kbps);
WAV (PCM + IMA ADPCM);
General MIDI / SP-MIDI format 0 files
-File type played (VS1053): Decodes Ogg Vorbis;
MPEG 1 & 2 audio layer III (CBR +VBR
+ABR); layers I & II optional;
MPEG4 / 2 AAC-LC(+PNS),
HE-AAC v2 (Level 3) (SBR + PS);
WMA4.0/4.1/7/8/9 all profiles (5-384 kbps);
WAV (PCM + IMA ADPCM);
General MIDI 1 / SP-MIDI format 0 files

For bitrate higher than 320Kb/s is necessary to increase the CPU frequency from fuses for 4Mhz to fuses for 8Mhz internal RC

This project is under develop.
Last update 14-06-2009
Download source code
Download the board .max and gerber files
Download orcad schematick
Download PDF schematick
Several variants of this player can be found for purchase here.

Mp3 Player with Winamp skin

Mp3 Player with Synthetic skin

Mp3 Player with Media Player skin Download demo hex file
The fuse bit be set for 4Mhz Internal RC Oscillator

Mp3 Player with Half Life skin

This player run 2 threads , one for navigating and one for serving data to VS1011.

The last rectify of compatibility of Fat32 filesystem library and Player data service library has increase the transfer rate , in this moment the player is capable to read 256Kbit/s melody at 4Mhz internal RC clock with osccal=199(default), and 320Kbit/s at 4Mhz and osccal=255 (approximately 5Mhz) internal RC clock.

Now i work to one explorer configured from skin file like XML file.

This navigator display the short filename if the long file name is not writed on the name of file.

For support post a comment

This project was abandoned for another more powerful.

DiY: most tiny MP3 player with ATmega8 VS1011a and Nokia6100 Display

2009-04-23T20:51:00.020+03:00

This is a complete mobile MP3 player and first mp3-player with ATmega8 and Nokia 6100 color display.

An demo firmware and gerber file for board will be available soon.

This player has capability to play wav and mp3 files and view BMP files on 8 or 24 bits/pixel from a MicroSD card with maximum capacity 2GB, the format of the SD is FAT32 with clusters from 512 Bytes to 32768Bytes, the filesystem has no limits in number of directories and files.
For future i want to adapting the SD driver for SDHC because the filesystem is designed to use all capacity of fat32 ( 2TB in 512Bytes/sector)

List of features:
Play Wav and MP3 Files because the VS1011a only this files is capable to decode( but for future in this project i want to include the VS1053 chip to play more file formats.
View Bitmap files on 8Bit and 24 bit/pixel

This project is in asm language and my 100% own libraries

For the moment the project has 5172Bytes of Flash , 663Bytes of Ram and 0Bytes of EEprom
Several variants of this player can be found for purchase here.

I work to another MP3 player:
New MP3 Player Link

VS1011a board ( MP3 decoder )

2009-04-17T12:31:00.004+03:00

This is a simple board for VS1011a MP3 decoder

Soon available for buy here.

ATXmega.....A1 ,Mp3Player ,RadioFm ,Rds ,Hdd ,Sd ,Ethernet ,2UsbHost

2009-03-26T10:15:00.009+02:00

Here i present you orcad capture schematic:

PDF Schematic

Fat32 complete library in asm language

2009-02-28T19:59:00.032+02:00

Observing that the file system created by me is almost identical to FAT32, i decided to convert to FAT32, this library work with clusters from 256 bytes to 32768 bytes autodetect from storage device.

This library is in asm language.

This file system is designed for double buffered (a buffer to the Allocation Table and a data buffer) this method of using separate buffers increase the rate of transfer to the storage device.

The buffer’s separation between allocation table and the data, makes that at each change of the data cluster not to charge the next cluster index from storage device. In this case, the index is token from allocation table’s buffer, if this is inside the sector memorized inside buffer. If this is not inside the sector of the buffer, then will be saved the buffer in allocation table (in case that inside the buffer has been made a modification), and then will be loaded in the sector where the index is.

In this way can be made with the data buffer. The pointer can be putted at an particular offset from open file, and then, from the address of the pointer can be read byte with byte, the pointer been incremented automatically. The same will be the sectors inside the buffer, those will be changed automatically. It doesn’t matter for user which cluster or bit must be read, because everything is done automatically. User must set the address of the file needed and the pointer of the address of the byte inside the file.

Done functions:
-Go to file/folder ( address in clusters )
-Go to next file/folder in current directory ( this function return Flag T in Sreg = 0 if the pointer is on bottom of the list else return 1)
-Go to forward file folder in current directory ( this function return Flag T in Sreg = 0 if the pointer is on top of the list else return 1)
-Read address on pointed file/folder ( in clusters )
-Read short name of pointed file/folder ( string 11 char )
-Read full name of pointed file/folder ( string max 128 char )
-Read byte by byte the file opened ( offset of byte in file ) with autoincrement pointer
-Write byte by byte in the file opened ( offset of byte in file ) with autoincrement pointer ( this function work with append in file and have property to enlarge the size of file )
-Read pointed file size (in bytes)
-Write pointed file size = current pointer
-Read pointed file attribute
-Write pointed file attribute
-Read pointer in opened file
-Write pointer in opened file
-Create file with short name converted from long name( Creating with long name not completed )
-CloseFile ( when the file is closed if the pointer in file is bigger to actual size of file , the actual size of file = pointer position in file ( in read mode is not possible to point to an byte address bigger to file size but in write mode this is possible because the file is auto enlarged )

The terminal have next functions:
+ :
Go Down one file folder and read short and long file name.
- :
Go Up one file folder and read short and long file name.
Enter :
1) Go to selected folder,
2) Open selected file,
3) Close opened file.
Esc :
Close opened file
p :
Enter in write long file name, and Enter will convert from long filename to short filename
c :
Create file with converted short filename

Performance obtained with ATmega640 at 16 Mhz and SPI hardware at 8Mhz:

Write SD Card with 512 Bytes/cluster = 48659 Bytes/s
Write SD Card with 4096 Bytes/cluster = 40163 Bytes/s
Read SD Card with 512 Bytes/cluster = 70286 Bytes/s
Read SD Card with 4096 Bytes/cluster = 56229 Bytes/s

Transfer rate depends on the device storage and on fragmentation.
The flash used not include the terminal

Resources for maxim 512 bytes/cluster:
Flash= 3220 Bytes ( Only read section )
Flash= 5042 Bytes ( Read and write sections )
Ram for allocation table management= 542
Ram for data management= 629 (512Bytes (Data Buffer)+ 64 (Bytes String Long Name) + 11Bytes (String Short Name) + Variables )
Total Ram= 1171Bytes

Resources for maxim 4096 bytes/cluster:
Flash= 3220 Bytes ( Only read section )
Flash= 5042 Bytes ( Read and write sections )
Ram for allocation table management= 542
Ram for data management= 4213 (4096Bytes (Data Buffer)+ 64 Bytes (String Long Name) + 11Bytes (String Short Name) + Variables )
Total Ram= 4755 Bytes

The ram size is set by user because the maximum size of cluster is set by ram buffer data cluster

The data management library is a dynamic library ( That means this library can be open multiple times, and when you call the library in Z must be the beginning address of RAM to work with ) for this i wrote the ram size table occupied by allocation library and data management library separately

In conclusion we can work with multiple open files using a single library written in flash that can work with multiple sections of ram

Operating principle:
This block function is one example only for 512 Bytes/Cluster Fat32 formats for other cluster dimension the ram allocation is different.

Fig1

In this moment i work to create and allocation table library from static library to dynamic library

These two libraries ( allocation table and data section ) will be in 2 variants:
1) A library will have only buffer for data which can be put on the controllers with ram more than 655Bytes
2) A library that does not include buffers (will lose the stats of dynamic library) but which can be put on the controllers that have the minimum 128Bytes of ram
____________________________________________________________________

This library is concept to work with only one buffer and work fine to my MP3 players at 5Mhz with 320Kb/s melody with one artifice, and from this moment this library is open source
This library use 3016Bytes of flash and 655Bytes of ram memory
The up bloc description in Fig1 can by applied and for this library

1)Fat32_DataInit
2)Fat32_ReadByte
3)Fat32_GoToRoot
4)Fat32_GoToFile
5)Fat32_ResetDirPointer
6)Fat32_IncrementDirPointer
7)Fat32_DecrementDirPointer
8)Fat32_GetShortFileName
9)Fat32_GetLongFileName
10)Fat32_GetFileAdress
11)Fat32_ReadFileSize
12)Fat32_ReadFileAttr
13)Fat32_WritePointerInFile
14)Fat32_ReadPointerInFile
15)Fat32_OpenPointedFileFolder
16)Fat32_CloseFile

Last update 17-06-2009
Download fat32 read only library for atmega64
Download fat32 read only library for atmega8

Now this driver is updated and included in my ASM_SDK here

For support post a comment

My own filesystem for non volatile storage devices

2009-02-13T15:57:00.012+02:00

This is a very fast file system for all memory devices ( SD/MMC, HDD, and others memory storage ) and is created in ASM language.
This file system is double buffered ( One buffer for index and one buffer for data )this method was adopted to maximize performance in the event that more files are open at the same time.
Support maximum capacity between 2^40 Bytes in 256 Bytes per page and 2^48 Bytes in 65536 Bytes per page.
For moment at 16 Mhz and SPI = 8Mhz transfer rate between Controller and SD Card is: Read = 86,036KBytes/S, Write = 52,675KBytes/S in 512 Bytes per page and Read = 86,036KBytes/s, Write = 71,697KBytes/s in 2048Bytes per page.

For now this file system has the following features included:
1) FastFormatDriveMemory
2) ModifyFileDimension (From 1 do Maxim Storage support dimension )
3) ReadOneByteFromFile ( With autoincrement pointer )
4) WriteOneByteToFile ( With autoincrement pointer )
5) Create Folder (The name is maxim 48 Char )(Normal folder,Read Only Folder,System Folder,Hidden Folder)
6) Create File (The name is maxim 48 Char )(Normal File,Read Only File,System File,Hidden File)
7) Back <- 8) Rename File/Folder (ex: point "file/folder name",rename "new file/folder name" For writing method is a special feature to enlarge the size of file while writing it (for example if the file is originally created by 512 bytes (one page) and would write in 700 byte will automatically extend the file size 1024 Bytes ( 2 pages ),(If a file is created for 512Bytes long and i want to write 1MBytes linear the Write function enlarge file page by page to 1MByte size), if one file have 512 bytes dimension and i want to read one byte from 513 address the read function return error. Section of indexes on the storage is separate from the data, such is accessed 128 less pages if a page has 512 Bytes and 512 times in case a page has 2048 bytes, for navigating through the files or in the file( for example: In 512 bytes/page, one page in index sections contain indexes for 65536 Data Bytes, in 2048 Bytes/page ( maximum length of one page for SD/MMC card ) one page in index section contain indexes for 1048576 Data Bytes ). For moment the terminal contain next commands: 1) ls ( List files and folders from current folder ) 2) mkfil ( make a file with name max 48 char in current director ) 3) mkdir ( make a folder with name max 48 char in current director ) 4) cd .. ( go back ) 5) cd director ( go up one directory ) 6) format 7) point file/folder 8) rename new name of pointed file/folder

The Board is this:

From Digital electronics and programing

4x25W amplifier with internal usb control

2009-01-29T22:22:00.006+02:00

This is a 4x22W amplifier 4Ohm which is young for a PCI Desktop slot and can be diagnosed and controlled by an internal USB connector.
This project is still in development stage
This card is made with a specialized circuit in Class D with I2C control interface produced by TexasInstruments TAS5414 QFP64 and a ATmega8 controller

USB Unipolar 3 in 1 Motor Stepper Controller

2009-01-14T12:17:00.011+02:00

This is a usb controller for 3 engines unipolar step by step, you can move completely independent, and in terms of speed of rotation sense and the coordinated which should be.

The position of engine can take value between -2147483648 and 2147483647
Minim velocity = 0.015 steps/second
Maximum velocity = 1000 steps/second

Here i posted a brief presentation of the controller in the prototype phase, it will arrive in stores in a short period.

It is designed around an ATmega8 microcontroller with USB1.1 software interface and drivers that are used is ULN2003

This is the interface for the PC, to control in real-time the controller:

And this is the prototype controller board:

In the next image is described command method :

From Digital electronics and programing

Update for PC program, add new function:

Soon available for buy here.

ATmega64 simple Board

2008-11-20T20:39:00.010+02:00

This is a very simple board for ATmega64

Download .MAX project and Gerber files

3in1 unipolar motor steper controller

2008-11-12T14:46:00.009+02:00

This project is designed for control 3 motors stepper independently with only one ATmega8 mocrocontroller

This project has been designed for unipolar engines

The interface is Serial 19200b/s

For Bipolar engines

Download entire project

My fourth micro development board for atmega 640-1280-2560

2008-11-09T11:41:00.011+02:00

It developed this board for commercial use , so do not you publish the file .MAX ,
We developed by removing certain modules that are present on this board development

This board is designed to be able to connect on data bus and addresses up to 6 extension modules, besides memory and external display Samsung E700.

This development board is in this stage:

Kernel V0.4 for atmega microcontrollers

2008-11-06T16:57:00.008+02:00

This is an upgrade of the Kernel V0.3 Kernel V0.2 and brings with him besides the possibility that programs running What could have direct access to physical memory directly without the intermediate certain routines included in the kernel, and the possibility that a program can open multiple libraries who will perform in the assigned to the program what these libraries open.

Major modifications are:

I changed how to access the RAM allocated program for the program or library.

I changed the style of training the virtual ram.
-Changing the virtualization of RAM, programs can not change the size of the RAM went
-The size of ram ocupied will be declared in the head.
unless otherwise create virtualized file and copy the old file in the new file, then delete the old file

I changed how to open other programs and to include libraries in the program.

And we designed in such a way as to be compiled for all types of products ATmega.

This kernel runs programs like .exe programs.

Example of how to open,close and include libraries .PDF

All kernel routines utilities:
1)ReadHeaderOfProgramOrLibrary
2)HeaderProgram
3)HeaderLibrary
4)RDEEPROM
5)RWEEPROM
6)ReserveRamMemoryForProgram
7)CalculateStringAdressInHeadOfProgramOrLibrary
8)SearchProgramOrLibrary
9)SearchProgramAndLauch
10)TransmitComandToOneLibraryOrOneProgram
11)ConvertFromRamBytesInRamPages
12)FreeRamForCurentProgramOrLibrary

Routines for user uses is inly:
1)HeaderProgram
2)HeaderLibrary
3)RDEEPROM
4)RWEEPROM
5)ReserveRamMemoryForProgram
6)SearchProgramAndLauch
7)TransmitComandToOneLibraryOrOneProgram
8)FreeRamForCurentProgramOrLibrary

In this stage the nucleus of the kernel has 1018Bytes of flash memory, and is not designet to work with threads

Real schematik to interface a SD/MMC card to atmega microcontrollers

2008-10-22T11:59:00.010+03:00

Because many sites operate a scheme to connect an SD/MMC card to a ATmega microcontroller that is non functional, I mean scheme with dividing resistive to the ground, I decided to post an overall scheme real functional and will post and parameters operation of a card at different voltages, everything after more probe:

We know that most cards SD/MMC operates in a voltage between 2.7 and 3.6 V, I will recommend one to use the minimum operating voltage.
However such a card works at 5V supply voltage without any risk of failure, but a voltage across the card manufacturer's specifications will work only read data and read CID etc. Write delete functions will not work

SD/MMC card and ATmega at diferent voltages:

SD/MMC card and ATmega at same voltages:

Spi Software for all atmega microcontrollers

2008-10-12T14:49:00.010+03:00

This is a simple library for software SPI compatible with all ATmega microcontrollers according to specifications 45DB SPI interface

( is not proved yet )

Download ASM Library

Driver for Nand Flash memory chip for normal port operation

2008-10-10T20:58:00.014+03:00

This is one driver for interfacing programs to Nand Flash Chip Memory as those used in Stik USB or SD / MMC cards

It is known that a page of a nand Flash memory is 2048 +16 Bytes

Nand flash memories allow delete only a block of data or the entire chip, writing a whole page, reading a whole page, or rewriting a page keeps unchanged, but you can not edit a byte already written a page.

This example is for 1GByte nand flash chip memory K9K8G08U0A

Download ASM code driver

Download .Max Orcad Project

Soon a test board available for buy.

PPC terminal for Com ports

2008-10-10T20:17:00.008+03:00

This is one Com terminal for poket PC for Windows Mobyle 2003 or later

For runing this terminal is necesary .Net Framework 2.0

Download .Exe Program

Smartphone terminal for Com ports

2008-10-10T20:10:00.011+03:00

This is one sample com terminal for Windows mobile Smartphone edition 5.0 or later

For runing this terminal is necesary .Net Framework 2.0

Download .Exe program

I2C library for 24C.... external EEprom memory for ATmega microcontrollers

2008-10-10T00:01:00.011+03:00

This is a driver for control one 24c... EEProm memory on Byte level for read / write and page level for complete format

This driver is compatible with EEProm i2c memory between 512 and 65536 Bytes capacity.

This library is made for ATmega8 but with some modifications is working on all ATmega microcontrollers

Download this library

New explorer for max displays resolution 244x244

2008-10-08T14:58:00.033+03:00

An explorer full display Samsung E700.
This driver will include:

1) Draw a text:

- The default color set to initiate the page or run Explorer
- With a pre-color description in the order of drawing text

2) Draws a link:

- Link will default colors to select and clear preset to initiate or start page Explorer, calling routines click on this link will call on the name and number to order the program.
- Link will set the colors in the description Linc to select and deselect preset to initiate or start page Explorer, calling routines click on this link will call on the name and number to order the program.
- Link will default to select colors and clear preset to initiate or start page Explorer, calling routines click on this link will call at the number and order of the program.
- Link will set the colors in the description Linc to select and deselect preset to initiate or start page Explorer, calling routines click on this link will call at the number and order of the program.

3) text editor:

- During the translation page and display them when there is a text editor library will call the name of the program that is attached to the text and edit the command, the program can read the contents edited text of a buffer separate text content publisher to create page will be "FF", this program has to return the same string buffer that will be displayed in text editor.
- During the translation page and display them when there is a text editor library will be made by calling the program that is attached to the text and edit the command, the program can read the contents edited text of a buffer separate text content publisher to create page will be "FF", this program has to return the same string buffer that will be displayed in text editor.
(Color color text will be declared the creation of the page or initiate Explorer, the color of the border will be declared the creation of the color page or entering into Explorer, background color of text edit initially will be white)

4) Chek box:

- During the translation page and display them when there is a check box library will call the name of the program that is attached in check box and the command, the program can read 2 = Neinitializat, 0 = We checked, 1 = ticked in the register R16 Thus creating the page will be read will be 2, this program has to return in the same register 0 = us option 1 = check, as will happen every call of that program and the routine question
- During the translation page and display them when there is a check box library will be made by calling the program that is attached in chek box and the command, the program can read 2 = Neinitializat, 0 = We checked, 1 = ticked in the register R16 Thus creating the page will be read will be 2, this program has to return in the same register 0 = us option 1 = check, as will happen every call of that program and the routine question

The format of description page in buffer is:

SetBacgroundColor:

- 4 | 0 | Color(Low),Color(High)

SetInkColor:

- 4 | 1 | Color(Low),Color(High)

SetBarColor:

- 4 | 2 | Color(Low),Color(High)

SetPointerAdress:

- 4 | 3 | X AdressForPointer,Y AdressForPointer

PrintStaticText:

PrintLinkText:

PrintTextEdit:

PrintKeckBox:

SetLinkColor:

- 6 | 8 | UnSelectedLinkColor(Low),UnSelectedLinkColor(High)| SelectedLinkColor(Low),SelectedLinkColor(High)

SetPointer:

- 4 | 9 | X Coordonate | Y Coordonate

PaintVerticalLine:

- 6 | 10 | 0 | X Coordonate | Y Coordonate | Y Length

- 8 | 10 | 1 | Low(Color),High(Color) | X Coordonate | Y Coordonate | Y Length

PaintHorizontalLine:

- 6 | 11 | 0 | X Coordonate | Y Coordonate | X Length

- 8 | 11 | 1 | Low(Color),High(Color) | X Coordonate | Y Coordonate | X Length

PaintSquare:

SetPlotColor:

- 4 | 13 | Color(Low),Color(High)

Status = coming up soon

Topics toll programs by name and was implemented for the explorer to be compatible with Kernel V0.3 learned here

The stage of this explorer is:

For example for paint One label ,3 links , 1 versical bar, one horizontal bar, one rectangle , one check box ( uncheked) and one chek box (cheked) load in buffer memory this data code:

.Equ CodeForSetBacgroundColor = 0
.Equ CodeForSetInkColor = 1
.Equ CodeForSetBarColor = 2
.Equ CodeForSetPointerAdress = 3
.Equ CodeForPrintStaticText = 4
.Equ CodeForPrintLinkText = 5
.Equ CodeForPrintTextEdit = 6
.Equ CodeForPrintKeckBox = 7
.Equ CodeForSetLinkColor = 8
.Equ CodeForSetPointer = 9
.Equ CodeToPaintVerticalLine =10
.Equ CodeToPaintHorizontalLine =11
.Equ CodeToPaintSquare =12
.Equ CodeForSetPlotColor =13

.db 4,CodeForSetBacgroundColor,Low(BLUE),High(BLUE),
4,CodeForSetInkColor,Low(WHITE),High(WHITE),
6,CodeForSetLinkColor,Low(YELLOW),High(YELLOW),Low(RED),High(RED),
12,CodeForPrintStaticText,0,8,"Hello!!!",
4,CodeForSetPointer,0,8,
14,CodeForPrintStaticText,1,Low(RED),High(RED),8,"Hello!!!",
4,CodeForSetPointer,0,16,
24,CodeForPrintLinkText,0,0,0,8,"Hello!!!",1,8,"Hello!!!",
4,CodeForSetPointer,0,24,
24,CodeForPrintLinkText,1,0,0,8,"Hello!!!",1,8,"Hello!!!",
4,CodeForSetPointer,0,32,
24,CodeForPrintLinkText,0,0,0,8,"Hello!!!",1,8,"Hello!!!",
14,CodeForPrintKeckBox,0,0,0,8,"Hello!!!",
14,CodeForPrintKeckBox,0,1,0,8,"Hello!!!",
6,CodeToPaintVerticalLine,0,50,50,30,
6,CodeToPaintHorizontalLine,0,50,50,30,
7,CodeToPaintSquare,0,2,60,40,10,255

And result this for samsung e700 display:

Text edit implemented

This is the complete schematic for one atmega64 and one samsung e700 display( the ram memory is not necessarily )

My third development board for ATmega640-1280-2560

2008-10-06T13:45:00.030+03:00

There are modules and connectors to come on this development board.
Point out that I did not even cable.

Here is described the top face:

Here is described Bottom face:

Download .MAX project for orcad

Manage page from SD/MMC/HDD memory with page bufer

2008-10-05T11:47:00.014+03:00

This is one driver for accessing SD/MMC/HDD drive on byte level with auto replacement page selection

This driver support drives until up to the amount 2^41 in 512Bytes on page and 2^48 bytes in 65536Bytes per page

This library is ready to serves pages from 256 to 65536Bytes

Download ASM driver file

And this driver is interface to up driver and SD card memory

Download ASM driver file

With this drivers on ATmega640 at 19,5Mhz the transfer rate betwen Controller and SD card is :
-63167Bytes/s Linear write
-111550Bytes/s Linear read

Most tiny AVR Dopper programator for atmega microcontrollers

2008-10-04T22:33:00.029+03:00

Download .MAX board project for orcad
Link to download AVR Doper firmware and driver

Development board 2 for ATmega640

2008-10-04T22:18:00.017+03:00

Download .MAX project for this development board

Download Gerber files for this development board

Development board 1 for ATmega640

2008-10-04T22:15:00.018+03:00

Download .MAX Project for this development board

Development board for ATmega64

2008-10-04T22:09:00.017+03:00

Download .MAX Board project for orcad

Simple RPM Auto

2008-10-04T16:14:00.014+03:00

Download Firmware and ASM code

A small remote controll for 8 digital channels

2008-10-04T15:59:00.015+03:00

This is one remote control wih ATmega8 and Rx-Tx Modules
The fuse bits be set up to work with internal RC oscillator 1Mhz

Download Tx Firmware and ASM code
Download Rx Firmware and ASM code

Soon available for buy.

Mini Led Cross

2008-10-04T15:43:00.012+03:00

One sample led cross

Download entire project

Miniexplorer for ATmega microcontrollers and Nokia6100 Displays Philips chip

2008-10-04T14:58:00.011+03:00

This is one minidriver and explorer for ATmega microcontrollers and Nokia6100 Displays with Philips chip

Download entire project no logo suport ( only color )

Extended driver in comand line for Nokia6100 Display Philips chip

2008-10-04T14:45:00.012+03:00

This driver is designed to work with a display of Nokia6100 with the Philips chip and is provided with additional features from the base:

This driver is double buffered to refrash's on display only characters that are modified in this way speed refrash being much improved given that SPI interface 9Biti display is done with software

Positions included declared constants in the driver are:

1) DisplayIdle = Idle
2) DisplaySetup = Interface Setup
3) DisplayWriteChar = WriteOneChar (auto increment, R16 = character writing)
4) DisplayUpCursor Moving the cursor from the menu at a superior position
5) DisplayDnCursor = The move cursor on the menu at a lower position
6) DisplayGetCursor = Read position the cursor on the menu (R16 = Position)
7) DisplayClear = Clear display
8) DisplayWriteTxt = enter a default text from flash memory
9) DisplayCreateProgress = Create a Progress bar
10)DisplayProgressRfsh = Update the progress bar (yl = value between 0 and 111)
11) DisplayCreateMenu = Create a Menu (x is adress of menu in Flash)
12) DisplayInkColor = Set the color character (R16-R17 = color)
13) DisplayBekgroundColor = Set the becground color (R16-R17 = color)
14) InteruptDriverLCD = Interupt priority

To access this subrutinelor driver just called routine selection functions.

EX:
Ldi R25,(Commanda)
Mov R15,R25
Rcall PrimireComenziDriverLcd6100

Resurse consumate:
- Flash ...
- EEprom ...
- Ram = (2x256)+20Bytes

Rfsh display is made to order InteruptPriorrity therefore it should be called the most possible and loops of delay and Idle because every call of this is rfsh a character on display, so to make everything rfsh display is need to call this with 256 times.
I chose this method because rfsh entire rfsh display controller take quite a long time about 0.2 seconds and if it stays in a loop of 5-second delay for example in those 5 seconds is no longer able to refrash, so may resort to a contrivance: to make delay-ROMs and much shorter and every delay to send the command to rfsh such display is being updated and if the display is ADD characters and commands of interruptions

Download this driver

Minidriver for Nokia3310 Display

2008-10-04T14:05:00.012+03:00

This is a general driver

EX:
Ldi R25,(Command)
Mov R15,R25
Rcall PrimireComenziDriverLcd3310

1) Idle
2) Setup Interface
3) No Comand
4) WriteOneChar(auto increment, R16 = The aracter)
5) WriteOneCharWithAdress(R16 = The caracterul,R17 = Vertical adress (0 to 13),R18 = Horizontal adress (0 to 4)
6) Clear display(Black Color)
7) Clear display(White Color)
8) Print Logo (x = The adress of logo in flash memory,R17 = Orizontal adress in char (0 to 13),R18 = Vertical adress in char (0 to 4))
The logo is in this format:
; ------------------------------------------------------------------------------------------------------------------------------
|Low(LogoDimension)|High(LogoDimension)|0=NonInvertingColor,1=InvertingColor|......Logo.................|
------------------------------------------------------------------------------------------------------------------------------

Download driver

Minidriver for 2x16 to 4x40 Char display

2008-10-04T14:02:00.012+03:00

Driver for Hd44780 8bit data bus

This driver is designed for 2x16 to 4x40 Char

Include:
Char Write
Text write from Flash
Clear Display

Function included:
DisplayIdle44780
DisplaySetup44780
DisplayWriteChar44780
DisplayClear44780
DisplayWriteTxt44780

Download driver

Minidriver for Sharp displays 320x240

2008-10-04T13:52:00.011+03:00

This is a driver for 320x240 3,5 inch Sharp display in command line mode 2,5 FPS atmega64 16 mhz

To display the characters on the screen uses a buffer for ASCII characters to be displayed with the size of 1200Bytes (Xresolution / XCaracterDimension) * (Yresolution / YCaracterDimension)

Download entire project

RPM & Temperature & Gass Monitor

2008-10-04T13:38:00.011+03:00

One simply project for ATmega Microcontrollers

Function = RPM & Temperature & Gass Monitor in Graphic mode

Contain:
One module for measurament of pulse and convert in RPM
One module for measurament of Temperature in analogic mode
One module for measurament of Fuel Gass in analogic mode
One driver for LCD display Nokia 3310 including char inserting and logo paint
This program is compiled in ASM AVRStudio 4

Target core = Posted for Atmega8
Modified = All ATmega Core

Resources :
Data Flash = 2114 Bytes
Code Flash = 1256 Bytes
Total Flash = 3370 Bytes
Data Ram = 7 Bytes

Download entire project

3 in 1 bipolar motor steper controller with only one controller

2008-10-04T13:16:00.018+03:00

This project is designed for control 3 motors stepper independently with only one ATmega8 mocrocontroller
The interface is Serial 19200b/s

Dovnload entire project

Soon available for buy.

Kernel V0.3 for atmega microcontrollers

2008-10-04T13:13:00.024+03:00

This project is a kernel initially made for ATmega 640.

Download project

The number of threads maximum 254 or limited with the ram memory dimension.

Description:
- This kernel was designed to use all the processing power of an microcontroller, in the case when on a device are used more microcontrollers each one with different functions and they (microcontrollers) don't work at maximum capacity, and it can facilitate tremendously the job of an programator who wants to implement more functions in only one microcontroller.

- On this kernel, more programs totally independently can work simultaneously (in the same time), the only thing that is affect is the processing power on each one.

- This programs can communicate between them using the name ( string 16 Chars ) of the program and/or the address of program in Flash obtained from one ping to the name of program for idle-section of program, so if we update a program or a driver, it will replace the old one with the new one without actualizing the remaining programs (the programs who were not updated) to the new address of the new program, the address of new program is declared in the installed programs table.

- When a program starts to run the kernel reads from the program haw much memory ram to give him, the kernel assigns to the program the memory ram demanded rounded of form 128 in 128 Bytes (if a program needs 0 (zero) memory ram the kernel will not assign ram memory to that program; if a program needs 1-128 Bytes memory ram the kernel will assign 128 Bytes ram memory to that program; if a program needs 129-256 Bytes memory ram the kernel will assign 256 Bytes ram memory to that program) but when the program is running it can change the dimension of the memory ram assigned, according to the memory ram he needs, by "handing in an application" to the kernel demanding a change of memory ram assigned.

- If a program requests to the kernel to open a program the kernel can open it, the kernel is checking if that program is already open, if that program is open, the kernel reads if that program can be open again, if it can be open again it will be open like a new thread independently from the previous and it will give a order number (the first open program will have the number of order 0 (zero), the second program open will have the number of order 1 etc.) this value it will be return to the program who requested the open to the program to make the difference between the open threads with the same ID. If the requested program can't be open many times, the program who demanded the open of the program will receive an error the program can't be open because is already open. (This function is incomplete implemented.)

- At the end of a program, the kernel is taking care of deleting the cluster of memory ram occupied by the program (the memory ram that this program occupied can be used by future open program) and immediately the kernel will compact the table in which are kept the principals dates of each open program.

- A program can be force closed by the kernel if there is an stack overflow error, the program can request the kernel to be closed or the kernel receive the close command from another program, and the program who will be closed can save the working dates and after that sending the close command to the kernel.

- The open programs divide the processing power equally, but there is the case when a program is in idle, in this case the program will sent to the kernel a interrupt command, the processing power remain between the time when the demand of interrupt and the time of interrupt is equally divided to the running programs.

- For each program the kernel assigns an cluster of memory ram of 128 octets because when the program is interrupted the kernel to save 32 registry, stank counter and 93 Bytes from the stank occupied by the program, before returning in the interrupted program the kernel will restore the contents of 32 registry ,the stank and counter of the stank and the stank.

- The memory ram for each program begins from an virtual address 0 (zero) in the registry Z where is the address of the head cluster of the memory ram assigned, if a program wants to find out the address of the head cluster memory ram assigned it can appeal a routine from the kernel to give him the address (in this way, using an artifice we can use the direct address knowing that the cluster memory ram used starts at the head address +2).

- System Timers: They were integrated to can make data processing and to an exact time and for software pause in lock delays, system timer have 128 steps/sec, so we can create software with the exact time of the external Quartz of 32768Hz

(Still working at kernel.)

This kernel can be adapted on any microcontroller ATmega with the some little modifications.

Here is an description to use this kernel

This kernel is a fully dynamic kernel, all files to use this kernel is in virtual ram memory

One bug is present in this kernel because is not possible to close one program if run minimum 3 threads, if one thread is closed if is running one or two thread this kernel will freeze.

For eliminate this error please use 3 ghost threads like this:
_____________________________________________________________
Ghost programs ( these programs no consume processing power )
Ldi Yl,Low(Ghost1*2)
Ldi Yh,High(Ghost1*2)
Call LauchProgram

Ldi Yl,Low(Ghost2*2)
Ldi Yh,High(Ghost2*2)
Call LauchProgram

Ldi Yl,Low(Ghost2*2)
Ldi Yh,High(Ghost2*2)
Call LauchProgram

User programs ( this programs is a user programs lached in startup )
Ldi Yl,Low(Program1*2)
Ldi Yh,High(Program1*2)
Call LauchProgram
;**********************************************************
Sei
;**********************************************************
IdleKernel:
Wdr
Rjmp IdleKernel
;**********************************************************
---------------------------------------------------------------------------------------
Ghost1:
.Db "Ghost1",255,255,255,255,255,255,255,255,255,255
.Dw EndGhost1-Ghost1
.Dw 0
.Dw 0
Ghost1Startup:
Call IntrerupereThreadLaCerere
Rjmp Ghost1Startup
EndGhost1:
---------------------------------------------------------------------------------------
Ghost2:
.Db "Ghost2",255,255,255,255,255,255,255,255,255,255
.Dw EndGhost2-Ghost2
.Dw 0
.Dw 0
Ghost2Startup:
Call IntrerupereThreadLaCerere
Rjmp Ghost2Startup
EndGhost2:
---------------------------------------------------------------------------------------
Ghost3:
.Db "Ghost3",255,255,255,255,255,255,255,255,255,255
.Dw EndGhost3-Ghost3
.Dw 0
.Dw 0
Ghost3Startup:
Call IntrerupereThreadLaCerere
Rjmp Ghost3Startup
EndGhost3:
_____________________________________________________________

With this sequences is launched one program:

Ldi Yl,Low(Program1*2)
Ldi Yh,High(Program1*2)
Call LauchProgram

With this sequences is created the resources of ram but until this sequences the program is not launched, the program is launched after kernel scan the table of start programs.
_____________________________________________________________

Here is a simple thread to run on this kernel:

Program1:
.Db "ProgramTest1",255,255,255,255;Here is a string with maxim 16 char ( this is the name of task ) this string is necessarily to end with 255 int8
.Dw EndProgram1-Program1;Here is a int16 dimension of the program
.Dw 63; Here is a int16 ( how ram to assign to this thread )
.Dw 0;Here is a int16 constant divided in Boolean that describe the configuration thread
;Vectors ( links ) for routines in program
Program1Startup:;Here jump the kernel until the all resources is reserved for this thread, here is start of thread
Rjmp Program1Startup_
Until start link , is the links of routines of this thread ( for this example , no links )
...
...
...
...
...
...
...
...
;End of vectors and begin of program routines, no chase in this example
Program1Startup_:
Lds R17,DDRH;\
Sbr R17,1<<2;Here is the configuration section for this thread, here is configurations of all port and resources used by this thread
Sts DDRH,R17;/
Program1Startup__:; Here is the main of this thread
Ldi R16,16
Rcall SlepS
Cli
Lds R17,PORTH
Sbr R17,1<<2;
Sts PORTH,R17
Sei
Rcall SlepS
Cli
Lds R17,PORTH
Cbr R17,1<<2 ;
Sts PORTH,R17
Sei ;If is used ( Jmp CloseProgram ) this thread is closed ( killed )
Program1Startup___:
Call IntrerupereThreadLaCerere;Here is interrupt request from the thread, because this thread no longer needs processing power
Rjmp Program1Startup___;After the kernel restore this thread go again to interrupt request
EndProgram1:
_____________________________________________________________

For read and write to ram memory with errors capture use these sequences:

Rcall GetRamAdressForCurentThreadInZ;Read file adress ( here is the head of ram file assigned to this thread )
Ldi Xl,Low( Offset in file )
Ldi Xh,High( Offset in file );In X is offset of byte in file
Ldi R16,'A';In R16 is byte to write
Call WriteToVirtualRamFile
Rjmp ErrorOutOfVirtualMemory;This routine is return here if is a out of file error this jump es used by user to capture this error
;Or here if no error encountred
Call ReadFromVirtualRamFile; In R16 is byte result
Rjmp ErrorOutOfVirtualMemory;This routine is return here if is a out of file error this jump es used by user to capture this error
;Or here if no error encountred
_____________________________________________________________

For read and write to ram memory with no errors capture use these sequences:

Rcall GetRamAdressForCurentThreadInZ;Read file adress ( here is the head of ram file assigned to this thread )
Ldi Xl,Low( Offset in file )
Ldi Xh,High( Offset in file );In X is offset of byte in file
Ldi R16,'A';In R16 is byte to write
Call WriteToVirtualRamFile
Nop
Call ReadFromVirtualRamFile; In R16 is byte result
Nop
_____________________________________________________________

For read and write to ram memory with errors capture and autoextend ram memory space if is detected an out of file error use these sequences:

Rcall GetRamAdressForCurentThreadInZ;Read file adress ( here is the head of ram file assigned to this thread )
Ldi Xl,Low( Offset in file )
Ldi Xh,High( Offset in file );In X is offset of byte in file
Ldi R16,'A';In R16 is byte to write
ReturnFromExtendFile:
Call WriteToVirtualRamFile
Rjmp ErrorOutOfVirtualMemoryExtendFile;This routine is return here if is a out of file error this jump es used by user to capture this error
;Or here if no error encountred
Call ReadFromVirtualRamFile; In R16 is byte result
Nop
---------------------------------------------------------------------------------------
ErrorOutOfVirtualMemoryExtendFile:
Rcall ModifyVirtualRamFileDimension
Rjmp ReturnFromExtendFile
_____________________________________________________________

Kernel V0.2 for atmega microcontrollers

2008-10-04T12:21:00.006+03:00

This project is a kernel initially made for ATmega 64.

Description:
- This kernel was designed to use all the processing power of an microcontroller, in the case when on a device are used more microcontrollers each one with different functions and they (microcontrollers) don't work at maximum capacity, and it can facilitate tremendously the job of an programator who wants to implement more functions in only one microcontroller.

- On this kernel, more programs totally independently can work simultaneously (in the same time), the only thing that is affect is the processing power on each one.

- This programs can communicate between them using the unic number id ( Integer 2Bytes ) of the program and/or the address of program in Flash obtained from one ping to the name of program for idle-section of program, so if we update a program or a driver, it will replace the old one with the new one without actualizing the remaining programs (the programs who were not updated) to the new address of the new program, the address of new program is declared in the installed programs table.

- When a program starts to run the kernel reads from the program haw much memory ram to give him, the kernel assigns to the program the memory ram demanded rounded of form 64 in 64 Bytes (if a program needs 0 (zero) memory ram the kernel will not assign ram memory to that program; if a program needs 1-64 Bytes memory ram the kernel will assign 64 Bytes ram memory to that program; if a program needs 65-128 Bytes memory ram the kernel will assign 128 Bytes ram memory to that program) but when the program is running it can change the dimension of the memory ram assigned, according to the memory ram he needs, by "handing in an application" to the kernel demanding a change of memory ram assigned.

- If a program requests to the kernel to open a program the kernel can open it, the kernel is checking if that program is already open, if that program is open, the kernel reads if that program can be open again, if it can be open again it will be open like a new thread independently from the previous and it will give a order number (the first open program will have the number of order 0 (zero), the second program open will have the number of order 1 etc.) this value it will be return to the program who requested the open to the program to make the difference between the open threads with the same ID. If the requested program can't be open many times, the program who demanded the open of the program will receive an error the program can't be open because is already open. (This function is incomplete implemented.)

- At the end of a program, the kernel is taking care of deleting the cluster of memory ram occupied by the program (the memory ram that this program occupied can be used by future open program) and immediately the kernel will compact the table in which are kept the principals dates of each open program.

- A program can be force closed by the kernel if there is an stack overflow error, the program can request the kernel to be closed or the kernel receive the close command from another program, and the program who will be closed can save the working dates and after that sending the close command to the kernel.

- The open programs divide the processing power equally, but there is the case when a program is in idle, in this case the program will sent to the kernel a interrupt command, the processing power remain between the time when the demand of interrupt and the time of interrupt is equally divided to the running programs.

- For each program the kernel assigns an cluster of memory ram of 64 octets because when the program is interrupted the kernel to save 32 registry, stank counter and 29 Bytes from the stank occupied by the program, before returning in the interrupted program the kernel will restore the contents of 32 registry ,the stank and counter of the stank and the stank.

- The memory ram for each program begins from an virtual address 0 (zero) in the registry Z where is the address of the head cluster of the memory ram assigned, if a program wants to find out the address of the head cluster memory ram assigned it can appeal a routine from the kernel to give him the address (in this way, using an artifice we can use the direct address knowing that the cluster memory ram used starts at the head address +2).

- System Timers: They were integrated to can make data processing and to an exact time and for software pause in lock delays, system timer have 128 steps/sec, so we can create software with the exact time of the external Quartz of 32768Hz

This kernel can be adapted on any microcontroller ATmega with the some little modifications.