| 0,0 → 1,1434 |
|---|
| // Change the following to change the clock frequency |
| #define CRYSTAL_FREQ 16000000 |
| // Change the following to change between 16 or 20 column display |
| #define DISPLAY_COLS 20 |
| // Speed units are "1" (nautical knots), "2" (metric kph), or "3" (statute mph) |
| #define SPEED_UNITS 1 |
| |
| /**************************************************************************** |
| GPS18.c |
| |
| This program receives NMEA-0183 data from a GPS and displays it. |
| Meant for large display version still in 16F876. |
| Three buttons |
| Automicaly resets if main loop stops (not the best solution, still don't know why it's stopping) |
| |
| Next: don't display GPS screens unless GPS is active |
| detect display needing reset |
| preset data eeprom for first-time operation |
| don't display init stuff if reseting from main loop |
| |
| |
| |
| +5 +5+5 |
| | | | |
| 20 15 2 |
| ---------- ---------- |
| ~SerIn -----18-| |-24-----11-|DB4 A Vdd | |
| | |-25-----12-|DB5 | |
| ADC0 ------2-| |-26-----13-|DB6 | |
| ADC1 ------3-| 16F876 |-27-----14-|DB7 Vo| 3-- |
| ADC2 ------5-| | | LCD | | |
| | |-14------6-|EN | | |
| XTAL--9-| |-15------4-|R/S | | |
| XTAL-10-| |-28-FET-16-|K | | |
| | | | RW Vss | | |
| BUTTON 1---21-| | ---------- | |
| BUTTON 2---22-| | 1 5 | |
| BUTTON 3---23-| | | | | |
| | | Gnd Gnd | |
| | | | |
| | |-11----------R/C----------- |
| | | |
| | | |
| ---------- |
| 8 19 |
| | | |
| Gnd Gnd |
| |
| ***************************************************************************/ |
| #case |
| #include <16F876.h> |
| #include <jonsinc.h> |
| #device = *=16 ADC=10 /* allow RAM addresses over 255 */ |
| |
| #if ( ( CRYSTAL_FREQ < 4000000) || ( CRYSTAL_FREQ > 20000000 ) ) |
| #error "CRYSTAL FREQ" not defined to between 8000000 and 20000000 |
| #endif |
| #if ( ( DISPLAY_COLS != 16 ) && ( DISPLAY_COLS != 20 ) ) |
| #error "DISPLAY COLS" not defined to 16 or 20 |
| #endif |
| |
| // RMC_TIME = 1 per clock megahertz, rounded |
| #define RMC_TIME CRYSTAL_FREQ/1000000 |
| |
| #define LCD_D0 PIN_B3 |
| #define LCD_D1 PIN_B4 |
| #define LCD_D2 PIN_B5 |
| #define LCD_D3 PIN_B6 |
| #define LCD_EN PIN_C3 |
| #define LCD_RS PIN_C4 |
| #define RX_IN PIN_C7 |
| #define BUTTON_1 PIN_B0 |
| #define BUTTON_2 PIN_B1 |
| #define BUTTON_3 PIN_B2 |
| #define LCD_BACKLITE PIN_B7 |
| #define LINE_1 0x00 |
| #define LINE_2 0x40 |
| #if DISPLAY_COLS == 20 |
| #define LINE_3 0x14 |
| #define LINE_4 0x54 |
| #endif |
| #if DISPLAY_COLS == 16 |
| #define LINE_3 0x10 |
| #define LINE_4 0x50 |
| #endif |
| #define CLEAR_DISP 0x01 |
| #define EOF 0x00 |
| #define COMMA ',' |
| #define CR 13 |
| #define SPACE ' ' |
| #define PERIOD '.' |
| #define DEGREE 0xdf |
| #define DOLLAR '$' |
| #define NULL 0 |
| #define GPRMC_CODE 75 |
| #define GPRMB_CODE 74 |
| #define RX_BUFFER_SIZE 70 |
| #define POSITION_SCREEN 1 |
| #define WAYPOINT_SCREEN 2 |
| #define BATTERY_SCREEN 3 |
| #define HIDDEN_RMC 5 |
| #define WARNING_MSG 0 |
| #define NODATA_MSG 1 |
| #define ACTIVITY_SYMBOL 0xFF |
| #define MAX_VOLTS 15 |
| #define EEPROM_CONTRAST 0 |
| #define EEPROM_INITIAL 1 |
| |
| /* Set the following define to "YES" to display XOR'ed GPS sentence code */ |
| /* such as GPRMC and the display will read out the value of 74. */ |
| #define GET_GPS_CODE NO |
| |
| #separate void Display ( void ); |
| #separate void LCD_Init ( void ); |
| #separate void LCD_SetPosition ( unsigned int cX ); |
| #separate void LCD_PutChar ( unsigned int cX ); |
| #separate void LCD_PutCmd ( unsigned int cX ); |
| #separate void LCD_PulseEnable ( void ); |
| #separate void LCD_SetData ( unsigned int cX ); |
| #separate void SkipField ( char cCnt ); |
| #separate char GetField ( void ); |
| #separate void InitRxBuffer ( char cCode ); |
| #separate char GetRxChar ( void ); |
| #separate void DisplayLatLon ( void ); |
| #separate void DisplayWaypoint ( void ); |
| #separate void DisplayLatitude ( char cLine ); |
| #separate void DisplayLongitude ( char cLine ); |
| #separate void DisplayHeading ( char cLine ); |
| #separate void DisplaySpeed ( char cLine ); |
| #separate void DisplaySteer ( char cLine, char cX ); |
| #separate void DisplayWaypointName ( char cLine, char cX ); |
| #separate void DisplayDistance ( char cLine, char cX ); |
| #separate void DisplayBearing ( char cLine, char cX ); |
| #separate void GetUtcAndMagVar ( void ); |
| #separate long TrueToMag ( long iH ); |
| #separate long FieldFiveToLong ( void ); |
| #separate void DisplayAnalog ( void ); |
| #separate void DisplayScaledVoltage ( long iV, char cScale ); |
| #separate void DisplayArrival ( char cLine ); |
| #separate void DisplayMessage ( char cMsgNum ); |
| #separate void DisplayTemplateLatLon ( void ); |
| #separate void DisplayTemplateWaypoint ( void ); |
| #separate void DisplayTemplateAnalog ( void ); |
| #separate void Delay5mS ( char cCnt ); |
| |
| #fuses HS, NOPROTECT, PUT, NOWDT, BROWNOUT, NOLVP, NOCPD |
| #use standard_io ( A ) |
| #use standard_io ( B ) |
| #use standard_io ( C ) |
| #use delay ( clock = CRYSTAL_FREQ ) |
| #use rs232 ( baud=4800, xmit=PIN_C6, rcv=PIN_C7, ERRORS ) // XMIT must be assigned to enable hardward USART |
| #priority RDA, RTCC, EXT |
| |
| static char cC [ 10 ]; // local buffer |
| static char cTimeOut; |
| static char cRxBuffer [ RX_BUFFER_SIZE ]; // Fifo |
| static char cRxByteCnt; // Number of bytes in the recv fifo |
| static char *cRxBufferWritePtr; // Pointers for the Rx buffer |
| static char *cRxBufferReadPtr; |
| static char cRxIsrState, cRxMsgTypeReceived, cRxMsgTypeDesired; |
| static char cRxMsgReady, cReceiveFlag; |
| static long iVar, iLastRange, iTimeOut; |
| static char cVarDir, cScreenChanged, cAdcDone; |
| static char cButtonPressed, cSkip, cButtonCount; |
| static char cScreen, cSavedScreen, cRmcTimer1, cRmcTimer2; |
| static char cToFrom [ 5 ], cIndicator, cIllumination, cRxErrorFlag; |
| static char cDone, cContrast; |
| |
| /*******************************************************************/ |
| #int_ad |
| void AdcInterrupt ( void ) |
| { |
| /* Gets here when ADC is done conversion, sets flag */ |
| cAdcDone = YES; |
| } |
| |
| #int_timer1 |
| void Timer1Interrupt ( void ) |
| { |
| /* Periodic RMC data timer, gets here every 204mS */ |
| /* This routine forces RMC to run every 10 minutes to update */ |
| /* magnetic variation */ |
| if ( cRmcTimer1-- == 0 ) |
| { |
| cRmcTimer1 = 255; // 52 seconds @ 10.240MHz |
| if ( cRmcTimer2-- == 0 ) |
| { |
| cRmcTimer2 = RMC_TIME; // triggers every 10 minutes |
| cSavedScreen = cScreen; // save current screen type |
| cScreen = HIDDEN_RMC; // force RMC to run |
| } |
| } |
| } |
| |
| #int_rtcc |
| void Timer0Interrupt ( void ) |
| { |
| // Gets here every 16.4mS at 8MHz, 8.2mS at 16MHz |
| // Handles data timeout and switch debounce. |
| |
| // DATA TIMEOUT TIMER |
| if ( cTimeOut != 0 ) |
| { |
| cTimeOut--; |
| } |
| |
| // This timer is preset by the normal operating loop, unless the operating |
| // loop stops looping, at which point iTimeOut finally decrements to zero |
| // and resets CPU. |
| if ( iTimeOut != 0 ) |
| { |
| iTimeOut--; |
| } |
| else |
| { |
| reset_cpu(); // force reset |
| } |
| |
| if ( input ( BUTTON_2 ) == LOW ) // if button still pressed |
| { |
| cScreen = WAYPOINT_SCREEN; |
| cSkip = YES; // skip out of anything in process |
| cScreenChanged = YES; // repaint complete screen |
| } |
| |
| if ( input ( BUTTON_3 ) == LOW ) // if button still pressed |
| { |
| cScreen = BATTERY_SCREEN; |
| cSkip = YES; // skip out of anything in process |
| cScreenChanged = YES; // repaint complete screen |
| } |
| |
| // SWITCH DEBOUNCE |
| if ( input ( BUTTON_1 ) == LOW ) // if button still pressed |
| { |
| if ( cButtonCount < 255 ) // hold at 255 |
| { |
| cButtonCount++; // otherwise increment |
| } |
| } |
| else // if button is unpressed |
| { |
| if ( cButtonCount > 2 ) // filter out glitches |
| { |
| //If button press is greater than 3.3 seconds, cold reset |
| if ( cButtonCount == 255 ) |
| { |
| reset_cpu(); |
| } |
| if ( ( cButtonCount > 57 ) && ( cButtonCount < 255 ) ) |
| { |
| if ( cScreen != HIDDEN_RMC ) // if not in the middle of getting magnetic variation |
| { |
| // cIllumination ^= ON; |
| output_bit ( LCD_BACKLITE, cIllumination ^= ON ); |
| } |
| } |
| // If button press is less than 0.5 second |
| if ( cButtonCount <= 57 ) |
| { |
| if ( cScreen != HIDDEN_RMC ) // if not in the middle of getting magnetic variation |
| { |
| //if ( cScreen++ >= BATTERY_SCREEN ) // increment to next screen |
| { |
| cScreen = POSITION_SCREEN; // wrap |
| } |
| cSkip = YES; // skip out of anything in process |
| cScreenChanged = YES; // repaint complete screen |
| } |
| } |
| } |
| cButtonCount = 0; // restart |
| } |
| } |
| |
| #int_rda |
| void SerialInterrupt ( void ) |
| { |
| /* |
| Reads incoming data from the USART and puts in in a rolling buffer |
| ( but in this application, it should never roll.) |
| If the buffer is full, this routine just discards the received byte. |
| Not checking the LRC byte at the end of the NMEA-0183 sentence. |
| */ |
| char cChar; |
| |
| if ( rs232_errors & 0x04 ) // get framing error bit from Rx status reg |
| { |
| cRxErrorFlag = ON; |
| } |
| cChar = getchar(); // get char from UART, clear any errors |
| |
| if ( cRxByteCnt == RX_BUFFER_SIZE ) // is recv fifo full ??? |
| { |
| goto done; |
| } |
| switch ( cRxIsrState ) |
| { |
| case 0: |
| { |
| if ( cChar == DOLLAR ) // if start of NMEA0183 message |
| { |
| cRxByteCnt = 0; // reset byte count |
| cReceiveFlag = OFF; // default to off |
| cRxMsgTypeReceived = NULL; // set hashed value to null |
| cRxIsrState++; // next state |
| } |
| break; |
| } |
| case 1: // five type characters to obtain |
| case 2: |
| case 3: |
| case 4: |
| case 5: |
| { |
| cRxMsgTypeReceived ^= cChar; // hash in msg type |
| if ( cRxIsrState++ == 5 ) // if time to check message type |
| { |
| if ( cRxMsgTypeReceived == cRxMsgTypeDesired ) // if good |
| { |
| cReceiveFlag = YES; // enable receiving |
| cRxBufferWritePtr = cRxBuffer; // reset to beginning of buffer |
| } |
| else // don't want this message |
| { |
| cRxIsrState = 0; // reset to look for next msg |
| } |
| } |
| break; |
| } |
| case 6: |
| { |
| /* Case 6 skips the comma character following msg type */ |
| cRxIsrState++; |
| break; |
| } |
| default: // remainder of characters |
| { |
| if ( cReceiveFlag == YES ) // if this message is wanted |
| { |
| *cRxBufferWritePtr = cChar; // put char in fifo |
| cRxBufferWritePtr++; // increment pointer |
| if ( cRxBufferWritePtr == ( cRxBuffer + RX_BUFFER_SIZE ) ) // pointer past end ? |
| { |
| cRxBufferWritePtr = cRxBuffer; // set pointer to start of fifo |
| } |
| cRxByteCnt++; // Increment byte count |
| if ( cChar == CR ) |
| { |
| cRxMsgReady = YES; // signal that message is ready |
| cReceiveFlag = NO; // no more receive |
| } |
| } |
| } |
| } |
| done:; |
| } |
| |
| /*******************************************************************/ |
| |
| void main ( void ) |
| { |
| char cX; |
| |
| iTimeOut = 65535; // default to very long to get by init |
| /* INITIALIZE */ |
| output_float ( RX_IN ); // ensure Rx input is HiZ |
| output_float ( BUTTON_1 ); // ensure switch input is HiZ |
| output_float ( BUTTON_2 ); // ensure switch input is HiZ |
| output_float ( BUTTON_3 ); // ensure switch input is HiZ |
| output_low ( LCD_BACKLITE ); // turn off backlighting |
| port_b_pullups ( ON ); // enable pullups on switches |
| |
| // GET SAVED SETTINGS |
| cContrast = read_eeprom ( EEPROM_CONTRAST ); // get stored value |
| |
| // PWM is for display contrast |
| setup_ccp2 ( CCP_PWM ); // set for PWM mode |
| //The cycle time will be (1/clock)*4*t2div*(period+1) |
| // 1/8000000 * 4 * 1 * 128 = 51.2uS = 19.5KHz |
| setup_timer_2 ( T2_DIV_BY_1, 255, 1 ); // set PWM period |
| // duty cycle = value*(1/clock)*t2div |
| // 10 * 1/8000000 * 1 = 1.2uS |
| set_pwm2_duty ( cContrast ); // set contrast duty cycle |
| |
| // SETUP TIMER 0 |
| // Need 8-bit Timer0 to roll over every 13mS, approximately. |
| // Roll time = 256 * 1 / ( clock_freq / prescaler setting / 4 ) |
| #if CRYSTAL_FREQ >= 15000000 |
| setup_counters ( RTCC_INTERNAL, RTCC_DIV_256 ); // ~13mS timer wrap |
| #elif CRYSTAL_FREQ >= 8000000 |
| setup_counters ( RTCC_INTERNAL, RTCC_DIV_128 ); // ~13mS timer wrap |
| #elif CRYSTAL_FREQ < 8000000 |
| setup_counters ( RTCC_INTERNAL, RTCC_DIV_64 ); // ~13mS timer wrap |
| #endif |
| |
| // Timer 1 roll time = 65536 * 1 / ( clock_freq / prescaler setting / 4 ) |
| setup_timer_1 ( T1_INTERNAL | T1_DIV_BY_8 ); // 16-bit timer |
| |
| setup_adc_ports ( RA0_RA1_RA3_ANALOG ); /* these three statements set up the ADC */ |
| setup_adc ( ADC_CLOCK_INTERNAL ); |
| cIllumination = OFF; |
| |
| LCD_Init(); // set up LCD for 4-wire bus, etc. |
| |
| /* INIT MESSAGE */ |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( LINE_1 + 0 ); |
| printf ( LCD_PutChar, " Northern Light " ); // welcome screen |
| LCD_SetPosition ( LINE_2 + 2 ); |
| printf ( LCD_PutChar, "Monitor/Repeater" ); |
| LCD_SetPosition ( LINE_3 + 3 ); |
| printf ( LCD_PutChar, "v18 06/21/03" ); |
| LCD_SetPosition ( LINE_4 + 5 ); |
| printf ( LCD_PutChar, "c Jon Fick" ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( LINE_1 + 0); |
| printf ( LCD_PutChar, " Northern Light " ); // welcome screen |
| LCD_SetPosition ( LINE_2 + 2 ); |
| printf ( LCD_PutChar, "GPS Repeater" ); |
| LCD_SetPosition ( LINE_3 + 1 ); |
| printf ( LCD_PutChar, "v18 06/21/03" ); |
| LCD_SetPosition ( LINE_4 + 3 ); |
| printf ( LCD_PutChar, "c Jon Fick" ); |
| #endif |
| delay_ms ( 1000 ); |
| |
| /* INSTRUCTION MESSAGE */ |
| LCD_PutCmd ( CLEAR_DISP ); |
| LCD_SetPosition ( LINE_1 + 0 ); |
| printf ( LCD_PutChar, "BUTTONS:" ); |
| LCD_SetPosition ( LINE_2 + 0 ); |
| printf ( LCD_PutChar, "<-- Lat/Lon" ); |
| LCD_SetPosition ( LINE_3 + 0 ); |
| printf ( LCD_PutChar, "<-- Waypoint" ); |
| LCD_SetPosition ( LINE_4 + 0 ); |
| printf ( LCD_PutChar, "<-- Battery" ); |
| delay_ms ( 2000 ); |
| |
| /* SETUP MODE */ |
| if ( input ( BUTTON_1 ) == LOW ) // if button is pressed |
| { |
| LCD_PutCmd ( CLEAR_DISP ); |
| LCD_SetPosition ( LINE_1 + 0 ); |
| printf ( LCD_PutChar, "Set contrast:" ); |
| LCD_SetPosition ( LINE_2 + 0 ); |
| printf ( LCD_PutChar, "<-- More" ); |
| LCD_SetPosition ( LINE_3 + 0 ); |
| printf ( LCD_PutChar, "<-- DONE" ); |
| LCD_SetPosition ( LINE_4 + 0 ); |
| printf ( LCD_PutChar, "<-- Less" ); |
| while ( input ( BUTTON_1 ) == LOW ); // wait for switch to be released after entering SETUP mode |
| cContrast = 120; // start at full contrast |
| cDone = NO; |
| while ( cDone == NO ) |
| { |
| set_pwm2_duty ( cContrast ); // update contrast |
| if ( input ( BUTTON_1 ) == LOW ) |
| { |
| if ( cContrast > 0 ) |
| { |
| cContrast--; // more |
| } |
| } |
| if ( input ( BUTTON_2 ) == LOW ) |
| { |
| cDone = YES; // done |
| } |
| if ( input ( BUTTON_3 ) == LOW ) |
| { |
| if ( cContrast < 255 ) |
| { |
| cContrast++; // less |
| } |
| } |
| delay_ms ( 30 ); // autorepeat |
| } |
| write_eeprom ( EEPROM_CONTRAST, cContrast ); // save CONTRAST to EEPROM |
| |
| LCD_PutCmd ( CLEAR_DISP ); |
| LCD_SetPosition ( LINE_2 + 0 ); |
| printf ( LCD_PutChar, "<- Press initial" ); |
| LCD_SetPosition ( LINE_3 + 0 ); |
| printf ( LCD_PutChar, " bootup screen" ); |
| while ( input ( BUTTON_1 ) == LOW ); // wait until button not pressed |
| cX = POSITION_SCREEN; |
| while ( TRUE ) |
| { |
| LCD_SetPosition ( LINE_4 + 3 ); |
| switch ( cX ) |
| { |
| case POSITION_SCREEN: |
| { |
| printf ( LCD_PutChar, "POSITION " ); |
| break; |
| } |
| case WAYPOINT_SCREEN: |
| { |
| printf ( LCD_PutChar, "WAYPOINT " ); |
| break; |
| } |
| case BATTERY_SCREEN: |
| { |
| printf ( LCD_PutChar, "BATTERY " ); |
| break; |
| } |
| } |
| delay_ms ( 750 ); |
| if ( input ( BUTTON_1 ) == LOW ) // if button is pressed |
| { |
| write_eeprom ( EEPROM_INITIAL, cX ); // save screen number to EEPROM |
| break; |
| } |
| if ( cX++ == BATTERY_SCREEN ) |
| { |
| cX = POSITION_SCREEN; |
| } |
| } |
| LCD_PutCmd ( CLEAR_DISP ); |
| } |
| |
| /* This IF/ENDIF is a tool for getting the $GP... codes */ |
| /* that are used in the switch/case in the main loop. */ |
| #if ( GET_GPS_CODE == YES ) |
| printf ( LCD_PutChar, "%u", 'G'^'P'^'R'^'M'^'B'); |
| while ( TRUE ); |
| #endif |
| |
| /* INTERRUPTS */ |
| ext_int_edge ( H_TO_L ); // set falling edge ext interrupt |
| enable_interrupts ( INT_TIMER1 ); // enable Timer1 interrupt |
| enable_interrupts ( INT_RDA ); // enable serial interrupt |
| enable_interrupts ( INT_RTCC ); // enable Timer0 interrupt |
| enable_interrupts ( INT_AD ); // enable ADC interrupt |
| enable_interrupts ( GLOBAL ); // enable all interrupts |
| |
| /* VARIABLES */ |
| iVar = NULL; // default, no variation yet |
| cVarDir = SPACE; // default, no variation yet |
| cRmcTimer1 = 255; // initialize to 52 seconds |
| cRmcTimer2 = RMC_TIME; // trigger forced RMC after 10 minutes |
| cScreen = HIDDEN_RMC; // default screen, get magnetic variation first |
| cSavedScreen = read_eeprom ( EEPROM_INITIAL ); // restore initial screen |
| iLastRange = 65535; // make max by default |
| strcpy ( cToFrom, " " ); // blank by default |
| cScreenChanged = YES; |
| cIndicator = 0; |
| cButtonCount = 0; |
| cButtonPressed = NO; |
| cRxErrorFlag = OFF; |
| |
| /* MAIN LOOP */ |
| while ( TRUE ) |
| { |
| cTimeOut = 188; // 231 * 0.013mS = 3 seconds |
| switch ( cScreen ) |
| { |
| case HIDDEN_RMC: |
| { |
| InitRxBuffer( GPRMC_CODE ); // set code and turn on serial interrupt |
| while ( ( cRxMsgReady == NO ) && ( cTimeOut != 0 ) ); |
| disable_interrupts ( INT_RDA ); // ignore rest of messages |
| if ( cTimeOut != 0 ) // if not timed out |
| { |
| GetUtcAndMagVar(); // get and store the magnetic variation |
| } |
| cScreen = cSavedScreen; // revert to previous screen |
| break; |
| } |
| case POSITION_SCREEN: |
| { |
| if ( cScreenChanged == YES ) |
| { |
| disable_interrupts ( INT_RDA ); |
| cScreenChanged = NO; |
| cSkip = NO; |
| LCD_PutCmd ( CLEAR_DISP ); |
| DisplayTemplateLatLon(); |
| enable_interrupts ( INT_RDA ); |
| } |
| InitRxBuffer( GPRMC_CODE ); // set code and turn on serial interrupt |
| while ( ( cRxMsgReady == NO ) && ( cTimeOut != 0 ) && ( cScreenChanged != YES ) ); |
| disable_interrupts ( INT_RDA ); // ignore rest of messages |
| if ( cScreenChanged == NO ) |
| { |
| if ( cTimeOut != 0 ) |
| { |
| DisplayLatLon(); |
| } |
| else |
| { |
| DisplayMessage ( NODATA_MSG ); |
| } |
| } |
| cRxErrorFlag = OFF; |
| break; |
| } |
| case WAYPOINT_SCREEN: |
| { |
| if ( cScreenChanged == YES ) |
| { |
| disable_interrupts ( INT_RDA ); |
| cScreenChanged = NO; |
| cSkip = NO; |
| LCD_PutCmd ( CLEAR_DISP ); |
| DisplayTemplateWaypoint(); |
| enable_interrupts ( INT_RDA ); |
| } |
| cSkip = NO; |
| InitRxBuffer( GPRMB_CODE ); // set code and turn on serial interrupt |
| while ( ( cRxMsgReady == NO ) && ( cTimeOut != 0 ) && ( cScreenChanged != YES ) ); |
| disable_interrupts ( INT_RDA ); // ignore rest of messages |
| if ( cScreenChanged == NO ) |
| { |
| if ( cTimeOut != 0 ) |
| { |
| DisplayWaypoint(); |
| } |
| else |
| { |
| DisplayMessage ( NODATA_MSG ); |
| } |
| } |
| break; |
| } |
| case BATTERY_SCREEN: |
| { |
| if ( cScreenChanged == YES ) |
| { |
| disable_interrupts ( INT_RDA ); |
| cScreenChanged = NO; |
| cSkip = NO; |
| LCD_PutCmd ( CLEAR_DISP ); |
| DisplayTemplateAnalog(); |
| } |
| DisplayAnalog(); |
| break; |
| } |
| } |
| |
| // Preset timeout counter each loop; RTCC interrupt decrements, resets if zero is reached |
| iTimeOut = 2000; // ~ 30 seconds |
| |
| /* Flashing activity indicator in lower right of screen. */ |
| cIndicator ^= 1; |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( LINE_4 + 19 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( LINE_4 + 15 ); |
| #endif |
| if ( cIndicator == 1 ) |
| { |
| printf ( LCD_PutChar, "%c", ACTIVITY_SYMBOL ); |
| } |
| else |
| { |
| printf ( LCD_PutChar, " " ); |
| } |
| } |
| } |
| |
| #separate void DisplayTemplateLatLon ( void ) |
| { |
| LCD_SetPosition ( LINE_1 ); |
| printf ( LCD_PutChar, "LAT" ); |
| LCD_SetPosition ( LINE_2 ); |
| printf ( LCD_PutChar, "LON" ); |
| LCD_SetPosition ( LINE_3 ); |
| #if ( DISPLAY_COLS == 20 ) |
| printf ( LCD_PutChar, "SPEED" ); |
| LCD_SetPosition ( LINE_4 ); |
| printf ( LCD_PutChar, "HEADING" ); |
| #elif ( DISPLAY_COLS == 16 ) |
| printf ( LCD_PutChar, "SPD" ); |
| LCD_SetPosition ( LINE_4 ); |
| printf ( LCD_PutChar, "HDG" ); |
| #endif |
| } |
| |
| #separate void DisplayTemplateWaypoint ( void ) |
| { |
| LCD_SetPosition ( LINE_1 ); |
| #if ( DISPLAY_COLS == 20 ) |
| printf ( LCD_PutChar, "WAYPOINT" ); |
| #elif ( DISPLAY_COLS == 16 ) |
| printf ( LCD_PutChar, "WAYPT" ); |
| #endif |
| LCD_SetPosition ( LINE_2 ); |
| printf ( LCD_PutChar, "STEER" ); |
| LCD_SetPosition ( LINE_3 ); |
| printf ( LCD_PutChar, "DIST" ); |
| LCD_SetPosition ( LINE_4 ); |
| printf ( LCD_PutChar, "BEARING" ); |
| } |
| |
| #separate void DisplayTemplateAnalog ( void ) |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( LINE_1 + 3 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( LINE_1 + 1 ); |
| #endif |
| printf ( LCD_PutChar, "BATTERY STATUS" ); |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( LINE_2 ); |
| printf ( LCD_PutChar, "Primary" ); |
| LCD_SetPosition ( LINE_3 ); |
| printf ( LCD_PutChar, "Secondary" ); |
| LCD_SetPosition ( LINE_4 ); |
| printf ( LCD_PutChar, "Refrigerator" ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( LINE_2 ); |
| printf ( LCD_PutChar, "Main#1 " ); |
| LCD_SetPosition ( LINE_3 ); |
| printf ( LCD_PutChar, "Main#2 " ); |
| LCD_SetPosition ( LINE_4 ); |
| printf ( LCD_PutChar, "Refrig " ); |
| #endif |
| } |
| |
| #separate void DisplayLatLon ( void ) |
| { |
| SkipField ( 1 ); // skip UTC |
| GetField(); // A = OK, V = warning |
| if ( ( cC [ 0 ] == 'A' ) && ( !cSkip ) ) |
| { |
| GetField(); // LAT |
| if ( !cSkip ) |
| { |
| DisplayLatitude ( LINE_1 ); |
| } |
| GetField(); // LON |
| if ( !cSkip ) |
| { |
| DisplayLongitude ( LINE_2 ); |
| } |
| GetField(); // SPEED |
| if ( !cSkip ) |
| { |
| DisplaySpeed ( LINE_3 ); |
| } |
| GetField(); // HEADING |
| if ( !cSkip ) |
| { |
| DisplayHeading ( LINE_4 ); |
| } |
| } |
| else |
| { |
| DisplayMessage( WARNING_MSG ); |
| } |
| } |
| |
| #separate void DisplayWaypoint ( void ) |
| { |
| char cX; |
| |
| GetField(); // A = OK, V = warning |
| if ( ( cC [ 0 ] == 'A' ) && ( !cSkip ) ) |
| { |
| cX = GetField(); // XTE |
| if ( !cSkip ) |
| { |
| DisplaySteer ( LINE_2, cX ); |
| } |
| SkipField ( 1 ); // skip origin WP ID |
| GetField(); // DEST WP ID |
| if ( !cSkip ) |
| { |
| DisplayWaypointName ( LINE_1, cX ); |
| } |
| SkipField ( 4 ); // skip LAT, NS, LON, EW |
| cX = GetField(); // RANGE |
| if ( !cSkip ) |
| { |
| DisplayDistance ( LINE_3, cX ); |
| } |
| cX = GetField(); // BEARING |
| if ( !cSkip ) |
| { |
| DisplayBearing ( LINE_4, cX ); |
| } |
| SkipField ( 1 ); // skip SPEED TO DEST |
| GetField(); // ARRIVAL FLAG |
| if ( !cSkip ) |
| { |
| DisplayArrival ( LINE_1 ); // overwrite RANGE if arrived |
| } |
| } |
| else |
| { |
| DisplayMessage( WARNING_MSG ); |
| } |
| } |
| |
| #separate void DisplayAnalog ( void ) |
| { |
| long iX; |
| char cCnt; |
| |
| set_adc_channel ( 0 ); // set channel |
| delay_us ( 100 ); // wait aquisition time |
| cAdcDone = NO; |
| if ( !cSkip ) |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( LINE_2 + 13 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( LINE_2 + 8 ); |
| #endif |
| DisplayScaledVoltage ( read_adc(), MAX_VOLTS ); |
| printf ( LCD_PutChar, " V " ); |
| } |
| set_adc_channel ( 1 ); |
| delay_us ( 100 ); |
| cAdcDone = NO; |
| if ( !cSkip ) |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( LINE_3 + 13 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( LINE_3 + 8 ); |
| #endif |
| DisplayScaledVoltage ( read_adc(), MAX_VOLTS ); |
| printf ( LCD_PutChar, " V " ); |
| } |
| set_adc_channel ( 3 ); |
| delay_us ( 100 ); |
| cAdcDone = NO; |
| if ( !cSkip ) |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( LINE_4 + 13 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( LINE_4 + 8 ); |
| #endif |
| DisplayScaledVoltage ( read_adc(), MAX_VOLTS ); |
| printf ( LCD_PutChar, " V " ); |
| } |
| Delay5mS ( 100 ); // slow loop down a bit |
| } |
| |
| #separate void GetUtcAndMagVar ( void ) |
| { |
| /* |
| This is a non-display version of the RMC sentence |
| to get the A/V warning, the magnetic variation, and the |
| magnetic direction. |
| */ |
| |
| GetField(); // get UTC |
| GetField(); // A = OK, V = warning |
| if ( cC [ 0 ] == 'A' ) |
| { |
| SkipField ( 7 ); // skip fields |
| GetField(); // MAGNETIC VARIATION |
| iVar = FieldFiveToLong(); // save to global variable, used in other sentences |
| GetField(); // EW |
| cVarDir = cC [ 0 ]; // save direction |
| } |
| else |
| { |
| iVar = NULL; // invalid |
| cVarDir = SPACE; |
| } |
| } |
| |
| /******************************************************************/ |
| |
| #separate void DisplayScaledVoltage ( long iV, char cScale ) |
| { |
| float fX; |
| |
| /* |
| 0 to 5V input at pin 2 results in 0 - 1023. This routine |
| scales it to something else. |
| */ |
| while ( cAdcDone == NO ); // wait for completion by ADC interrupt |
| if ( iV == 1023 ) |
| { |
| printf ( LCD_PutChar, "O/L" ); /* print it to the screen */ |
| } |
| else |
| { |
| fX = ( ( float ) iV ) / 1023 * ( float ) cScale; // scale to proper range, 1023 leaves room for out-of-range |
| printf ( LCD_PutChar, "%2.1f", fX ); /* print it to the screen */ |
| } |
| } |
| |
| #separate void DisplayArrival ( char cLine ) |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( cLine + 11 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( cLine + 9 ); |
| #endif |
| if ( cC [ 0 ] == 'A' ) |
| { |
| printf ( LCD_PutChar, "Arrived" ); |
| } |
| else |
| { |
| printf ( LCD_PutChar, " " ); |
| } |
| } |
| |
| #separate void DisplayWaypointName ( char cLine, char cX ) |
| { |
| /* Displays waypoint name, pads field with blanks */ |
| char cChar, cI; |
| |
| LCD_SetPosition ( cLine ); |
| if ( cX != 0 ) |
| { |
| printf ( LCD_PutChar, "\"" ); |
| for ( cI = 0; cI < 6; cI++ ) |
| { |
| cChar = cC [ cI ]; |
| if ( cChar == EOF ) |
| { |
| break; |
| } |
| printf ( LCD_PutChar, "%c", cChar ); |
| } |
| printf ( LCD_PutChar, "\"" ); |
| // Blank remainder of field |
| cChar = SPACE; |
| for ( ; cI < 6; cI++ ) |
| { |
| printf ( LCD_PutChar, "%c", cChar ); |
| } |
| } |
| else |
| { |
| printf ( LCD_PutChar, "- none -" ); |
| } |
| } |
| |
| #separate void DisplaySteer ( char cLine, char cX ) |
| { |
| /* |
| Displays A.BC literals, appends 'L' or 'R'. |
| If less than 1.0, displays feet rather than nm. |
| Doesn't display distance if on track. |
| */ |
| long iX; |
| char cCnt; |
| |
| if ( cX != 0 ) |
| { |
| if ( ( cC [ 0 ] != '0' ) || ( cC [ 2 ] != '0' ) || ( cC [ 3 ] != '0' ) ) // if not 0.00 |
| { |
| LCD_SetPosition ( cLine + 14 ); |
| #if ( DISPLAY_COLS == 20 ) |
| printf ( LCD_PutChar, " " ); // blank possible characters |
| LCD_SetPosition ( cLine + 11 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| printf ( LCD_PutChar, " " ); // blank possible characters |
| LCD_SetPosition ( cLine + 8); |
| #endif |
| if ( cC [ 0 ] == '0' ) // if less than 1.0 nm, display as feet |
| { |
| iX = ( 528 * ( long ) ( cC [ 2 ] - 0x30 ) ) + ( 52 * ( long ) ( cC [ 3 ] - 0x30 ) ); |
| printf ( LCD_PutChar, "%luft ", iX ); |
| } |
| else // if 1.0 nm or greater, display as nautical miles |
| { |
| printf ( LCD_PutChar, "%c%c%c%cmi ", cC [ 0 ], cC [ 1 ], cC [ 2 ] , cC [ 3 ] ); |
| } |
| GetField(); // L or R |
| LCD_SetPosition ( cLine + 6 ); |
| if ( cC [ 0 ] == 'L' ) |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| printf ( LCD_PutChar, "PORT " ); |
| #elif ( DISPLAY_COLS == 16 ) |
| printf ( LCD_PutChar, "L" ); |
| #endif |
| } |
| else |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| printf ( LCD_PutChar, "STBD " ); |
| #elif ( DISPLAY_COLS == 16 ) |
| printf ( LCD_PutChar, "R" ); |
| #endif |
| } |
| } |
| else // if 0.00 |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( cLine + 11 ); |
| printf ( LCD_PutChar, "On track " ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( cLine + 6 ); |
| printf ( LCD_PutChar, " On track" ); |
| #endif |
| GetField(); // dummy L or R |
| } |
| } |
| else |
| { |
| LCD_SetPosition ( cLine + 6 ); |
| printf ( LCD_PutChar, " " ); |
| } |
| } |
| |
| #separate void DisplayDistance ( char cLine, char cX ) |
| { |
| /* Format: ABC.D nautical miles */ |
| char cChar, cI; |
| long iThisRange; |
| |
| if ( cX != 0 ) // if waypoint data to display |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( cLine + 11 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( cLine + 8 ); |
| #endif |
| cI = 0; |
| for ( cI = 0; cI < 2; cI++ ) // find first non-zero |
| { |
| cChar = cC [ cI ]; |
| if ( cChar != '0' ) |
| { |
| break; |
| } |
| } |
| for ( ; cI < 5; cI++ ) // display from there on |
| { |
| printf ( LCD_PutChar, "%c", cC [ cI ] ); |
| } |
| printf ( LCD_PutChar, "nm " ); // pad with blanks |
| |
| /* |
| The least significant character from the GPS is 0.1 nm. |
| Multiply whole thing by 10 and make it type long. |
| Discern if increasing (FROM) or decreasing (TO). |
| */ |
| iThisRange = 1000 * ( long ) ( cC [ 0 ] - 0x30 ); |
| iThisRange += 100 * ( long ) ( cC [ 1 ] - 0x30 ); |
| iThisRange += 10 * ( long ) ( cC [ 2 ] - 0x30 ); |
| iThisRange += ( long ) ( cC [ 4 ] - 0x30 ); |
| if ( iThisRange < iLastRange ) |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| strcpy ( cToFrom, "TO " ); |
| #elif ( DISPLAY_COLS == 16 ) |
| strcpy ( cToFrom, "TO" ); |
| #endif |
| } |
| if ( iThisRange > iLastRange ) |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| strcpy ( cToFrom, "FROM" ); |
| #elif ( DISPLAY_COLS == 16 ) |
| strcpy ( cToFrom, "FM" ); |
| #endif |
| } |
| iLastRange = iThisRange; // save this range to compare next time |
| LCD_SetPosition ( cLine + 5 ); |
| printf ( LCD_PutChar, cToFrom ); |
| } |
| else |
| { |
| LCD_SetPosition ( cLine + 5 ); |
| #if ( DISPLAY_COLS == 20 ) |
| printf ( LCD_PutChar, " " ); |
| #elif ( DISPLAY_COLS == 16 ) |
| printf ( LCD_PutChar, " " ); |
| #endif |
| } |
| } |
| |
| #separate void DisplayBearing ( char cLine, char cX ) |
| { |
| /* |
| Compass variation comes from RMC sentence. If RMC has not run yet |
| then "T" is displayed after bearing. |
| */ |
| long iHdg; |
| char cTrueIndicator; |
| |
| if ( cX != 0 ) // if waypoint data to display |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( cLine + 11 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( cLine + 8 ); |
| #endif |
| iHdg = FieldFiveToLong(); |
| iHdg = TrueToMag ( iHdg ); // factor variation into heading |
| if ( ( iVar == NULL ) || ( cVarDir == SPACE ) ) |
| { |
| cTrueIndicator = 'T'; |
| } |
| else |
| { |
| cTrueIndicator = ' '; |
| } |
| printf ( LCD_PutChar, "%lu%c%c ", iHdg, DEGREE, cTrueIndicator ); // pad with blanks |
| } |
| else |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( cLine + 11 ); |
| printf ( LCD_PutChar, " " ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( cLine + 8 ); |
| printf ( LCD_PutChar, " " ); |
| #endif |
| } |
| } |
| |
| #separate void DisplayLatitude ( char cLine ) |
| { |
| /* Displays latitude ABCD.EF as AB CD.EF, appends 'N' or 'S' */ |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( cLine + 8 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( cLine + 5 ); |
| #endif |
| if ( cC [ 0 ] == '0' ) |
| { |
| cC [ 0 ] = SPACE; |
| } |
| printf ( LCD_PutChar, "%c%c%c", cC [ 0 ], cC [ 1 ], DEGREE ); |
| printf ( LCD_PutChar, "%c%c%c%c%c%c", cC [ 2 ], cC [ 3 ], cC [ 4 ], cC [ 5 ], cC [ 6 ], cC [ 7 ] ); |
| GetField(); // NS |
| printf ( LCD_PutChar, " %c", cC [ 0 ] ); |
| } |
| |
| #separate void DisplayLongitude ( char cLine ) |
| { |
| /* Displays longitude ABCDE.FG as ABC DE.FG, appends 'E' or 'W' */ |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( cLine + 7 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( cLine + 4 ); |
| #endif |
| if ( cC [ 0 ] == '0' ) |
| { |
| cC [ 0 ] = SPACE; |
| } |
| if ( cC [ 1 ] == '0' ) |
| { |
| cC [ 1 ] = SPACE; |
| } |
| printf ( LCD_PutChar, "%c%c%c%c", cC [ 0 ], cC [ 1 ], cC [ 2 ], DEGREE ); |
| printf ( LCD_PutChar, "%c%c%c%c%c%c", cC [ 3 ], cC [ 4 ], cC [ 5 ], cC [ 6 ], cC [ 7 ], cC [ 8 ] ); |
| GetField(); // EW |
| printf ( LCD_PutChar, " %c", cC [ 0 ] ); |
| } |
| |
| #separate void DisplaySpeed ( char cLine ) |
| { |
| float fX; |
| |
| // Format ABC.D |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( cLine + 8 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( cLine + 5 ); |
| #endif |
| fX = 100 * ( cC [ 0 ] - 0x30 ); |
| fX += 10 * ( cC [ 1 ] - 0x30 ); |
| fX += 1 * ( cC [ 2 ] - 0x30 ); |
| fX += 0.1 * ( cC [ 4 ] - 0x30 ); |
| #if SPEED_UNITS == 2 |
| fX *= 1.852; // convert knots to km/h |
| #endif |
| #if SPEED_UNITS == 3 |
| fX *= 1.151; // convert knots to mi/h |
| #endif |
| printf ( LCD_PutChar, "%3.1f ", fX ); // print it to the screen |
| #if SPEED_UNITS == 1 |
| printf ( LCD_PutChar, "kts " ); // print it to the screen |
| #endif |
| #if SPEED_UNITS == 2 |
| printf ( LCD_PutChar, "kph " ); // print it to the screen |
| #endif |
| #if SPEED_UNITS == 3 |
| printf ( LCD_PutChar, "mph " ); // print it to the screen |
| #endif |
| } |
| |
| #separate void DisplayHeading ( char cLine ) |
| { |
| long iHdg; |
| |
| #if ( DISPLAY_COLS == 20 ) |
| LCD_SetPosition ( cLine + 8 ); |
| #elif ( DISPLAY_COLS == 16 ) |
| LCD_SetPosition ( cLine + 5 ); |
| #endif |
| iHdg = FieldFiveToLong(); |
| SkipField ( 1 ); // skip fix date |
| GetField(); // MAGNETIC VARIATION |
| iVar = FieldFiveToLong(); // save to global variable, used in other sentences |
| GetField(); // EW |
| cVarDir = cC [ 0 ]; // save direction |
| iHdg = TrueToMag ( iHdg ); // factor variation into heading |
| printf ( LCD_PutChar, "%lu%c ", iHdg, DEGREE ); // pad with blanks |
| } |
| |
| #separate long FieldFiveToLong ( void ) |
| { |
| /* Converts ABC.D to long, rounds decimal up or down */ |
| long iX; |
| |
| iX = 100 * ( long ) ( cC [ 0 ] - 0x30 ); |
| iX += 10 * ( long ) ( cC [ 1 ] - 0x30 ); |
| iX += ( long ) ( cC [ 2 ] - 0x30 ); |
| if ( ( cC [ 3 ] == PERIOD ) && ( cC [ 4 ] >= '5' ) ) |
| { |
| iX++; // round up |
| } |
| return ( iX ); |
| } |
| |
| #separate long TrueToMag ( long iH ) |
| { |
| /* Magnetic variation information comes from the RMC sentence */ |
| |
| if ( cVarDir == 'W' ) |
| { |
| iH += iVar; |
| } |
| else |
| { |
| if ( iH >= iVar ) |
| { |
| iH -= iVar; // OK as-is |
| } |
| else |
| { |
| iH = iH + 360 - iVar; // correct for below zero |
| } |
| } |
| if ( iH >= 360 ) |
| { |
| iH -= 360; |
| } |
| return ( iH ); |
| } |
| |
| #separate void DisplayMessage ( char cMsgNum ) |
| { |
| LCD_PutCmd ( CLEAR_DISP ); |
| LCD_SetPosition ( LINE_2 ); |
| switch ( cMsgNum ) |
| { |
| case WARNING_MSG: |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| printf ( LCD_PutChar, " GPS warning " ); |
| #elif ( DISPLAY_COLS == 16 ) |
| printf ( LCD_PutChar, " GPS warning" ); |
| #endif |
| break; |
| } |
| case NODATA_MSG: |
| { |
| if ( cRxErrorFlag == OFF ) // is it a framing error problem ? |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| printf ( LCD_PutChar, " No data from GPS" ); |
| #elif ( DISPLAY_COLS == 16 ) |
| printf ( LCD_PutChar, "No data from GPS" ); |
| #endif |
| } |
| else |
| { |
| #if ( DISPLAY_COLS == 20 ) |
| printf ( LCD_PutChar, " Baud error" ); |
| #elif ( DISPLAY_COLS == 16 ) |
| printf ( LCD_PutChar, " Baud error" ); |
| #endif |
| cRxErrorFlag = OFF; |
| } |
| break; |
| } |
| } |
| Delay5mS ( 255 ); // delay 1.25 seconds |
| iVar = NULL; |
| cVarDir = SPACE; // signal "no magnetic variation" yet |
| cScreenChanged = YES; |
| } |
| |
| #separate void Delay5mS ( char cCnt ) |
| { |
| char cX; |
| |
| /* This variable-count 5mS delay is interruptable by a button press */ |
| for ( cX = 0; cX < cCnt; cX++ ) |
| { |
| if ( cScreenChanged == YES ) |
| { |
| break; |
| } |
| delay_ms ( 5 ); |
| } |
| } |
| |
| #separate char GetField ( void ) |
| { |
| char cX, cIndex; |
| |
| cX = NULL; |
| cIndex = 0; |
| while ( !cSkip ) |
| { |
| cX = GetRxChar(); |
| if ( ( cX == COMMA ) || ( cX == CR ) ) |
| { |
| break; |
| } |
| cC [ cIndex++ ] = cX; |
| } |
| cC [ cIndex ] = EOF; |
| return ( cIndex ); // return number of characters in field |
| } |
| |
| #separate void SkipField ( char cCnt ) |
| { |
| char cX; |
| |
| for ( cX = 0; cX < cCnt; cX++ ) |
| { |
| while ( GetRxChar() != COMMA ); |
| } |
| } |
| |
| /* RS232 FUNCTIONS ================================================== */ |
| |
| #separate void InitRxBuffer ( char cCode ) |
| { |
| disable_interrupts ( INT_RDA ); |
| cRxBufferWritePtr = cRxBuffer; // point to beginning of buffer |
| cRxBufferReadPtr = cRxBuffer; |
| cRxByteCnt = 0; |
| cRxIsrState = 0; |
| cRxMsgReady = NO; |
| cRxMsgTypeDesired = cCode; |
| enable_interrupts ( INT_RDA ); |
| } |
| |
| #separate char GetRxChar ( void ) |
| { |
| // Get the next available byte in the recv fifo. |
| // Call this function ONLY if the recv fifo contains data. |
| char cValue; |
| |
| cValue = 0; |
| if ( cRxByteCnt > 0 ) // For safety, check if there is any data |
| { |
| cValue = *cRxBufferReadPtr++; // Read byte from fifo |
| if ( cRxBufferReadPtr == ( cRxBuffer + RX_BUFFER_SIZE ) ) // Did tail ptr wrap ? |
| { |
| cRxBufferReadPtr = cRxBuffer; // If so, reset it to start of buffer |
| } |
| cRxByteCnt--; // Decrement byte count |
| } |
| return ( cValue ); |
| } |
| |
| /* LCD FUNCTIONS ================================= */ |
| |
| #separate void LCD_Init ( void ) |
| { |
| LCD_SetData ( 0x00 ); |
| delay_ms ( 200 ); /* wait enough time after Vdd rise */ |
| output_low ( LCD_RS ); |
| LCD_SetData ( 0x03 ); /* init with specific nibbles to start 4-bit mode */ |
| LCD_PulseEnable(); |
| LCD_PulseEnable(); |
| LCD_PulseEnable(); |
| LCD_SetData ( 0x02 ); /* set 4-bit interface */ |
| LCD_PulseEnable(); /* send dual nibbles hereafter, MSN first */ |
| LCD_PutCmd ( 0x2C ); /* function set (all lines, 5x7 characters) */ |
| LCD_PutCmd ( 0x0C ); /* display ON, cursor off, no blink */ |
| LCD_PutCmd ( 0x01 ); /* clear display */ |
| LCD_PutCmd ( 0x06 ); /* entry mode set, increment & scroll left */ |
| } |
| |
| #separate void LCD_SetPosition ( unsigned int cX ) |
| { |
| /* this subroutine works specifically for 4-bit Port A */ |
| LCD_SetData ( swap ( cX ) | 0x08 ); |
| LCD_PulseEnable(); |
| LCD_SetData ( swap ( cX ) ); |
| LCD_PulseEnable(); |
| } |
| |
| #separate void LCD_PutChar ( unsigned int cX ) |
| { |
| /* this subroutine works specifically for 4-bit Port A */ |
| if ( !cSkip ) |
| { |
| output_high ( LCD_RS ); |
| LCD_SetData ( swap ( cX ) ); /* send high nibble */ |
| LCD_PulseEnable(); |
| LCD_SetData ( swap ( cX ) ); /* send low nibble */ |
| LCD_PulseEnable(); |
| output_low ( LCD_RS ); |
| } |
| } |
| |
| #separate void LCD_PutCmd ( unsigned int cX ) |
| { |
| /* this subroutine works specifically for 4-bit Port A */ |
| LCD_SetData ( swap ( cX ) ); /* send high nibble */ |
| LCD_PulseEnable(); |
| LCD_SetData ( swap ( cX ) ); /* send low nibble */ |
| LCD_PulseEnable(); |
| } |
| |
| #separate void LCD_PulseEnable ( void ) |
| { |
| output_high ( LCD_EN ); |
| delay_us ( 3 ); // was 10 |
| output_low ( LCD_EN ); |
| delay_ms ( 3 ); // was 5 |
| } |
| |
| #separate void LCD_SetData ( unsigned int cX ) |
| { |
| output_bit ( LCD_D0, cX & 0x01 ); |
| output_bit ( LCD_D1, cX & 0x02 ); |
| output_bit ( LCD_D2, cX & 0x04 ); |
| output_bit ( LCD_D3, cX & 0x08 ); |
| } |
| |