[product_section_start:product_page_section_overview.png]

Low cost 125kHz passive RFID tags are the ideal choice for all sorts of identification applications.  However many engineers view the task of designing a 125kHz RFID reader as too daunting a job involving dabbling in the black arts of radio frequency design.  Instead an engineer will typically opt for the safe approach of using one of the many off the shelf but expensive RFID reader OEM modules.

Actually designing a 125KHz RFID reader is very straightforward if a good RFID reader IC is used and this driver is designed to work with the excellent NXP (formerly Philips) HTRC110 RFID Reader Chip.

[product_section_start:product_page_section_details.png]

This driver provides complete functionality to read EM Marin EM4102 (previously named H4001/H4102) and compatible RFID transponders.  The EM4100 is one of the more common data formats for RFID transponders, so named because the microchip at the heart of compatible tags are based on a controller chip originally made by the company EM Microelectronic.  The protocol is typically used by the many types of generic 125kHz read only passive RFID tags available from a huge range of suppliers.  These simple RFID transponders carry 40 bits of read only memory and are typically supplied with a globally unique ID value (the 40 bits provide1,099,511,627,776 combinations).

The driver provides the following main features:-

• Automatically handles the 64, 32 or 16 period data rates and Manchester or Biphase encoding methods used by EM4102 based tags.  Most tags use Manchester encoding due to many RFID readers only supporting Manchester encoded tags.
• Optimised for small code footprint embedded designs.
• State machine and interrupt based implementation to avoid your application stalling while tags are read and the modulated data stream decoded.
• Automatically switches the HTRC110 to low power mode between reading tags.
• No reliance on compiler specific libraries.
• Full source code supplied for you to use and modify as required.

[product_section_start:product_page_section_specifications.png]

Hardware Specifications

The driver is designed to support the NXP HTRC110 RFID reader chip.  The driver has been designed to work with 8-bit, 16-bit and 32-bit microcontrollers.

In order to decode the modulated RFID tag data stream the driver requires the RFID Dout connection to be made to a microcontroller rising edge interrupt pin.  The driver carries out all other communications by driving and reading the microcontroller pins directly.

[product_section_start:product_page_section_compilers.png]

		This source code product is written in C and has been designed to be used with any ANSI compliant C compiler on any platform. Direct compatibility has been tested with the compilers and processors / microcontrollers listed below. Using the driver with other ANSI compliant C compilers and devices should not present significant problems.

		Tested with the Microchip C18 MPLAB C Compiler for PIC18 family of 8 bit microcontrollers with sample project included. Free version of the compiler available from Microchip.

[product_section_start:product_page_section_documentation.png]

	View the project technical manual
	View the most recent project revision history (useful for past customers to check for any modifications since they received their files)

[product_section_start:product_page_section_sample_files.png]

	Download sample source code files

[product_section_start:product_info_include_1]

[product_section_start:place_order]

[product_section_start:product_page_section_overview.png]

The Microchip TCN75 is an I2C Bus temperature sensor device.

[product_section_start:product_info_include_quick_driver_top_box]

[product_section_start:product_page_section_details.png]

The Microchip TCN75 is an I2C Bus temperature sensor device. It provides accurate temperture measurement at the PCB for embedded designs.

This driver provides the following functions:

READ TEMPERATURE
BYTE read_temperature (SIGNED_WORD *temperature)
Returns 1 if temperature was read sucessfully, 0 if not
temperature =
Temperature reading x0.5ºC (0×0000 = 0ºC)

Please view the sample source code files for full information regarding the driver.

[product_section_start:product_page_section_compilers.png]

		This source code product is written in C and has been designed to be used with any ANSI compliant C compiler on any platform. Direct compatibility has been tested with the compilers and processors / microcontrollers listed below. Using the driver with other ANSI compliant C compilers and devices should not present significant problems.

		Tested with the Microchip C30 MPLAB C Compiler for PIC24 family of 16 bit microcontrollers and dsPIC digital signal controllers. Free version of the compiler available from Microchip.

[product_section_start:product_page_section_sample_files.png]

	Download sample source code files (V1.00) (See the source code files for the revision history)

[product_section_start:product_info_include_quick_driver]

[product_section_start:place_order]

[product_section_start:product_page_section_overview.png]

The Dallas Maxim DS1307 is a I2C serial bus flash real time clock.

[product_section_start:product_info_include_quick_driver_top_box]

[product_section_start:product_page_section_details.png]

