main()
{
/* Set both LED's initially ON. When update_outputs() is called, the
* human will see it this way.
*/
strcpy(led2,led_on_gif);
strcpy(led3,led_on_gif);
sock_init();
http_init();
tcp_reserveport(80);
/* Configure the I/O ports. Disable slave port which makes
* Port A an output, and PORT E not have SCS signal.
* Read shadow and set PE1 and PE7 as normal I/O.
* LED's are controlled by PE1 and PE7, so make them outputs.
*/
WrPortI(SPCR, NULL, 0x84);
WrPortI(PEFR, & PEFRShadow, ~((1<<7)|(1<<1)) & PEFRShadow);
WrPortI(PEDDR, & PEDDRShadow, (1<<7)|(1<<1));
while (1) {
update_outputs();
http_handler();
}
}
// C programs require a main() function
void main()
{
int j; // define an integer j to serve as a loop counter
int k; // define a counter k to test the watch expression with
// set lowest 2 bits of port D as outputs
WrPortI(PDDDR, &PDDDRShadow, 0x03);
// set all ports D outputs to not be open drain
WrPortI(PDDCR, &PDDCRShadow, 0x00);
k=0; // initialize k to zero
while(1) { // begin an endless loop
BitWrPortI(PDDR, &PDDRShadow, 0x00, 0); // turn led on output 1 off
for(j=0; j<25000; j++)
; // time delay loop
BitWrPortI(PDDR, &PDDRShadow, 0xFF, 0); // turn led on output 0 on
for(j=0; j<25000; j++)
; // time delay loop
k++; // increment k
// update watch expressions for Dynamic C to read
runwatch();
} // end while loop
} // end program
void blink_leds()
{
WrPortI(PGDR, &PGDRShadow, 0x80);
delayloop();
WrPortI(PGDR, &PGDRShadow, 0x40);
delayloop();
}
// C programs require a main() function. This one returns no value.
void main()
{
int j; // define an integer j to serve as a loop counter
int k; // define a counter k with which to test the watch expression
// Write 84 hex to slave port control register that initializes parallel
// port A as an output port (port A drives the LEDs on the Prototyping Board).
WrPortI(SPCR, &SPCRShadow, 0x84);
k=0; // initialize k to 0
// now write all ones to port A which sets outputs high and LEDs off
WrPortI(PADR, &PADRShadow, 0xff);
while(1) { // begin an endless loop
BitWrPortI(PADR, &PADRShadow, 1, 1); // turn LED DS3 off
for(j=0; j<32000; j++)
; // time delay loop
BitWrPortI(PADR, &PADRShadow, 0, 1); // turn LED DS3 on
for(j=0; j<1000; j++)
; // time delay loop
k++; // increment k
runwatch(); // update watch expressions for Dynamic C to read
} // end while loop
} // end program
void dprint_init_ports() {
//set PA0:PA7 as outputs, disable slave port
WrPortI(SPCR, & SPCRShadow, 0x84);
//set PE0 for output ()
WrPortI(PEDDR, & PEDDRShadow, 0x01 | PEDDRShadow);
WrPortI(PEFR, & PEFRShadow, 0x00);
//write zero to start with...
WrPortI(DATA_PORT, & DATA_PORT_SHADOW, 0x00);
WrPortI(DISPLAY_E, NULL, 0x00);
}
void main()
{
auto int done;
WrPortI(PGCR, &PGCRShadow, 0x00);
WrPortI(PGFR, &PGFRShadow, 0x00);
WrPortI(PGDCR, &PGDCRShadow, 0x00);
WrPortI(PGDDR, &PGDDRShadow, 0xC0);
done = FALSE;
while (!done) {
costate {
// full processor clock
useMainOsc();
waitfor(DelaySec(STEPDELAY));
// 1/2 processor clock
useClockDivider3000(CLKDIV_2);
waitfor(DelaySec(STEPDELAY));
// 1/4 processor clock
useClockDivider3000(CLKDIV_4);
waitfor(DelaySec(STEPDELAY));
// 1/6 processor clock
useClockDivider3000(CLKDIV_6);
waitfor(DelaySec(STEPDELAY));
// 1/8 processor clock
useClockDivider3000(CLKDIV_8);
waitfor(DelaySec(STEPDELAY));
// run processor clock off 32kHz oscillator
use32kHzOsc();
// waitfor() will not work when running off the
// 32kHz oscillator (the periodic interrupt is
// disabled). Instead we'll just call the
// LED-blinking code once, which should be enough
// (note that it will take one the order of
// half a minute to finish).
blink_leds();
// full processor clock
useMainOsc();
waitfor(DelaySec(STEPDELAY));
done = TRUE;
}
costate {
blink_leds();
}
}
}
// Setup timer c and parallel port D alternate outputs.
void timerc_setup()
{
unsigned int tc_div;
// The Timer C divisor affects how far apart the pulses are. This
// effectively controls the volume by changing the average voltage
// between a certain range. Too high and the pulses get very far apart
// and start to produce a high pitched noise. Too low and the pulses
// get too close together and the wav becomes inaudible.
tc_div = 0x0100;
// setup PE0 for alternate output TMRC[0]
WrPortI(PEDDR, &PEDDRShadow, PEDDRShadow | 0x01);
WrPortI(PEALR, &PEALRShadow, (PEALRShadow & 0xFC) | 0x02);
WrPortI(PEFR, &PEFRShadow, PEFRShadow | 0x01);
// setup timer c
WrPortI(TCS0HR, NULL, 0x00); // SET value MSB
WrPortI(TCS0LR, NULL, 0x00); // SET value LSB
WrPortI(TCR0HR, NULL, 0x00); // RESET value MSB (LSB set by DMA later)
// Timer C Divider
WrPortI(TCDLR, NULL, (char)tc_div);
WrPortI(TCDHR, NULL, (char)(tc_div >> 8));
// Timer C Control registers
WrPortI(TCCR, &TCCRShadow, 0x00); // interrupts disabled for timer c
WrPortI(TCCSR, &TCCSRShadow, 0x01); // enable main clock for timer c
}
pop hl
ipres
ret
#endasm
// Generate an interrupt by toggling PB3
void generate_interrupt()
{
WrPortI(PBDR, &PBDRShadow, PBDRShadow & ~0x08);
WrPortI(PBDR, &PBDRShadow, PBDRShadow | 0x08);
}
void main()
{
int vswitch; // state of virtual switch controlled by button S1
// set lowest 2 bits of port D as outputs, the rest as inputs
WrPortI(PDDDR, &PDDDRShadow, 0x03);
// set all port D outputs to not be open drain
WrPortI(PDDCR, &PDDCRShadow, 0x00);
vswitch=0; // initialize virtual switch as off
while (1) { // endless loop
// First task will flash LED #4 for 200ms once per second.
costate {
BitWrPortI(PDDR, &PDDRShadow, 0xFF, 1); // turn LED on
waitfor(DelayMs(200)); // wait 200 milliseconds
BitWrPortI(PDDR, &PDDRShadow, 0x00, 1); // turn LED off
waitfor(DelayMs(800)); // wait 800 milliseconds
}
// Second task will debounce switch #1 and toggle virtual switch vswitch.
// also check button 1 and toggle vswitch on or off
costate {
if (!BitRdPortI(PDDR, 2))
abort; // if button not down skip out of costatement
waitfor(DelayMs(50)); // wait 50 ms
if(!BitRdPortI(PDDR, 2))
abort; // if button not still down skip out
vswitch = !vswitch; // toggle virtual switch since button was down 50 ms
// now wait for the button to be up for at least 200 ms before considering another toggle
while (1) {
waitfor(!BitRdPortI(PDDR, 2)); // wait for button to go up
waitfor(DelayMs(200)); // wait additional 200 milliseconds
if (!BitRdPortI(PDDR, 2))
break; // if button still up break out of while loop
}
} // end of costate
// make LED agree with vswitch
BitWrPortI(PDDR, &PDDRShadow, vswitch, 0);
} // end of while loop
} // end of main
void main()
{
int vswitch; // state of virtual switch controlled by button S1
WrPortI(SPCR, &SPCRShadow, 0x84); // setup parallel port A as output
WrPortI(PADR, &PADRShadow, 0xff); // turn off all LED's
vswitch=0; // initialize virtual switch as off
while (1) { // endless loop
// First task will flash LED DS4 for 200ms once per second.
costate {
BitWrPortI(PADR, &PADRShadow, 0, 1); // turn LED on
waitfor(DelayMs(200)); // wait 200 milliseconds
BitWrPortI(PADR, &PADRShadow, 1, 1); // turn LED off
waitfor(DelayMs(800)); // wait 800 milliseconds
}
// Second task will debounce switch S1 and toggle virtual switch vswitch.
// also check button 1 and toggle vswitch on or off
costate {
if (BitRdPortI(PBDR, 2))
abort; // if button not down skip out of costatement
waitfor(DelayMs(50)); // wait 50 ms
if(BitRdPortI(PBDR,2))
abort; // if button not still down skip out
vswitch = !vswitch; // toggle virtual switch since button was down 50 ms
// now wait for the button to be up for at least 200 ms before considering another toggle
while (1) {
waitfor(BitRdPortI(PBDR, 2)); // wait for button to go up
waitfor(DelayMs(200)); // wait additional 200 milliseconds
if (BitRdPortI(PBDR,2))
break; // if button still up break out of while loop
}
} // end of costate
// make led agree with vswitch if vswitch has changed
if( (PADRShadow & 1) == vswitch)
BitWrPortI(PADR, &PADRShadow, !vswitch, 0);
} // end of while loop
} // end of main
//use low four
void dprint_write_nibble(char d,int instr){
int i;
char fixed_data;
//write the nibble
fixed_data = 0;
if(instr==1) fixed_data = d & 0x0F; //just the low four
else fixed_data = d & 0x4F;
WrPortI(DATA_PORT, & DATA_PORT_SHADOW, fixed_data);
//toggle E
WrPortI(DISPLAY_E, NULL, 0xFF);
delay_us(20);
WrPortI(DISPLAY_E, NULL, 0x00);
delay_us(200);
//printf(" wrote nibble 0x%02x (0x%02x)\n",d,fixed_data);
}
void main()
{
int i;
reg_write_t reg_write;
// Register user defined syscall.
_sys_register_usersyscall(systemmode_test);
// Set PB3 to output
WrPortI(PBDDR, &PBDDRShadow, PBDDRShadow | 0x08);
// Set PE4 to input
WrPortI(PEDDR, &PEDDRShadow, PEDDRShadow & ~0x10);
// Set interrupt handler for external INT0
SetVectExtern3000(0, ext_int0_isr);
// Enable external INT0 on PE4, rising edge, priority 1
WrPortI(I0CR, &I0CRShadow, 0x21);
while(1)
{
// Call user syscall to enable use of parallel port B through its user
// enable register, generate interrupts and show the number of interrupts
// handled.
_sys_usersyscall(ENABLE_PORT_B, NULL);
interrupt_count = 0;
for(i = 0; i < 2000; i++)
{
generate_interrupt();
}
printf("Port B enabled: %d\n", interrupt_count);
// Call user syscall to disable use of parallel port B through its user
// enable register and attempt to generate interrupts. Since the parallel
// port B user enable register is not set, no interrupts will be generated
// and the count will be zero at the end of this loop.
// Note that disabling of PBUER is handled differently than above. This
// is purely for demonstration purposes to show the use of the parameter
// that can be passed to the user defined syscall.
reg_write.port = PBUER;
reg_write.data = 0x00;
_sys_usersyscall(REGISTER_WRITE, (void*)®_write);
interrupt_count = 0;
for(i = 0; i < 2000; i++)
{
generate_interrupt();
}
printf("Port B disabled: %d\n", interrupt_count);
}
}
int main()
{
int count, err;
unsigned int dma_div, flags;
dma_chan_t handle;
// The dma divisor determines how fast the data sent to TCR0LR changes.
// The larger this number is, the slower the wav file will play.
dma_div = 0x0F00;
src = xmem_src + sizeof(long);
xmem2root((void *)&wav_size, xmem_src, 4);
timerc_setup();
// Set the DMA to use 50% of the CPU resources.
err = DMAsetParameters(0, 0, DMA_IDP_FIXED, 2, 50);
if(err){
printf("Error: DMAsetParameters.\n");
exit(err);
}
handle = DMAalloc(DMA_CHANNEL_ANY, 0);
if(handle == DMA_CHANNEL_NONE){
printf("Error: DMAalloc.\n");
exit(EINVAL);
}
printf("Playing wav file...\n");
for(count = 0; count < 5 && !kbhit(); count++){ // play the wav 5 times.
printf(" Count = %d.\n", count + 1);
// This function sets up the timer. To use the timer, the flag values
// must be set correctly as well.
DMAtimerSetup(dma_div);
// if the wav_size were larger than 32765 bytes, more than one transfer
// would be necessary.
flags = DMA_F_TIMER | DMA_F_TIMER_1BPR;
err = DMAmem2ioi(handle, TCR0LR, src, (int)wav_size, flags);
if(err){
printf("Error: DMAmem2ioi.\n");
exit(err);
}
while(!DMAcompleted(handle, NULL))
;
}
WrPortI(TCCSR, NULL, 0x00); // disable the main clock for timer c
err = DMAunalloc(handle);
if(err){
printf("Error: DMAunalloc.\n");
exit(err);
}
}
pinginled(int what)
{
if (what==LEDON)
ledstatus&=0x7F; //turn DS2 on
else
ledstatus|=0x80; //turn DS2 off
WrPortI(PDDR, NULL, ledstatus);
}
pingoutled(int what)
{
if (what==LEDON)
ledstatus&=0xBF; //turn DS1 on
else
ledstatus|=0x40; //turn DS1 off
WrPortI(PDDR, NULL, ledstatus);
}
/* Update all LED's to reflect string values. */
void update_outputs()
{
int value;
/* update DS2 */
value = (1<<1); /* PE1 */
if( !strcmp(led2,led_on_gif) ) {
value = 0;
}
WrPortI(PEB1R, NULL, value);
/* update DS3 */
value = (1<<7); /* PE7 */;
if( !strcmp(led3,led_on_gif) ) {
value = 0;
}
WrPortI(PEB7R,NULL,value);
} /* end update_outputs() */
void main() {
void brdInit(); // Enable development board
WrPortI(SPCR, NULL, 0x84); // Set Rabbit port A to output
WrPortI(PADR, &PADRShadow, 0x0); // Zero out all bits of port A
WrPortI(PBDDR, &PBDDRShadow, 0xFF); // Set port B to output
LcdWrite(0, 0x30);
MsDelay(4);
LcdWrite(0, 0x30);
LcdWrite(0, 0x30);
LcdWrite(0, 0x38); // Send cmd "8bit, 2 lines, 5x7 font"
LcdWrite(0, 0x06); // Send cmd "Entry mode, increment move"
LcdWrite(0, 0x10); // Send cmd "display and cursor shift"
LcdWrite(0, 0x0E); // Send cmd "display and cursor on"
LcdWrite(0, 0x01); // Send cmd "LCD clear, jump to zero
LcdWrite(1, 0x48); // Send data 'H'
LcdWrite(1, 0x69); // Send data 'i'
}
void LcdWrite(int mode, char hex) {
BitWrPortI(PBDR, &PBDRShadow, mode, RSADDR); // Choose command or data mode
BitWrPortI(PBDR, &PBDRShadow, 0, RWADDR); // Set LCD write mode
WrPortI(PADR, &PADRShadow, hex); // Set LCD command on port A
MsDelay(1);
BitWrPortI(PBDR, &PBDRShadow, 1, ENADDR); // Start sending data
MsDelay(1); // Wait 1 ms for LCD to receive
BitWrPortI(PBDR, &PBDRShadow, 0, ENADDR); // Finish transmission
MsDelay(1); // Wait 1 ms until next write
}
void LcdCommandWr(char hex) {
BitWrPortI(PBDR, &PBDRShadow, 0, RSADDR); // Set LCD command mode
BitWrPortI(PBDR, &PBDRShadow, 0, RWADDR); // Set LCD write mode
WrPortI(PADR, &PADRShadow, hex); // Set LCD command on port A
MsDelay(1);
BitWrPortI(PBDR, &PBDRShadow, 1, ENADDR); // Start sending data
MsDelay(1); // Wait 1 ms for LCD to read
BitWrPortI(PBDR, &PBDRShadow, 0, ENADDR); // Finish transmission
MsDelay(1); // Wait 1 ms until next write
}
// C programs require a main() function
void main()
{
int j; // define an integer j to serve as a loop counter
/* 1. Convert the I/O ports. Disable slave port which makes
* Port A an output, and PORT E not have SCS signal.
*/
WrPortI(SPCR, & SPCRShadow, 0x84);
/* 2. Read function shadow and set PE1 and PE7 as normal I/O.
* LED's are conencted to PE1 and PE7, make them outputs.
* Using shadow register preserves function of other Port E bits.
*/
WrPortI(PEFR, & PEFRShadow, ~((1<<7)|(1<<1)) & PEFRShadow);
WrPortI(PEDDR, & PEDDRShadow, (1<<7)|(1<<1));
/* 3. Turn on DS2 (0 -> PE1) and turn off DS3 (1 -> PE7).
*/
WrPortI(PEDR, & PEDRShadow, (1<<7));
while(1) { // begin an endless loop
WrPortI(PEB7R, NULL, 0xff); // turn LED DS3 off
for(j=0; j<32000; j++)
; // time delay loop
WrPortI(PEB7R, NULL, 0); // turn LED DS3 on
for(j=0; j<25000; j++)
; // time delay loop
} // end while loop
} // end program
void dprint_write_byte(char d,int instr){
int i;
char fixed_data;
//write the high 4
fixed_data = d >> 4;
if(instr==1) fixed_data = fixed_data;
else fixed_data = fixed_data | 0x40;
WrPortI(DATA_PORT, & DATA_PORT_SHADOW, fixed_data);
//toggle E
WrPortI(DISPLAY_E, NULL, 0xFF);
delay_us(20);
WrPortI(DISPLAY_E, NULL, 0x00);
delay_us(20);
//printf(" wrote byte 0x%02x (0x%02x",d,fixed_data);
//write the low 4
if(instr==1) fixed_data = d & 0x0F;
else fixed_data = d | 0x40;
WrPortI(DATA_PORT, & DATA_PORT_SHADOW, fixed_data);
//toggle E
WrPortI(DISPLAY_E, NULL, 0xFF);
delay_us(20);
WrPortI(DISPLAY_E, NULL, 0x00);
//for some reason it doesn't work if I take this out :-(
delay_us(200);
for(i=0;i<100;i++);
}
main()
{
// Initializations
auto char display[128];
auto char key;
brdInit();
count_TMRA5 = 0; // Initialize counters to zero
count_TMRA6 = 0; // Initialize counters to zero
count_TMRA7 = 0; // Initialize counters to zero
for (i = 0; i < 3; i++) // Initialize display counters to zero
display_count[i] = 0;
// Set up Timer A interrupts
SetVectIntern(0x0A, Tmr_A_isr); // Set up timer A interrupt vector
WrPortI(TAT7R, &TAT7RShadow, 0x3F); // Set TMRA7 to count down from 63
WrPortI(TAT6R, &TAT6RShadow, 0x7F); // Set TMRA6 to count down from 127
WrPortI(TAT5R, &TAT5RShadow, 0xFF); // Set TMRA5 to count down from 255
WrPortI(TAT1R, &TAT1RShadow, 0xFF); // Set TMRA1 to count down from 255
WrPortI(TACR, &TACRShadow, 0xE1); // Clock TMRA5,TMRA6,TMRA7 by TMRA1. Clock TMRA4 by PCLK/2. Set Timer A to trigger priority 1 interrupts
WrPortI(TACSR, &TACSRShadow, 0xE1); // Enable interrupts for TMRA5,TMRA6,TMRA7 only. Enable main clock for Timer A
DispStr(5, 10, "<-PRESS 'Q' TO QUIT->");
// This is the background process. It repeatedly updates the computer monitor with the values in the display_count array
while (1) {
for(i = 0; i < 3; i++) {
display[0] = '\0';
sprintf(display, "Number of TMRA%d interrupts: %d\ (x100)", i+5, display_count[i]);
DispStr(5, i+1, display);
}
if (kbhit()) { // Check if any key has been pressed
key = getchar();
if (key == 0x71 || key == 0x51) // Check if it's the key 'q' or 'Q'
exit(0);
}
}
}
/* START FUNCTION DESCRIPTION ********************************************
tmpnam <stdio.h>
SYNTAX: char *tmpnam( char *s)
DESCRIPTION: Generates a string that is a valid file name and that is not the
same as the name of an existing file.
The tmpnam function generates a different string each time it
is called, up to TMP_MAX times.
In the current implementation, uses the pattern A:TEMP####.TMP
to generate filenames.
PARAMETER 1: Buffer to hold the filename. Must be at least L_tmpnam
characters.
If NULL, tmpnam() will store the name in a static buffer.
Subsequent calls to tmpnam() may modify that buffer, making
it a less-robust method than passing in a buffer to use.
RETURN VALUE: Buffer containing filename (either the first parameter or
a static buffer if the first parameter is NULL).
END DESCRIPTION **********************************************************/
_stdio_fat_debug
char *tmpnam( char *s)
{
static char static_name[L_tmpnam];
static word lastnum = 0xFFFF;
int status;
fat_part *part;
char *fn;
fat_dirent dirent; // dummy entry used during check for file
// use a static var to keep track of last number used to generate file
// first time through, use lower bits of RTC to seed random generator
if (lastnum == 0xFFFF)
{
WrPortI( RTC0R, NULL, 0);
lastnum = RdPortI16( RTC0R) & 0x03FF; // lastnum 0 to 1023
}
if (s == NULL)
{
s = static_name;
}
// <s> will be "A:
TEMP####.TMP". <part> is the partition, <fn> is the
// filename (the "TEMP####.TMP" part of <s>).
part = fat_part_mounted[0];
strcpy( s, "A:");
fn = &s[2];
do {
// lastnum ranges from 0 to 9999
if (++lastnum > 9999)
{
lastnum = 0;
}
sprintf( fn, "
TEMP%04u.TMP", lastnum);
do {
status = fat_Status( part, fn, &dirent);
} while (status == -EBUSY);
#ifdef STDIO_FAT_VERBOSE
fprintf( stderr, "%s:
%s %s\n", __FUNCTION__, s,
status ? "is available" : "exists");
#endif
} while (status == 0);
return s;
}
///// write character to lcd
void lcdPutc (char cData)
{
WrPortI ( PADR,&PADRShadow,(cData&0xF0)|0x04|(PADRShadow&0x01) );
WrPortI ( PADR,&PADRShadow,PADRShadow|0x02 ); // Strobe Write
WrPortI ( PADR,&PADRShadow,PADRShadow&0xFD );
// Ready Lower Nibble
WrPortI ( PADR,&PADRShadow,((cData<<4)&0xF0)|0x04|(PADRShadow&0x01) );
WrPortI ( PADR,&PADRShadow,PADRShadow|0x02 ); // Strobe Write
WrPortI ( PADR,&PADRShadow,PADRShadow&0xFD );
WrPortI ( PADR,&PADRShadow,(PADRShadow&0x01) ); // Restore Contrast
delay ( 4 ); // Wait 40 uSec
}
void main()
{
count0 = 0;
count1 = 0;
WrPortI(PEDDR, &PEDDRShadow, 0x00); // set port E as all inputs
#if __SEPARATE_INST_DATA__ && (_RK_FIXED_VECTORS)
interrupt_vector ext0_intvec my_isr0;
interrupt_vector ext1_intvec my_isr1;
#else
SetVectExtern3000(0, my_isr0);
SetVectExtern3000(1, my_isr1);
// re-setup ISR's to show example of retrieving ISR address using GetVectExtern3000
SetVectExtern3000(0, GetVectExtern3000(0));
SetVectExtern3000(1, GetVectExtern3000(1));
#endif
WrPortI(I0CR, &I0CRShadow, 0x09); // enable external INT0 on PE0, rising edge, priority 1
WrPortI(I1CR, &I1CRShadow, 0x09); // enable external INT1 on PE1, rising edge, priority 1
while ((count0 < 20) && (count1 < 20)) {
// output the interrupt count every second
costate {
printf("counts = %3d %3d\n", count0, count1);
waitfor(DelaySec(1));
}
}
WrPortI(I0CR, &I0CRShadow, 0x00); // disable external interrupt 0
WrPortI(I1CR, &I1CRShadow, 0x00); // disable external interrupt 1
// final counts
printf("counts = %3d %3d\n", count0, count1);
}
void LcdPutChar(char displayChar) {
char * lcdChar;
lcdChar = AsciiCharLookup(displayChar);
if(lcdChar==NULL) return;
BitWrPortI(PBDR, &PBDRShadow, 1, RSADDR); // Set LCD data mode
BitWrPortI(PBDR, &PBDRShadow, 0, RWADDR); // Set LCD write mode
WrPortI(PADR, &PADRShadow, *lcdChar); // Set the display data on port A
MsDelay(1);
BitWrPortI(PBDR, &PBDRShadow, 1, ENADDR); // Start sending data
MsDelay(1); // Wait 1 ms for LCD to read
BitWrPortI(PBDR, &PBDRShadow, 0, ENADDR); // Finish transmission
MsDelay(1);
}
void main ( void )
{
///// initialize keypad
WrPortI ( PDFR,NULL,0x00 ); // parallel Port D All I/O
WrPortI ( PDDCR,NULL,0xC0 ); // PD7..PD6 Open Collector
WrPortI ( PDDDR,NULL,0xC0 ); // PD7..PD6 Output
///// initialize lcd
WrPortI ( PADR,&PADRShadow,0x00 ); // Assure Outputs are Low
WrPortI ( SPCR,&SPCRShadow,0x84 ); // parallel Port A = Outputs
WrPortI ( PADR,&PADRShadow,PADRShadow&0x01 ); // Set Contrast at GND
delay ( 1500 ); // Wait 15 mSec (LCD to Stabilize)
lcdCmd4 ( 0x30 ); // Set to 8-Bit Interface
delay ( 410 ); // Wait 4.1 mSec
lcdCmd4 ( 0x30 ); // Set 8-Bit Interface
delay ( 10 ); // Wait 100 uSec
lcdCmd4 ( 0x30 ); // Set 8-Bit Interface
lcdCmd4 ( 0x20 ); // Set 8-Bit Interface
lcdCmd ( 0x28 ); // Set Dual Line Display
lcdCmd ( 0x06 ); // Disable Display Shift
lcdCmd ( 0x0C ); // Display On, Cursor Off
lcdCmd ( 0x01 ); // Clear Screen, Home Cursor, Backlight On
delay ( 164 ); // Wait 1.64 mSec
for (;;) {
WrPortI ( PDDR,NULL,0x40 ); // Scan Row 0
lcdGoto ( 0,0 ); // Cursor on column 0, row 0
keyCol (); // Scan for keypress
WrPortI ( PDDR,NULL,0x80 ); // Scan Row 1
lcdGoto ( 0,1 ); // Cursor on column 0, row 1
keyCol (); // Scan for keypress
}
}
// Helper functions
void InitTimerInt()
{
auto UBYTE i;
count_TMRA5 = 0;
count_TMRA6 = 0;
count_TMRA7 = 0;
for (i = 0; i < N_TASKS; i++)
display_count[i] = 0;
// Setup internal interrupt and set up timer A
SetVectIntern(0x0A, Tmr_A_isr); // Set up timer A interrupt vector
WrPortI(TAT7R, &TAT7RShadow, 0x3F); // Set TMRA7 to count down from 63
WrPortI(TAT6R, &TAT6RShadow, 0x7F); // Set TMRA6 to count down from 127
WrPortI(TAT5R, &TAT5RShadow, 0xFF); // Set TMRA5 to count down from 255
WrPortI(TAT1R, &TAT1RShadow, 0xFF); // Set TMRA1 to count down from 255
WrPortI(TACR, &TACRShadow, 0xE1); // Clock TMRA5-7 by TMRA1 and set interrupt priority to 1
WrPortI(TACSR, &TACSRShadow, 0xE1); // Enable TMRA5-7 and main clock for Timer A
}
void main() {
void brdInit(); // Enable development board
SetPortAOut(); // Set port A as output port
WrPortI(PBDDR, &PBDDRShadow, 0xFF); // Set port B as output port
Lcd_Config();
pause(5);
LcdWriteStr(1,"Rabbit-RCM4010:");
pause(5);
LcdWriteStr(2,"[\"Hello World!\"]");
pause(10);
Lcd_Clear();
Lcd_noCursor_On();
LcdWriteStr(1,"LCD off in 5 sec");
LcdCommandWr(0xA8);
MsDelay(300); LcdPutChar('5');
MsDelay(300); LcdPutChar('.');
MsDelay(300); LcdPutChar('.');
MsDelay(300); LcdPutChar('4');
MsDelay(300); LcdPutChar('.');
MsDelay(300); LcdPutChar('.');
MsDelay(300); LcdPutChar('3');
MsDelay(300); LcdPutChar('.');
MsDelay(300); LcdPutChar('.');
MsDelay(300); LcdPutChar('2');
MsDelay(300); LcdPutChar('.');
MsDelay(300); LcdPutChar('.');
MsDelay(300); LcdPutChar('1');
MsDelay(300); LcdPutChar('.');
MsDelay(300); LcdPutChar('.');
MsDelay(300); LcdPutChar('0');
MsDelay(300); Lcd_Off();
}
///// 4-bit lcd command
void lcdCmd4 (char cmd4)
{
WrPortI ( PADR,&PADRShadow,(cmd4&0xF1)|(PADRShadow&1) ); // Ready Nibble
WrPortI ( PADR,&PADRShadow,PADRShadow|0x02 ); // Write Nibble
WrPortI ( PADR,&PADRShadow,PADRShadow&0xFD );
}