Introduction:
        The microcontrolled biostimulator is designed to be a inexpensive alternative to more expensive commercial models. By replacing costly discrete IC timers with one microcontroller, a huge price savings can be acheived; a microcontrolled stimulator can cost as little as five dollars. Due to the price savings, a stimulator can easily be distributed in classrooms, labs, and field experiments. Note the microcontrolled biostimulator is not "cheap" alternative. Timing parameters and errors are similar or better than a normal discrete IC based designs.

Specifications:

	Maximum	Minimum	Comments
Input Voltage	20V	5V	Using Atmel development board
Output Voltage	5V		CMOS compatible
Time step	100us	100us	Firmware adjustable
Beats	255	0
Interval	65536 * Time step	0
Duration	65536 * Time step	0
Inital Delay	65536 * Time step	0
Interbeat Interval	65536 * Time step	0
Sync Pulse	Yes
Manual Pulse	Yes
Y2K?	Yes

Philosophy:
        The biostimulator is divided into two discrete parts. The first is the "Timer Core"; this segment controls all the timing for the stimulator. The timer core is part of every stimulator. The second part is the "Wrapper"; this segment provides  interface between the core and the user. As the timer core is a stand-alone component, the stimulator can adapt to a wide variety of situations.

Timer Core:

   The timer takes five different values:

• Interval: This is the time between one sync pulse and the next.
• Duration: This is the time that a pulse is 'high'.
• Sync Delay: This is the time elapsed from the sync pulse to the first rising edge.
• Interpulse Delay: This is the time between pulses.
• Pulses: This is the number of pulses within an interval.

Single/Multi: One interval of pulses delivered, or a continuous string of intervals

    Inputs and Outputs are as follows:
        PortB #3 is the pulse output.
        PortB #0 is the syncronization output.
        PortA #5 and #6 are Pulse/external inputs.

        The timer core is quite simple. TimerA controls the time base, the "tick" for the clock. Currently it is set to a 100us tick. When TimerA overflows, it provides a 'tick' to TimerB. As the microcontroller runs TimerB accumulates a value from these ticks.  While running, the controller polls TimerB to see if certain points in the specified pulse train, like the end of a duration, have been reached. When this happens, PortB#3 is turned on or off, depending on the previous status of the port. At the same time, the timer calculates the next milestone that TimerB needs to hit. When the new value is detected PortB#3 toggles again. This repeats as necessary. When the interval is over, everything resets and starts anew with a new sync pulse. The sync pulse and the pulse output can be syncronized when the 'Sync delay' is set to zero. Having a non-zero value shifts the pulse train so that it starts later than the sync pulse.

Wrapper:
        The "Wrapper" is simply a user interface for the biostimulator. Depending on the application, it can take many forms. Lab users may prefer the RS-232 support, while field and classroom use may enjoy a LCD/button type interface. The wrapper is also totally unnecessary; if long term embedded solutions are needed, the stimulator can be used as an OTP device.
        In its current iteration, however, the RS-232 support is implemented. Using a PC, new timing parameters can be inserted to the biostimulator. It must be noted that you need a serial program like "Hyperterminal" to communicate with the stimulator. To set up a serial link,  the computer needs to have the serial cable attached to COM1 and the serial port on the evaluation board. Then in hyperterminal, set the protocol to 9600-8-N-1.
        9600 refers to the baud rate, or speed, of the serial communications. The baud rate on the computer can be set to a higher setting, but the user must manually change this setting in the microcontroller code. Right now it is set to 9600, and it is fast enough for most purposes.
        The '8' refers to the the word size. All communications for the biostimulator will only use 8 bit words.
        For parity, set it to 'N' for none, set the stop bit to '1', and there is no flow control.
 
 
 

Here's how to use the RS232 implementation:

• Run Hyperterminal or some similar serial communication program
• Turn on the microcontroller. It is important that this is done AFTER the communication link is established. The microcontroller will automatically send a message on boot. If the serial port on the computer is not listening, then you need to press the reset button on the stimulator to resend the signal to the computer.
• Once the device has booted, you will see several choices:


Note that all times are entered in ***MICROseconds***.

N)um beats? 1
I)nterval? 100
D)uration? 50
S)ync Delay?0
P)ulse delay? 0
M)ulti press'2' single press'1')?
 

• To enter values for each field, press on the keyboard the letter to the left of the parenthesis. (eg: "I want to enter the number of beats".... press the 'n' key
• Once the key is pressed another prompt will appear:


N)um beats? _
 