The Dallas Maxim DS1307 is a I2C serial bus flash real time clock.. It provides low power time keeping for embedded designs.

This driver provides the following functions:

SET REAL TIME CLOCK TIME
BYTE rtc_set_time (BYTE *seconds, BYTE *minutes, BYTE *hours, BYTE *day, BYTE *date, BYTE *month, BYTE *year)
The fields are converted from binary to BCD before being sent to the RTC
All fields are 0 – #, except day, date and month, which are 1 – #
Pointers are used for comanilty with rtc_get_time
Uses 24 hour clock mode

GET REAL TIME CLOCK TIME
BYTE rtc_get_time (BYTE *seconds, BYTE *minutes, BYTE *hours, BYTE *day, BYTE *date, BYTE *month, BYTE *year)
Returns
1 if sucessful, 0 if not.
All fields are converted to binary values.
All fields are 0 – #, except day, date and month, which are 1 – #
Uses 24 hour clock mode

Please view the sample source code files for full information regarding the driver.

[product_section_start:product_page_section_compilers.png]

		This source code product is written in C and has been designed to be used with any ANSI compliant C compiler on any platform. Direct compatibility has been tested with the compilers and processors / microcontrollers listed below. Using the driver with other ANSI compliant C compilers and devices should not present significant problems.

		Tested with the Microchip C18 MPLAB C Compiler for PIC18 family of 8 bit microcontrollers. Free version of the compiler available from Microchip.

[product_section_start:product_page_section_sample_files.png]

	Download sample source code files (V1.00) (See the source code files for the revision history)

[product_section_start:product_info_include_quick_driver]

[product_section_start:place_order]

[product_section_start:product_page_section_overview.png]

ADVANCE INFORMATION – THIS PROJECT IS NOT YET RELEASED (ORDERING NOT YET AVAILABLE)

This driver provides a complete bootloader solution for the Microchip PIC24 family of microcontrollers.

[product_section_start:product_info_include_quick_driver_top_box]

[product_section_start:product_page_section_details.png]

Designing a sophisticated bootloader tends to be a complex task that is often painful to debug. This driver provides a ready made bootloader system for the for the Microchip PIC24 family of microcontrollers. It provides everything you need to allow your device to be upgraded in the field via a flash firmware upgrade file.

This driver provides the following features:

The driver is based around a seperate bootloader and flash firmware project. The bootloader occupies a small section of memory at the start of the PIC program memory space. The flash firmware occupies the remainder of the program memory space. External memory is used to temporary store the upgrade file with your project providing the means to read and write that memory.

To upgrade the firmware your project simply deals with receiving the upgrade file over whatever communication interface your project has (e.g. Ethernet, USB, RS485, RS232, CAN etc) and passing it byte by byte to the driver. Once all of the firmware file has been received the driver verifies the new firmware file is valid and if it is a marker is stored for the bootloader. The PIC is then restarted and the bootloader deals with overwriting the flash firmware with the new file, verifying its integrity before running exiting to allow the the new firmware version to run

Firmware upgrades may also be provided using a removable memory device such as a memory card, USB dongle etc. Your application deals with providing the means to read the file from the card and the driver takes care of the rest.

Included PC application to convert the compilers .hex file into binary file ready for uploading / passing to driver.

The driver deals with ensuring the PIC24 interrupt vector tables are updated for new flash firmware versions.

16 bit checksum used to verify integrity of the firmware upgrade at every stage.

Allows you to encrypt your firmware upgrade file if desired.

Designed with failure in mind – should the upgrade process fail at any stage due to the PIC loosing power, corrupt communication of the file, etc, operation is not comprimised (the current firmware will continue to function or the upgrade process will complete when power is next returned).

The driver will deal with external memory typtes that require block erase and block write access (e.g. cheaper flash memory devices).

Please view the sample source code files for full information regarding the driver.

[product_section_start:product_page_section_compilers.png]

		Tested with the Microchip C30 MPLAB C Compiler for PIC24 family of 16 bit microcontrollers. Free version of the compiler available from Microchip.

[product_section_start:product_page_section_sample_files.png]

	Download sample source code files (V1.00) (See the source code files for the revision history)

[product_section_start:product_info_include_quick_driver]

[product_section_start:place_order]

[product_section_start:product_page_section_overview.png]
The Atmel AT45DB041D is a 4-megabit SPI serial bus flash memory device.

[product_section_start:product_info_include_quick_driver_top_box]

