output.c

Go to the documentation of this file.

    #define     OUTPUT_C

    #include    "output.h"


// Local Variables

static BYTE * _pu8LCD_row;
static BYTE _u8LCD_contrast;
static BYTE _u8LCD_progress;
static BYTE _u8LED_blinking;
static DWORD _u32BlinkTimer;
static DWORD _u32LastProgTime;
volatile WORD _u16LCDTime;
static DWORD _u32DisplayTimer;


// Local function prototypes

static void _writeToLCD(BYTE nValue, BOOL bRAM);
static void _setLCDAddress(BYTE nCol, BYTE nRow);
static void _startLCDTimer(WORD u16WaitValue);
static void _initLCDTimer(void);
static BOOL _isLCDTimerElapsed(void);
void _peripheralTimerISR(void);


// Function implementation

void OutInit(void)
{
    BYTE i = 0;

    // Init values for LCD, see the st7036 datasheet for details.
    BYTE initArray[] = { // Function set: 8 Bit | 2 rows | Inst table 1
                        0x39, 0x39,

                        // BIAS set: 1/5 | 2 rows
                        0x14, 

                        // Follower control: Circuit on | 3,3 V boost
                        0x6D,

                        // Contrast set (low byte), the contrast value is later
                        // ored to by the function _writeToLCD.
                        0x70, 

                        // ICON off | Booster circuit on | Contrast set (high 
                        // byte), later ored to by the function _writeToLCD.
                        0x54, 

                        // Display On | No cursor | No cursor blinkink
                        0x0C, 

                        // Shift of entire display is not performed.
                        0x06, 

                        // Clear display.
                        0x01, 

                        // Function set: 8 Bit | 2 rows | Inst table 0
                        0x38, 

                        // Set CGRAM address to address 0x08.
                        0x48 };

    BYTE patternArray[] = {0x18, 0x04, 0x02, 0x18, 0x1A, 0x1F, 0x1F, 0x0A,
                           0x03, 0x04, 0x08, 0x03, 0x0B, 0x1F, 0x1F, 0x0A,
                           0x00, 0x0E, 0x11, 0x11, 0x11, 0x0E, 0x00, 0x00,
                           0x00, 0x0E, 0x1F, 0x1F, 0x1F, 0x0E, 0x00, 0x00,
                           0x04, 0x0E, 0x1F, 0x04, 0x04, 0x04, 0x04, 0x04,
                           0x04, 0x04, 0x04, 0x04, 0x04, 0x1F, 0x0E, 0x04};

    // Disable analog and comparator module 
    ADCON1 = 0x0F;
    CMCON = 0x07;

    // Initialize PORTF...
    // PORTF.RF0 - Not connected
    // PORTF.RF1 -> LCD_PWR (LCD power supply, high active )
    // PORTF.RF2 -> LCD_RS (select mode at LCD, register or ram access)
    // PORTF.RF3 -> /LCD_CSB (LCD chip select for SPI access)
    // PORTF.RF4 -> LCD_LED (Enables the backlight at LCD)
    // PORTF.RF5 -> /EEPROM_CS (Selects the EEPROM for SPI access, low active)
    // -> Configure the whole port as output.

    PORTF = 0x28;   // Turn off all signals.
    Nop();
    TRISF = 0;      // Configure all bits of PORTF as outputs.
    

    // Initialize PORTB...
    // PORTB.RB0 -> /LED_PWR (LED of the power button, low active)
    // PORTB.RB1 -> /LED_F4 (LED of the F4 button, low active)
    // PORTB.RB2 -> /LED_F3 (LED of the F3 button, low active)
    // PORTB.RB3 -> /LED_F2 (LED of the F2 button, low active)
    // PORTB.RB4 - PORTB.RB7 not used by the display functions.
    // Only the lower 4 Bits of PORTB will be configured as outputs. The other 
    // bits remain unintended.

    PORTB = 0x0F;       // Switch off all the PORTB LEDs.
    Nop();
    TRISB &= 0xF0;  


    // Initialize PORTC...
    // PORTC.RC0 -> /FL_LED (LED of the FL button, low active)
    // PORTC.RC1 -> /F1_LED (LED of the F1 button, low active)
    // PORTC.RC2 -> not connected
    // PORTC.RC3 -> LCD_CLK (SPI clock for communication with the LCD)
    // PORTC.RC4 <- SPI MISO (Not used by LCD)
    // PORTC.RC5 -> LCD_SI (SPI data line to LCD)
    // PORTC.RC6 -> /SEL_LED (LED of the SEL button, low active)
    // PORTC.RC7 -> /ACC_LED (LED of the ACC button, low active)
    // All bits are initialized as outputs, but RC4 is configured as input.

    PORTC = 0xC3;       // Switch off all the PORTB LEDs.
    Nop();
    TRISC = 0x10;

    _u8LED_blinking = 0;


    // Initilaize register for LCD operations:
    lcd_status = 0;
    _pu8LCD_row = 0;
    _u8LCD_progress = 16;

    
    // Set a well known contrast value.
    _u8LCD_contrast = 0x18;


    // The LCD uses an internal timer for all its access routines because the
    // display has no back communication channel and therefore the ouput 
    // routines can not poll the busy flag of the LCD. It simply performs wait
    // cycles before sending the next data to the display.
    _initLCDTimer();

    _startLCDTimer(10); // Wait for stabilized outputs before enabling the LCD.
    while(_isLCDTimerElapsed() == FALSE);

    PORTFbits.RF1 = 1;  // Switch on LCD.


    // Wait some time (ca. 50 ms) before starting the init sequence of the
    // display (internal startup time of the display).
    _startLCDTimer(500);

    // Init sequence
    for (i = 0; i < sizeof(initArray); i++)
    {
        while(_isLCDTimerElapsed() == FALSE);
        _writeToLCD(initArray[i], FALSE);
    }

    // Send new symbols to display. 
    for (i = 0; i <  sizeof(patternArray); i++)
    {
        while(_isLCDTimerElapsed() == FALSE);
        _writeToLCD(patternArray[i], TRUE);
    }

    PORTFbits.RF4 = 1;  // Switch on LCD backlight.
}