• Here, type in the desired number and then press '='. This will enter in the number and lock it into memory. Repeat until all values are filled.
• When you are ready to start the timer, press 'g'. To stop the timer, press 'x'.
• When the timer is stopped, new values can be entered. Note that during longer intervals, it will take longer for the timer to stop, this is due to the timer core. It only checks for a stop condition at the end of one interval. This is to keep timing tight; therfore all beats inside the interval will be consistent from interval to interval.
• Note that the biostimulator comes with a default setting. If 'g' is pressed right after bootup, the biostimulator will run with the default, which is a 10ms, 50% duty cycle pulse, with no sync delay..

Guts:
    The wrapper is probably the largest part of the code. Approximately two-thirds of the code space is used for print statements, text string definitions, and parsing. Within the wrapper, there are two distinct routines. One is the wrapper itself and the other is the parser. The wrapper does all the "please display this string" calls and UART control. The parser's main function is to take ASCII input and translate them into binary, while storing copies of the ASCII string in RAM.

    The parser can be called the "guts" of the wrapper since it does all the vital work. As user input comes from the keyboard, the input is pushed onto a stack. This is great. However, the input is serial and it turns out that the most significant digit would appear as the least significant digit if popped normally from the stack. Now although this doesn't matter so much for the translation into binary since multiplication and additions are associative, it does make it slightly hairy when moving the digits into RAM. To alleviate the problem, we have two memory pointers working simultaneously. One is a RAM pointer to the value's RAM location for ASCII storage, and another is a copy of the stack pointer to find the right digit in the stack. The RAM pointer is post-incremented, and the "stack" pointer is preincremented. The RAM pointer is initally loaded with a fixed address, or "tag" for the value. The "stack" pointer is originally a copy of the stack pointer when the program initally jumps to the parser and has not begun to accept input. As input comes in, newer numbers are located in lower memory addresses,  since the stack starts at 0xFF and works its way to 0x00. Predecrementing the "stack pointer"  is to reflect this decrementing memory address. Essentially, the "stack" pointer reads the stack from the bottom up, instead of the top down....this preserves the natural order of the numbers as they are put in ASCII form into RAM. This also has the savings of not having to reparse the numbers from binary to ASCII to stick them into RAM. So in one pass, the values are read from the stack, inserted in the correct order into RAM, and translated into binary.

                Once all the numbers are parsed, the stack is flushed. This is to return the stack to its original state when it first entered the parse routine. This is important, or else the microcontroller will interpret one of the numbers that was entered to be a memory address to jump back to. To do this, a small 'pop' routine runs at the end of the parse routine. This loops only as many times as there are digits entered. Once all then numbers are popped off, then the program returns normally.

The source code.

    Timer Core:

• The timer currently has a fixed time resolution of 100us. This is certainly not the only time resolution avaliable; having a user adjustable time step would be nice. This can be implemented by changing the preload/reload to timer0. Instead of having the timer load immediate, the value could be treated as a user adjustible value and given a register. While this uses precious resources, loading from memory is not recommended since RAM/EEPROM reads are slow. However, there is a limit to adjustability. If a a time step that is too large is needed, timer0 will need to pull an interrupt to increment a register.

• The timer currently uses a polling loop to detect transitions. Another method is to use the CaputreA/B functions of the Atmel 4414. This is a slighly trickier way to implement the core. To implement this, captureA would clear timer1 on overflow, and captureB would toggle the captureB pin on a transition. This has the improvement of freeing up an output pin for other use. In addition, overall timing error would be reduced since a "polling" structure is not used; all timing errors would then be limited by the inherent hardware switching speed of the chip iteslf. This plan should be implemented if really precise timing is needed.

    Wrapper:

• A primary consideration for a wrapper was an LCD/button standalone design. When compared to the RS-232 design, the LCD type consumes much more code space. However it frees the user from the tether of a computer. The buttons will need to be set to become "progressively faster." This means that a small subroutine will be needed to adjust the timers during the information input phase.

• Note however, the multiply routine is not the standard ATMEL routine. The one posted on their website is incorrect and will not produce usable answers. The error is in the ordering of their code. In addtion, the multiply routine doesn't clean up after itself, so remember to add code to do so. In the future, the multiply routine should be fixed correclty with the full cleanup and ordering.

•  Labels for text are remarkably code intensive. Perhaps there is a way to make them shorter.