[product_section_start:product_page_section_details.png]

The Atmel AT45DB041 flash memory IC is a SPI bus device. It provides very low cost bulk memory to embedded designs.

Memory organisation:
0×00000 – 0x7FFFF
524288 bytes x 8 (512KB)
Organised as 2,048 pages of 256 bytes (To avoid non binary complexities this driver only uses 256 bytes of each page instead of the 264 which are actually available)

This driver provides the following functions:

TEST FLASH MEMORY
BYTE flash_test_memory (void)
An example of how to use this drivers functions.
Also a useful function if you want to verify the flash memory driver is working properly.
Returns 1 if test passed, 0 if not.

IS FLASH IC PRESENT
BYTE flash_check_present (void)
Useful to check flash chip is there and working

ERASE FLASH MEMORY
void flash_erase_all (void)

WRITE PAGE
void flash_write_page (DWORD address, BYTE *buffer, BYTE erase_first)
Call with:
address Binary byte address (must be the 1st byte of a page)
buffer Array of 256 bytes of data to be written
erase_first 1 = erase buffer first, 0 = don’t erase (if you’ve previously called flash_erase_all)

READ PAGE
void flash_read_page (DWORD address, BYTE *buffer)
Call with:
address Binary byte address (must be the 1st byte of a page)
buffer Array of 256 bytes of data to store read bytes in

READ STATUS
BYTE flash_read_status (void)
Returns status byte (bit 7 low = device is busy)

Please view the sample source code files for full information regarding the driver.

[product_section_start:product_page_section_compilers.png]

		This source code product is written in C and has been designed to be used with any ANSI compliant C compiler on any platform. Direct compatibility has been tested with the compilers and processors / microcontrollers listed below. Using the driver with other ANSI compliant C compilers and devices should not present significant problems.

		Tested with the Microchip C18 MPLAB C Compiler for PIC18 family of 8 bit microcontrollers. Free version of the compiler available from Microchip.

		Tested with the Microchip C30 MPLAB C Compiler for PIC24 family of 16 bit microcontrollers and dsPIC digital signal controllers. Free version of the compiler available from Microchip.

[product_section_start:product_page_section_sample_files.png]

	Download sample source code files (V1.00) (See the source code files for the revision history)

[product_section_start:product_info_include_quick_driver]

[product_section_start:place_order]

[product_section_start:product_page_section_overview.png]

MMC (MultiMediaCard) and SD (Secure Digital) memory cards provide a very convenient and inexpensive means of storing large quantities of data on a removable card. However providing a FAT16 / FAT 32 driver for a MMC or SD card, so that the files on the card may also be written and read by a PC is a daunting and complex task.

This MMC / SD card driver provides standard C library fopen() etc functions for FAT16 and FAT32 formatted cards, allowing you to add a MMC / SD card interface to your project with ease.

[product_section_start:product_page_section_details.png]

The driver provides the following main features:-

• Designed for both FAT16 and FAT32 formatted SD, SDHC (high capacity), MMC and MMCplus (high capacity) cards.
• Uses the licence free SPI bus interface for both MMC and SD cards allowing either type to be used with the same driver (the more complex 4 bit interface requires licence payments). Also fully compatible with the miniaturised versions of MMC and SD cards for space critical applications.
• Optimised for embedded designs. Only a single 512 data buffer is required for all operations. (It is not possible to write to MMC or SD cards without a 512 byte buffer as sectors have to be read to local memory, modified and written back as a whole).
• Intelligent use of the local ram sector buffer. Read and writes of sector data only occur when necessary, avoiding unnecessary and slow repeated read or write operations to the card.
• Optimised file delete function for fast deleting of large files. Instead of altering each FAT table entry one at a time, a complete sector of FAT table entries are altered in one operation before writing back to the card, resulting in a large speed improvement.
• Provides the following standard ANSI-C functions:- fopen, fseek, ftell, fgetpos, fsetpos, ffs_rewind, fputc, putc, fgetc, getc, fputs, fgets, fwrite, fread, fflush, fclose, remove, rename, clearer, feof and ferror
• Standard DOS ‘*’ and ‘?’ wildcard characters may be used in file operations.
• Multiple files may be opened, accessed and written at the same time.
• Optional real time clock support for applications that include time keeping. File creation, last modified and last accessed time and date values are automatically stored.
• Detailed project technical manual with a wealth of information on the FAT filing system and the structure of a FAT disk / memory card.
• No reliance on compiler specific libraries.
• Full source code supplied for you to use and modify as required.