void OutTriggerDisplay(void)
{
    _u32DisplayTimer = TickGet();

    if (sPCommonConfig.u8LCDLight == 0xFF)
    {
        OutSwitchLCDBacklight(TRUE);
    }
    else if (sPCommonConfig.u8LCDLight == 0)
    {
        OutSwitchLCDBacklight(FALSE);
    }
    else
    {
        _u32DisplayTimer += sPCommonConfig.u8LCDLight*TICKS_PER_SECOND;
        OutSwitchLCDBacklight(TRUE);
    }
}


void OutMain(void)
{
    if (_u8LED_blinking && (_u32BlinkTimer < TickGet()))
    {
        OutSetLED(_u8LED_blinking, LED_TOGGLE);
        _u32BlinkTimer = TickGet() + LED_BLINK_INTERVAL * TICKS_PER_SECOND;
    }

    // Is the LCD ready (Waiting time over)?
    if (_isLCDTimerElapsed() == FALSE)
    {
        return;
    }

    // If commands for the display are pending, the LCD is busy and therefore
    // the display stays on!
    if (lcd_status)
    {
        OutTriggerDisplay();
    }
    else if ((_u32DisplayTimer < TickGet()) && sPCommonConfig.u8LCDLight)
    {
        OutSwitchLCDBacklight(FALSE);
    }

    // Check the LCD command:   
    if (lcd_status & LCD_CLR_MASK)
    {
        _pu8LCD_row = 0;
        lcd_status &= ~(LCD_CLR_MASK);
        _writeToLCD(0x01, FALSE);
    }
    else if (_pu8LCD_row)
    {
        if (*_pu8LCD_row == 0)
        {
            _pu8LCD_row = 0;
        }
        else
        {   
            _writeToLCD(*_pu8LCD_row, TRUE);
            _pu8LCD_row++;
        }
    }
    else if (lcd_status & LCD_ROW1_MASK)
    {
        lcd_status &= ~LCD_ROW1_MASK;
        if (lcd_status & LCD_CENTER1_MASK)
        {
            lcd_addr1 = (LCD_CHARS_IN_A_ROW - strlen(lcdram_row1))>>1;
            lcd_status &= ~LCD_CENTER1_MASK;
        }
        if (strlen(lcdram_row1) == 0)
        {
            return;
        }
        _pu8LCD_row = lcdram_row1;
        _setLCDAddress(lcd_addr1, 0);
    }
#ifdef LCD_WITH_2_ROWS
    else if (lcd_status & LCD_ROW2_MASK)
    {
        lcd_status &= ~LCD_ROW2_MASK;
        if (lcd_status & LCD_CENTER2_MASK)
        {
            lcd_addr2 = (LCD_CHARS_IN_A_ROW - strlen(lcdram_row2))>>1;
            lcd_status &= ~LCD_CENTER2_MASK;
        }

        if (strlen(lcdram_row2) == 0)
        {
            return;
        }
        _pu8LCD_row = lcdram_row2;
        _u8LCD_progress = strlen(lcdram_row2);
        _u32LastProgTime = TickGet() + LCD_PROGRESS_TIME * TICKS_PER_SECOND;
        _setLCDAddress(lcd_addr2, 1);
    }
#ifdef LCD_WITH_3_ROWS
    else if (lcd_status & LCD_ROW3_MASK)
    {
        lcd_status &= ~LCD_ROW3_MASK;
        // ToDo: Implement.
    }
#endif
#endif
    else if (lcd_status & LCD_CLR_PROG_MASK)
    {
        BYTE i;
        lcd_status &= ~LCD_CLR_PROG_MASK;
    
        for (i = 0; i < 16; i++)
        {
            if (lcdram_row2[i] == '.')
            {
                lcdram_row2[i] = 0;
                lcd_status |= LCD_ROW2_MASK;
                break;
            }
        }
    }
    else if (lcd_status & LCD_PROGRESS_MASK)
    {
        // Is it time for a new character?
        if (_u32LastProgTime < TickGet())
        {
            lcdram_row2[_u8LCD_progress++] = LCD_PROGRESS_CHAR;
            lcdram_row2[_u8LCD_progress] = 0;
            lcd_status |= LCD_ROW2_MASK;
            if (_u8LCD_progress > (15 - lcd_addr2)) 
            {
                lcd_status &= ~LCD_PROGRESS_MASK;
            }
        }
    }
}


