TICkit Mini-Computers

Product Overview

The TICkit™ line of mini-computers are small programmable computing devices which are technically "micro-controllers", or more accurately "micro-interpreters". These small devices can execute relatively large and complex programs. They are optimized for I/O controlling, which means that they can control a wide variety of electrical interfaces from lights and switches to motors, printers, GPS devices, LCD screens and so on.. In addition to very capable I/O functions, it also has a great deal of data processing capability. The versions of the TICkit family are listed below.

TICkit 83 (28 pin) and TICkit 84 (40 pin) - 512K EEprom, 240 bytes RAM, 32 bit Floating point math, Multi-thread, User Assembly Language
TICkit 63 (28 pin) and TICkit 74 (40 pin) - 256K EEprom, 128 bytes RAM, 32 bit Floating point math
TICkit 62 (28 pin) - 64K EEprom, 96 byte RAM, 32 bit signed Integer math
TICkit 57 (28 pin ) - 64K EEprom, 48 bytes RAM, 32 bit signed Integer math

All TICkit devices support advanced programming concepts like structure, encapsulation, and interrupt processing. The latest in the TICkit line also supports Hybrid assembly language routines, internal token storage and even multi-threading. You can get a sense of how capable the FBasic programming language is by consulting the applications notes or the knowledge base for documents and examples highlighting FBasic.

These devices are programmed using software that runs on your PC. The software is called an Integrated Development Environment (IDE) and is available for free download. We ask that you register your software for a small fee if and when you use the TICkit or HUBbub for any commercial program design. This ensures it's continued advancement. The IDE can also be purchased as part of a more complete development system. More details on the IDE here.

Physically, TICkit micro-computers are RISC processor chips made by Microchip® called PIC processors. The PIC processors are relatively tiny micro-controllers designed for embedded applications. Protean implants special firmware called an interpreter which vastly expands the addressing capability and implements a large library of pre-written I/O routines. This combination yields a very small and inexpensive device that looks and acts very much like a small desk-top computer. (mini-computer, micro controller, micro-interpreter)

The TICkit interpreter has been implemented in four versions since its inception. These versions are identified by the numerical designation of the PIC processor they are implemented on. Protean Logic offers all versions and revisions of interpreter ICs as long as the native PIC chips are available. This ensures no designs will be orphaned within a reasonable life time. Protean Logic suggests that the latest TICkit version be used for new designs. This provides expanded capabilities and benefits for the end user.

We understand that some existing products require earlier versions continue to be available. Protean Logic maintains older versions to support customers having this need.

Every version of the TICkit can be purchased in several forms. These forms vary from the isolated TICkit processing IC to complete development systems with prototyping areas. The table below illustrates the various TICkit forms available.

TICkit 83/84

The TICkit 83/84 represents a major advancement in PIC based micro-interpreter technology. The TICkit 83 (28 pin) and 84 (40 pin version) have all the capabilities of the 63/74 with the following additional functionality:

External EEprom storage addressing capabilities to 512K in 8 I2C serial EEproms (24LC512). This space can be used for program storage, Data storage or audio playback storage.
Internal Token storage - Programs up to 7K can be stored inside the TICkit IC. Internal tokens fetch faster and provide greater security than code stored in external EEproms.
User interface for implementing Assembly language routines in the TICkit IC. This allows users to write special high speed routines for things like DRAM refresh or high speed peripheral interfaces.
More RAM memory variable and stack space. This is organized at 112 bytes for variables, 96 bytes for stack, and 32 bytes of scratch pad for convenient communications between assembly and FBasic routines.
Stack and Memory can be split for multi-threading capabilities. TICkit devices can actually run two programs at once!
Enhanced download protocols.
Ability to flash update the interpreter in circuit. This allows revisions of the interpreter to be placed into existing designs.
Enhanced audio playback functions.

T63H256K-IC

T74H256K-IC

TICkit 63/74

The TICkit 63 or 74 (40 pin version) has all the capabilities of the 62 with the following additional functionality:

EEprom Address Space increases to 256K from the 64K maximum of the 62.
32 bit Floating point math routines.
Pulse routines to control up to 4 RC style servos simultaneously.
Audio Playback from EEprom (8 bit)
Frequency output with up to 4 voices (4 different frequencies)
PCAT keyboard input routine to attach economical PC keyboards as a text input device.
RS232 reception and transmission in background
Second CCP output/input
TICkit 74 has 8bit A/D inputs
128 bytes of RAM for variables and stack space
Significant speed increases over that of the 62.
Background real-time clock.
Time base interrupts.
One-wire support for dallas semiconductor ICs

TICkit62 - Not Recommended for new designs

The TICkit 62 has all the capabilities of the 57 with the following additional functionality:

96 bytes of RAM.
SSP unit for 3 wire or 2 wire serial busses (I2C or SPI)
CCP unit for generating pulses or measuring pulses in background
Speed increases over that of the 57.
Better pin handling routines

T57X02E-IC

TICkit57 - Not Recommended for new designs

The TICkit 57 is the first TICkit. This device was introduced in 1996.

48 bytes of RAM
2K or 64K EEprom program and data space.
Pin input and output routines on 16 pins
RS232 in and out on any of 16 pins.
Pulse generation or measurement on any of 16 pins
Resistance-Capacitance measurement routine.
Timing routines
Interrupt input pin for hardware initiated sub-routine.
Complete symbolic debugging capability.
Programmed in a structured dialect of BASIC called FBasic.

TICkit and HUBbub Development Tools

All TICkit processors require the TICkit IDE software to be programmed. The IDE is a windows application which runs on any Windows 95,98, 2000, ME, XP computer with a serial port. Once the TICkit device is programmed the PC and the IDE software are no longer necessary. The IDE software has the following features:

Integrated multi-edit area program editor - This feature allows you to edit multiple files at one time.
FBasic Compiler - Converts your program into a token file which is downloaded into the TICkit. The compiler supports many advanced capabilities which make for better programs.
Structured flow control constructs.
Compile time - Include files for better organized code.
Assembly language support - For target TICkits (83/84) that allow user written assembly language functions.
Library support - For module re-usable code blocks.
Run-time debugging - For symbolically stepping through code and monitoring variables.
Complex EEprom data structures, Arrays, and Records - For extensive embedded data base applications.