Don’t think you need FAT32?

You may think that you don’t need anything more than FAT16 for your application if you don’t plan to store more than 2GB of data on a MMC or SD card. After all, many embedded applications only need to store relatively small amounts of data. However MMC and SD cards with capacities greater than 256MB are typically supplied pre-formatted with FAT32. Also Windows will typically format a MMC or SD card with a capacity greater than 32MB as FAT32 by default. This is because FAT32 uses larger volumes more efficiently than FAT16 and is also less susceptible to a single point of failure due to the use of a backup copy of critical data structures in the boot record. Therefore if you use a driver that only supports FAT16 for your application your users will need to find a PC with a MMC or SD card adaptor to re-format larger capacity cards to be FAT16 before they can be used with your device. You also run the risk of increased technical support demands from users who haven’t read your instructions or don’t understand how to format a card as FAT16 instead of the default FAT32 and can’t work out why their new MMC or SD card won’t work in your device. Using a driver that supports FAT16 and FAT32 doesn’t result in a large amount of additional code space by today’s standards, as the two systems are very similar, and it makes life a lot easier for you and your users.

[product_section_start:product_page_section_specifications.png]

Hardware Specifications

The driver is designed to support the licence free SPI bus MMC / SD memory card interface.

For full specifications please see the project technical manual.

[product_section_start:product_page_section_compilers.png]

		This source code product is written in C and has been designed to be used with any ANSI compliant C compiler on any platform. Direct compatibility has been tested with the compilers and processors / microcontrollers listed below. Using the driver with other ANSI compliant C compilers and devices should not present significant problems.

		Tested with the Rowley Associates CrossWorks for ARM C Compiler, with sample project for the NXP LPC23xx family of 32 bit ARM microcontrollers included.

		Tested with the Microchip C18 MPLAB C Compiler for PIC18 family of 8 bit microcontrollers with sample project included. Free version of the compiler available from Microchip.

		Tested with the Microchip C30 MPLAB C Compiler for PIC24 family of 16 bit microcontrollers and dsPIC digital signal controllers with sample project included. Free version of the compiler available from Microchip.

[product_section_start:product_page_section_documentation.png]

	View the project technical manual
	View the most recent project revision history (useful for past customers to check for any modifications since they received their files)
	Please also read our application note regarding SPI data bus signal noise.

[product_section_start:product_page_section_sample_files.png]

	Download sample source code files

[product_section_start:product_page_section_alternatives.png]

A version of this driver designed for CompactFlash memory cards is also available – click here.

[product_section_start:product_info_include_1]

[product_section_start:place_order]

[product_section_start:product_page_section_overview.png]

CompactFlash memory cards provide a very convenient and inexpensive means of storing large quantities of data on a removable card. However providing a FAT16 / FAT 32 driver for a CompactFlash card, so that the files on the card may also be written and read by a PC is a daunting and complex task.

This CompactFlash card driver provides standard C library fopen() etc functions for FAT16 and FAT32 formatted CompactFlash cards, allowing you to add a CompactFlash card interface to your project with ease.

[product_section_start:product_page_section_details.png]

The driver provides the following main features:-

• Designed for both FAT16 and FAT32 formatted CompactFlash cards.
• Optimised for embedded designs. Only a single 512 data buffer is required for all operations. (It is not possible to write to CompactFlash cards without a 512 byte buffer as sectors have to be read to local memory, modified and written back as a whole).
• Intelligent use of the local ram sector buffer. Read and writes of sector data only occur when necessary, avoiding unnecessary and slow repeated read or write operations to the CompactFlash card.
• Optimised file delete function for fast deleting of large files. Instead of altering each FAT table entry one at a time, a complete sector of FAT table entries are altered in one operation before writing back to the card, resulting in a large speed improvement.
• Provides the following standard ANSI-C functions:- fopen, fseek, ftell, fgetpos, fsetpos, ffs_rewind, fputc, putc, fgetc, getc, fputs, fgets, fwrite, fread, fflush, fclose, remove, rename, clearer, feof and ferror
• Standard DOS ‘*’ and ‘?’ wildcard characters may be used in file operations.
• Multiple files may be opened and accessed at the same time.
• Detailed project technical manual with a wealth of information on the FAT filing system and the structure of a FAT disk / memory card.
• No reliance on compiler specific libraries.
• Full source code supplied for you to use and modify as required.