#ifdef DEBEXT_MODE

void OutDebugOut(BYTE nValue)
{
    PORTCbits.RC0 = nValue & LED_FL ? 0 : 1;
    PORTCbits.RC1 = nValue & LED_F1 ? 0 : 1;
    PORTBbits.RB3 = nValue & LED_F2 ? 0 : 1;
    PORTBbits.RB2 = nValue & LED_F3 ? 0 : 1;
    PORTBbits.RB1 = nValue & LED_F4 ? 0 : 1;
    PORTBbits.RB0 = nValue & LED_PWR ? 0 : 1;
    PORTCbits.RC7 = nValue & LED_ACC ? 0 : 1;
    PORTCbits.RC6 = nValue & LED_SEL ? 0 : 1;
}

#endif


void OutSwitchOffLCD(void)
{
    PORTF &= 0x2C;
} 


void OutSwitchLCDBacklight(BOOL On)
{
    if (On == FALSE)
    {
        PORTF &= 0x2E;
    }
    else
    {
        PORTF |= 0x10;
    }
} 


BOOL OutIsLCDBusy(void)
{
    if ((_isLCDTimerElapsed() == FALSE) || (lcd_status) || (_pu8LCD_row))
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


void OutEnableCursor(BOOL On)
{
    if (On == TRUE)
    {
        _writeToLCD(0x0E, FALSE);
    }
    else
    {
        _writeToLCD(0x0C, FALSE);
    }
}


void OutSetCursor(BYTE Column, BYTE Row)
{
    _setLCDAddress(Column, Row);
}


void OutSwitchOffAllLEDs(void)
{
    BYTE i;

    for (i = LED_FL; i != 0; i = i<<1)
    {
        OutSetLED(i, LED_OFF);
    }
}


void OutSetLEDMask(BYTE LedMask, BYTE LedSwitchMask)
{
    BYTE setmask = LedMask & LedSwitchMask;
    BYTE clearmask = LedMask & (~LedSwitchMask);
    OutSetLED(setmask, LED_ON);
    OutSetLED(clearmask, LED_OFF);
}


void OutSetLED(BYTE LedMask, eLED_Modes Mode)
{
    BOOL ledOff = TRUE;

    switch(Mode)
    {
    case LED_BLINK:
        _u8LED_blinking |= LedMask;
        _u32BlinkTimer = TickGet() + LED_BLINK_INTERVAL;
        break;

    case LED_ON:
        ledOff = FALSE;
        // Intended fall through

    case LED_OFF:
        _u8LED_blinking &= ~LedMask;

        if (LedMask & LED_FL)
        {
            PORTCbits.RC0 = ledOff;
        }
        if (LedMask & LED_F1)
        {
            PORTCbits.RC1 = ledOff;
        }
        if (LedMask & LED_F2)
        {
            PORTBbits.RB3 = ledOff;
        }
        if (LedMask & LED_F3)
        {
            PORTBbits.RB2 = ledOff;
        }
        if (LedMask & LED_F4)
        {
            PORTBbits.RB1 = ledOff;
        }
        if (LedMask & LED_PWR)
        {
            PORTBbits.RB0 = ledOff;
        }
        if (LedMask & LED_ACC)
        {
            PORTCbits.RC7 = ledOff;
        }       
        if (LedMask & LED_SEL)
        {
            PORTCbits.RC6 = ledOff;
        }
        break;

    case LED_TOGGLE:
        if (LedMask & LED_FL)
        {
            PORTCbits.RC0 = ~PORTCbits.RC0;
        }
        if (LedMask & LED_F1)
        {
            PORTCbits.RC1 = ~PORTCbits.RC1;
        }
        if (LedMask & LED_F2)
        {
            PORTBbits.RB3 = ~PORTBbits.RB3;
        }
        if (LedMask & LED_F3)
        {
            PORTBbits.RB2 = ~PORTBbits.RB2;
        }
        if (LedMask & LED_F4)
        {
            PORTBbits.RB1 = ~PORTBbits.RB1;
        }
        if (LedMask & LED_PWR)
        {
            PORTBbits.RB0 = ~PORTBbits.RB0;
        }
        if (LedMask & LED_ACC)
        {
            PORTCbits.RC7 = ~PORTCbits.RC7; 
        }   
        if (LedMask & LED_SEL)
        {
            PORTCbits.RC6 = ~PORTCbits.RC6; 
        }
    }
}


eLED_Modes OutGetLEDMode(BYTE Led)
{
    BOOL ledOff = TRUE;

    if (_u8LED_blinking & Led)
    {
        return LED_BLINK;
    }

    if (Led & LED_FL)
    {
        ledOff = PORTCbits.RC0;
    }

    if (Led & LED_F1)
    {
        ledOff = PORTCbits.RC1;
    }

    if (Led & LED_F2)
    {
        ledOff = PORTBbits.RB3;
    }

    if (Led & LED_F3)
    {
        ledOff = PORTBbits.RB2;
    }

    if (Led & LED_F4)
    {
        ledOff = PORTBbits.RB1;
    }

    if (Led & LED_PWR)
    {
        ledOff = PORTBbits.RB0;
    }

    if (Led & LED_ACC)
    {
        ledOff = PORTCbits.RC7; 
    }

    if (Led & LED_SEL)
    {
        ledOff = PORTCbits.RC6;
    }

    if (ledOff)
    {
        return LED_OFF;
    }
    else
    {
        return LED_ON;
    }
}


static void _writeToLCD(BYTE nValue, BOOL bRAM)
{
    if (bRAM == FALSE) 
    {
        if ((nValue & 0xF0) == 0x60)
        {
            // Wait 200 ms for stabilizing of the power supply when writing the
            // follower control to display.
            _startLCDTimer(2000);
        }
        else if ((nValue & 0xFC) == 0x00)
        {
            // Return Home and Clear Diplay need ca. 1,08 ms
            _startLCDTimer(11);
        }
        else
        {
            if ((nValue & 0xF0) == 0x70)
            {
                // Oring the low nibble of the contrast value for setting the
                // contrast low byte.
                nValue = 0x70 | (_u8LCD_contrast & 0x0F);
            }
            else if ((nValue & 0xF0) == 0x50)
            {
                nValue &= 0xFC;
                nValue |= (_u8LCD_contrast >> 4) & 0x03;
            }
            _startLCDTimer(1);  // Wait 100 us.
        }
    }
    else
    {
        _startLCDTimer(1);  // Wait 100 us.
    }

    // SPI-Configuration for LCD:
    // SPI Master | Clock = Fosc/64 | Enable | Clock idle state is high 
    SSP1CON1 = 0x32;
    SSP1STAT = 0x00;    // CKE = 0

    PORTFbits.RF2 = bRAM;
    PORTFbits.RF3 = 0;  // Select LCD.
    PIR1bits.SSP1IF = 0;
    SSP1BUF = nValue;   // Write value on SPI bus.

    // Wait until SPI transmission is finished:
    while(PIR1bits.SSP1IF == 0);

    PORTFbits.RF3 = 1;  // Deselect LCD.

    return;
}


static void _setLCDAddress(BYTE nCol, BYTE nRow)
{

#ifdef LCD_WITH_3_ROWS
    nCol &= 0x0F;
    if (nRow == 1)
    {
        nCol |= 0x10;
    }
    else if (nRow == 2)
    {
        nCol |= 0x20;
    }
#endif  

#ifdef LCD_WITH_2_ROWS
    nCol &= 0x3F;
    if (nRow == 1)
    {
        nCol |= 0x40;
    }
#endif

    _writeToLCD(nCol | 0x80, FALSE);
}


static void _initLCDTimer(void)
{
    // Init the 100 us timer:
    T2CON = 0x03;   // Reset timer 2 (8 bit timer, 1:16 Prescaler).
    PR2 = (GetPeripheralClock() * 0.0001) / 16;     // Match register.
    IPR1bits.TMR2IP = 0;    // Low interrupt priority.
    PIE1bits.TMR2IE = 0;    // Disable the interrupt flag.
}


static void _startLCDTimer(WORD u16WaitValue)
{
    PIE1bits.TMR2IE = 0;    // Disable the interrupt.
    _u16LCDTime = u16WaitValue;
    T2CONbits.TMR2ON = 0;   // Stop timer.
    TMR2 = 0;
    PIR1bits.TMR2IF = 0;    // Clearing the compare match interrupt flag.
    PIE1bits.TMR2IE = 1;    // Enable the interrupt.

    T2CONbits.TMR2ON = 1;   // Start timer.
}


static BOOL _isLCDTimerElapsed(void)
{
    if (PIE1bits.TMR2IE == 0)
    {
        return TRUE;
    }
    
    return FALSE;
}


void OutConvertNameForDisplay(BYTE * pString)
{
    BYTE i;
    for (i = 0; i < strlen(pString); i++)
    {
        switch(pString[i])
        {
        case 0xE4:
            pString[i] = '\x84';
            break;

        case 0xFC:
            pString[i] = '\x81';
            break;

        case 0xF6:
            pString[i] = '\x94';
            break;

        case 0xDC:
            pString[i] = '\x9A';
            break;

        case 0xC4:
            pString[i] = '\x8E';
            break;

        case 0xD6:
            pString[i] = '\x99';
            break;
        }
    }
}


void OutInterruptHandler(void)
{
    if (PIR1bits.TMR2IF == 1)
    {
        // Decrement LCD wait time...
        _u16LCDTime--;
    
        if (_u16LCDTime == 0)
        {
            PIE1bits.TMR2IE = 0;    // Time is over, disable interrupt.
            T2CONbits.TMR2ON = 0;   // Disable timer.
        }

        PIR1bits.TMR2IF = 0;    // Clearing the interrupt flag.
    }
}

---