Don’t think you need FAT32?
You may think that you don’t need anything more than FAT16 for your application if you don’t plan to store more than 2GB of data on a CompactFlash card. After all, many embedded applications only need to store relatively small amounts of data. However CompactFlash cards with capacities greater than 256MB are typically supplied pre-formatted with FAT32. Also Windows will typically format a CompactFlash card with a capacity greater than 32MB as FAT32 by default. This is because FAT32 uses larger volumes more efficiently than FAT16 and is also less susceptible to a single point of failure due to the use of a backup copy of critical data structures in the boot record. Therefore if you use a driver that only supports FAT16 for your application your users will need to find a PC with a CompactFlash adaptor to re-format larger capacity cards to be FAT16 before they can be used with your device. You also run the risk of increased technical support demands from users who haven’t read your instructions or don’t understand how to format a card as FAT16 instead of the default FAT32 and can’t work out why their new CompactFlash card won’t work in your device. Using a driver that supports FAT16 and FAT32 doesn’t result in a large amount of additional code space by today’s standards, as the two systems are very similar, and it makes life a lot easier for you and your users.

[product_section_start:product_page_section_specifications.png]

Hardware Specifications
The driver is designed to support 8 bit CompactFlash card interfaces.
For full specifications please see the project technical manual.

[product_section_start:product_page_section_compilers.png]

		This source code product is written in C and has been designed to be used with any ANSI compliant C compiler on any platform. Direct compatibility has been tested with the compilers and processors / microcontrollers listed below. Using the driver with other ANSI compliant C compilers and devices should not present significant problems.

		Tested with the Microchip C18 MPLAB C Compiler for PIC18 family of 8 bit microcontrollers with sample project included. Free version of the compiler available from Microchip.

[product_section_start:product_page_section_documentation.png]

	View the project technical manual
	View the most recent project revision history (useful for past customers to check for any modifications since they received their files)

[product_section_start:product_page_section_sample_files.png]

	Download sample source code files

[product_section_start:product_page_section_alternatives.png]

A version of this driver designed for MMC (MultiMediaCard) and SD (Secure Digital) memory cards is also available – click here.

[product_section_start:product_info_include_1]

[product_section_start:place_order]

[product_section_start:product_page_section_overview.png]

Graphic screens look impressive and allow you to display images that a simple character based screen can’t provide. However this improvement comes at the cost of a great deal of complexity. This screen driver removes much of that complexity for you and allows you to simply display bitmaps of any size and ASCII text strings using user adjustable fonts anywhere on a screen. Once you have this capability using a graphic screen is easy and it’s a simple matter to add any special features you need for your application, such as menus, animated graphics, graphs and more.

[product_section_start:product_page_section_details.png]

This driver provides complete bitmap and string display capabilities on any standard mono graphic display, such as LCD, E Ink, LED, OLED and Vacuum Fluorescent monochrome screens. Once configured, the driver removes you from all of the problems of byte updating of displays. There is no requirement to use bitmaps sized in 8 bit multiples or located at 8 bit positions on the screen – display any bitmap of any size wherever you want. The driver can use the screen / display driver IC memory buffer for the display data rather than processor memory, resulting in a small RAM memory requirement for the driver, or a microcontroller / processor ram buffer for faster output or for when using screens that don’t proide the means to read back display data.

The included PC bitmap converter application will read all of your source .bmp bitmap files, created in a standard graphics package, and convert them into the selected format ready for use in your application. It will also convert special font .bmp bitmap files you can create to be used to display ASCII text strings. Options allow you to rotate your bitmap images and fonts before converting, allowing you to use a screen in any of the 4 possible orientations.

As well as displaying ASCII text strings in standard ‘monospace’ fixed pitch mode (each character takes the same horizontal space regardless of its actual width), this driver also allows you to display text in proportional mode. This makes lines of text much more attractive and natural to read and typically allows you to fit additional characters across a screen, as each character only uses as much width as is required to display it. Left, centre or right alignment and scrolling functions provides the complete toolbox of text display capabilities.

Once you have all these capabilities using a graphic screen is easy and it’s a simple matter to add any special user interface features you require for your application, such as menus, animated graphics, graphs and more. One of the great advantages of this driver is that it provides you with very simple but very powerful control over everything you display on the screen, allowing you to implement your display, and any user interface, exactly as you want it down to the individual pixel.

This driver can’t quite remove all of the complexity for you as you will still need to configure the screen access functions to suit the particular screen you’re using. This has been made as simple as possible, and some sample screen models are included for you to copy and modify as required. See the technical manual for more details.

Main features:

• Display bitmaps of any size anywhere on the screen without having to worry about 8 bit size multiples or 8 bit boundaries.

• Use your display in any of the 4 possible orientations.

• Display monospace or proportional width text anywhere on the screen.

• Left, centre or right text alignment and scrolling options.

• Use the included PC Bitmap Converter Application to convert your source bitmap (.bmp) files ready for use with the driver. Create your bitmaps using a standard graphics application.

• Create your own fonts simply by creating a line of characters in a single bitmap file.

• Output your bitmap source files as a C compliant header file or as a binary file using the Bitmap Converter Application. Use the header file to include all of your bitmaps as part of the program memory – convert the files and they are immediately ready to use. Use the binary file option to store your bitmaps as a single data block in external flash memory and provide the driver with a function to read the binary data byte by byte. Use both methods if desired to split storage between on chip and external.

• No requirements to use your display in pre-defined ways – use your display exactly as you want with your user interface implemented exactly as you want it, down to the individual pixel.

• Use display memory instead of microcontroller / processor memory to buffer the display data, resulting in a very low ram requirement. Alternatively use a local ram buffer for displays with no read capability or to improve speed.

• Very fast optimised code but with a small program memory requirement.

• No reliance on compiler specific libraries.

• Full source code supplied for you to use and modify as required.

[product_section_start:product_page_section_specifications.png]

Hardware Specifications
The driver is designed to support 8 bit parallel or serial screen interfaces.
For full specifications please see the project technical manual.

[product_section_start:product_page_section_compilers.png]

		This source code product is written in C and has been designed to be used with any ANSI compliant C compiler on any platform. Direct compatibility has been tested with the compilers and processors / microcontrollers listed below. Using the driver with other ANSI compliant C compilers and devices should not present significant problems.

		Tested with the Microchip C18 MPLAB C Compiler for PIC18 family of 8 bit microcontrollers with sample project included. Free version of the compiler available from Microchip.

		Tested with the Microchip C30 MPLAB C Compiler for PIC24 family of 16 bit microcontrollers and dsPIC digital signal controllers with sample project included. Free version of the compiler available from Microchip.

		Tested with the Microchip C32 MPLAB C Compiler for PIC32 family of 32bit microcontrollers with sample project included. Free version of the compiler available from Microchip.

[product_section_start:product_page_section_documentation.png]

	View the project technical manual
	View the most recent project revision history (useful for past customers to check for any modifications since they received their files)

[product_section_start:product_page_section_sample_files.png]

	Download sample source code files

[product_section_start:product_info_include_1]

[product_section_start:place_order]

[product_section_start:product_page_section_overview.png]

Most LCD Character displays are designed to be HD44780 compatible. This generic driver provides control of many different variants of these screens and operates in 4 bit mode to reduce the pins required from the microcontroller.

[product_section_start:product_info_include_quick_driver_top_box]

[product_section_start:product_page_section_details.png]

This driver provides the following features:

• Compatible with most standard 1, 2 or 4 line displays with up to 40 characters
• Reads the busy flag back from the LCD screen so that the display may be updated as quickly as possible
• Functions in the background checking for being able to write the next character every time its main function is called, to avoid code execution stall when using slow displays.
• Supports left, middle and right aligned text.
• Display from constant program memory or variable ram memory.
• Only store as many characters as required in program memory – Null character determines end of lines text an avoids wasted program memory space.
• A simple driver that just drops in to your project and makes your life easier

This driver provides the following functions:

INITIALISE LCD
void lcd_initialise (void)
Call on power-up

UPDATE LCD DISPLAY
void lcd_update_display (void)
Call as part of your main loop. This function outputs characters to the display and exits if the display is currently busy to avoid application stall with slow displays.

WRITE LINE OF LCD DISPLAY (Versions for constant and variable strings)
void lcd_display_const_string (BYTE line_number, BYTE alignment, CONSTANT BYTE *text_line)
void lcd_display_variable_string (BYTE line_number, BYTE alignment, BYTE *text_line)
Call these functions to display a line of text
line_number 0 = top line
alignment LCD_ALIGN_LEFT, LCD_ALIGN_CENTER or, LCD_ALIGN_RIGHT
text_line Null terminated string

IS SCREEN BUSY
BYTE lcd_is_screen_busy (void)
Returns 1 if screen is still busy from last operation, 0 if not

SEND HIGH AND LOW NIBBLES OF W TO LCD DATA REG
void lcd_write_data_byte (BYTE data)

SEND HIGH AND LOW NIBBLES TO LCD CTRL REG
void lcd_write_control_byte (BYTE data)

SEND HI NIBBLE OF W TO LCD CTRL REG
void lcd_write_ctrl_hi_nibble (BYTE data)

SEND LO NIBBLE OF W TO LCD CTRL REG
void lcd_write_ctrl_lo_nibble (BYTE data)

Please view the sample source code files for full information regarding the driver.

[product_section_start:product_page_section_compilers.png]

		This source code product is written in C and has been designed to be used with any ANSI compliant C compiler on any platform. Direct compatibility has been tested with the compilers and processors / microcontrollers listed below. Using the driver with other ANSI compliant C compilers and devices should not present significant problems.

		Tested with the Microchip C18 MPLAB C Compiler for PIC18 family of 8 bit microcontrollers. Free version of the compiler available from Microchip.

[product_section_start:product_page_section_sample_files.png]

	Download sample source code files (V1.00) (See the source code files for the revision history)

[product_section_start:product_info_include_quick_driver]

[product_section_start:place_order]

[product_section_start:product_page_section_overview.png]

Ethernet is the perfect solution to providing connectivity for all sorts of embedded devices. Not only does the incredibly versatile range of TCP/IP stack functions lend themselves to all sorts of communication applications, the internet and web browsers allow easy communications across the world and with anyone’s computer or smart phone, effectively for free. The barriers to use once caused by expensive embedded device program memory are now all but gone with today’s low end microcontrollers typically providing plenty of memory for a TCP/IP stack.

The simplicity of the design of each individual part of a typical TCP/IP stack has allowed it to become the universal standard it is today. However whilst simple in concept the implementation of a complete set of TCP/IP stack components is a large and complex task by any programmers standards. This driver removes you from all of that complexity and allows you to add an Ethernet interface to your project with ease. Each of the stack components is configurable to allow you to easily tailor the overall stack depending on each of your projects requirements.

[product_section_start:product_page_section_details.png]

This TCP/IP stack is designed from the ground up to be lean, yet extremely fast and powerful.  The aim of the driver is for it to be the perfect choice for applications ranging from small 8 bit low speed embedded devices needing TCP/IP functionality, to fast 16 and 32 bit devices that need to provide high throughput and performance without requiring huge resources.  Whilst these aims may seem to contradict each other, accomplishing this is actually relatively straightforward with the right decisions made about the architecture of the stack.  With a typical TCP/IP stack being comprised of a large number of lines of code it can be very daunting for anyone other than the original programmers to navigate and understanding it, let alone tailor it to their own needs with any sense of confidence.  However the other main aim of this stack is for it to be easy for programmers to understand and customise if need be and it has been implemented with huge importance placed on the source code remaining simple, straightforward and easy to understand.

The driver provides the following main features:

• Optimised for small memory embedded designs. Processor ram usage is kept to a minimum and the Ethernet Controller IC memory is released as soon as packets are transmitted, allowing for high throughput applications.

• Intelligent TCP handling to provide automatic re-transmission in the event of lost packets, but without using any large data buffers. If a packet gets lost it is automatically re-sent with the lost packet data simply re-generated.

• Powerful web server with built in dynamic data handling, allowing your application to automatically add additional information to each web page as it is transmitted. Design your web pages using your favourite web design package and then use the included PC application to automatically convert the entire web site, including its images, scripts, etc, into either:
  

  A single C compliant .h header file which you simply add to your project files and the entire web site is then automatically stored in the program memory of your device when you next compile. No additional work is required by you – the driver automatically deals with serving the web pages and content on demand.

  A single binary data file ready to store in a flash memory IC, with a header file to add to your project allowing the HTTP server to automatically deal with serving the entire web site as you designed it. You just provide the method to store the single binary data block to your flash memory and to read the binary data from it on request by the HTTP server driver.

• Receive input from a web browser using GET and POST methods. GET provides simple form or hyperlink inputs to be received. POST provides more advanced form entry and file upload. The driver incorporates full handling of uploaded files allowing users to upload configuration files, new firmware, new web site content, etc. The driver simply passes the received and decoded file data to your function ready for you to store or process as you wish.

• As the majority of internet connected networks will allow outbound communications but will block inbound connections this driver also provides the functionality to allow your embedded device to connect to the internet itself, avoiding the need for a remote device or PC to have to make a connection to it. Having this functionality avoids special changes needing to be made by network administrators to permit inbound communications to your embedded device, which is often an issue in today’s security conscious world. POP3 email functionality allows your embedded device to connect to a POP3 mail server to check for incoming emails. SMTP and MIME email functionality allows your embedded device to send emails periodically or in response to events or emails received, with files attached if you wish. DNS functionality allows you to use URL’s rather than IP addresses, ensuring your device will continue to work should your mail server or remote server IP address be changed.

• NetBIOS functionality allowing you to connect to your device by name rather than IP address on local networks.

• No reliance on compiler specific libraries.

• Full source code supplied for you to use and modify as required.

The following protocols are included:

• UDP – Fast non-managed data transferClient and server functionality.Multiple connections may be open and active at the same time.

• TCP – Fast connection based managed data transfersClient and server functionality.Multiple connections may be open and active at the same time.

• HTTP – Web serverMultiple connections may be open and active at the same time.

• DHCP – Automatic network configuration clientAutomatic request of IP address, subnet and gateway address so your device can simply plug and play on a network.

• NetBIOS – Use names instead of IP address on local networksFind your device by a text based name rather than IP address on a local network.Can be very useful when using DHCP.

• DNS – Lookup of IP address from a URLAllowing your embedded device to use text URL’s to connect to remote devices, such as mail servers or your own remote servers.An important feature to protect against changes in a remote servers IP address effectively stopping your device from connecting to it.

• POP3 – Receive emailAutomatically check and download email from a standard POP3 mailbox.Get round strict network administrators in this security critical world. If your embedded device will be behind routers or firewalls use POP3 to allow your device to retrieve messages via the internet itself, avoiding the need to configure the routers or firewalls to allow an incoming connection.

• SMTP – Send emailAutomatically send anyone emails in response to events or at fixed intervals. Request an email to be returned to you using POP3

• MIME Base64 encoding – Attach files to emails being sentEasy attachment of files to outgoing emails. For instance you could attach .txt files containing configuration settings or.csv spreadsheet files with logging data for opening with Excel and other spreadsheet applications. Any file type may be attached.

• ICMP – Ping responseResponds to ping requests.

• ARP – Address resolution protocolA basic requirement for a TCP/IP device.

• SNTP Time Server ClientUse internet public time servers to obtain the current time.

(Please see the project technical manual for detailed information regarding the implementation each of these protocols)

[product_section_start:product_page_section_specifications.png]

Drivers for the following Network Interface Controller IC’s are included

• 10Base-T / 100Base-TX
  

  NXP LPC2000 series ARM microcontroller with built in Ethernet interface and external KSZ8001 PHY IC.

  SMSC LAN91C111 (8 or 16 bit hardware interface)

• 10Base-T
  

  Microchip ENC28J60 (SPI bus hardware interface)

  Realtek RTL8019AS (8 bit hardware interface)

Adding support for other network interface controller IC’s is straightfoward by modifying the dedicated nic file to provide basic IO access to chosen chipset.

[product_section_start:product_page_section_compilers.png]

		This source code product is written in C and has been designed to be used with any ANSI compliant C compiler on any platform. Direct compatibility has been tested with the compilers and processors / microcontrollers listed below. Using the driver with other ANSI compliant C compilers and devices should not present significant problems.

		Tested with the Rowley Associates CrossWorks for ARM C Compiler, with sample project for the NXP LPC23xx family of 32 bit ARM microcontrollers included.

		Tested with the Microchip C18 MPLAB C Compiler for PIC18 family of 8 bit microcontrollers with sample project included. Free version of the compiler available from Microchip.

		Tested with the Microchip C30 MPLAB C Compiler for PIC24 family of 16 bit microcontrollers and dsPIC digital signal controllers with sample project included. Free version of the compiler available from Microchip.

		Tested with the Microchip C32 MPLAB C Compiler for PIC32 family of 32bit microcontrollers with sample project included. Free version of the compiler available from Microchip.

[product_section_start:product_page_section_documentation.png]

	View the project technical manual
	View the most recent project revision history (useful for past customers to check for any modifications since they received their files)

[product_section_start:product_page_section_sample_files.png]

	Download sample source code files

[product_section_start:product_info_include_1]

[product_section_start:place_order]