Subversion Repositories Projects

/*****************************************************************************

 *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *

 *   - original LCD control by Thomas "thkais" Kaiser                        *

 *   - special number formating routines taken from C-OSD                    *

 *      from Claas Anders "CaScAdE" Rathje                                   *

 *   - some extension, ellipse and circ_line by Peter "woggle" Mack          *

 *                                                                           *

 *   This program is free software; you can redistribute it and/or modify    *

 *   it under the terms of the GNU General Public License as published by    *

 *   the Free Software Foundation; either version 2 of the License.          *

 *                                                                           *

 *   This program is distributed in the hope that it will be useful,         *

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *

 *   GNU General Public License for more details.                            *

 *                                                                           *

 *   You should have received a copy of the GNU General Public License       *

 *   along with this program; if not, write to the                           *

 *   Free Software Foundation, Inc.,                                         *

 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *

 *                                                                           *

 *****************************************************************************/

//############################################################################

//# HISTORY  lcd.c

//#

//# 07.03.2013 OG

//# - del: Kompatibilitaetsfunktion lcd_printpj_at() entfernt

//#

//# 06.03.2013 OG

//# - lcdx_putc() wurde erweitert mit Unterstuetzung des 8x8 Font (alte Jeti 

//#   Funktionen) und Pixel-Verschiebung (xoffs,yoffs)

//# - etliche Char basierte Funktionen wurden erweitert um Parameter xoffs,yoffs

//#   um die Ausgabe um +/- Pixel zu verschieben. Fuer Pixelgenaue Positionierung

//#   von OSD-Screen Elementen.

//#   Die neuen Funktionen mit Pixel-Verschiebung beginnen mit lcdx_, writex_ ...

//# - add: Kompatibilitaet gewaehrleistet durch Mapper-Funktionen

//# - add: defines fuer Char-Drawmode's (MNORMAL, MINVERS, MBIG, MBIGINVERS)

//# - del: Jeti-Funktionen (teilweise ersetzt durch Kompatibilitaetsfunktionen)

//############################################################################

#include "../cpu.h"

#include <avr/io.h>

#include <avr/pgmspace.h>

#include <util/delay.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include "font8x6.h"

#include "Font8x8.h"

#include "../eeprom/eeprom.h"

#include "lcd.h"

#include "../main.h"

#include "../HAL_HW3_9.h"

#define DISP_W 128

#define DISP_H 64

#define DISP_BUFFER ((DISP_H * DISP_W) / 8)

#define LINE_BUFFER (((DISP_H/8) * DISP_W) / 8)

#define Jeti 1  // Jeti Routinen

volatile uint8_t display_buffer[DISP_BUFFER];   // Display-Puffer, weil nicht zurückgelesen werden kann

volatile uint8_t line_buffer[LINE_BUFFER];              // Zeilen-Puffer, weil nicht zurückgelesen werden kann

volatile uint16_t display_buffer_pointer;               // Pointer auf das aktuell übertragene Byte

volatile uint8_t display_buffer_counter;                // Hilfszähler zur Selektierung der Page

volatile uint8_t display_page_counter;                  // aktuelle Page-Nummer

volatile uint8_t display_mode;                                  // Modus für State-Machine

volatile uint8_t LCD_ORIENTATION;

// DOG: 128 x 64 with 6x8 Font => 21 x 8

// MAX7456: 30 x 16

uint8_t lcd_xpos;

uint8_t lcd_ypos;

        char s[7];

//-----------------------------------------------------------

void send_byte (uint8_t data)

{

        clr_cs ();

        SPDR = data;

        while (!(SPSR & (1<<SPIF)));

        //SPSR = SPSR;

        set_cs ();

}

//-----------------------------------------------------------

// * Writes one command byte

// * cmd           - the command byte

//

void lcd_command(uint8_t cmd)

{

//      LCD_SELECT();

//      LCD_CMD();

//      spi_write(cmd);

//      LCD_UNSELECT();

        clr_cs ();

        SPDR = cmd;

        while (!(SPSR & (1<<SPIF)));

        //SPSR = SPSR;

        set_cs ();

}

//-----------------------------------------------------------

void lcd_cls (void)

{

        uint16_t i, j;

//      memset (display_buffer, 0, 1024);

        for (i = 0; i < DISP_BUFFER; i++)

                display_buffer[i] = 0x00;

        for (i = 0; i < 8; i++)

        {

                clr_A0 ();

                send_byte (0xB0 + i);                   //1011xxxx

                send_byte (0x10);                               //00010000

//              send_byte(0x04);                                //00000100 gedreht plus 4 Byte

//              send_byte(0x00);                                //00000000

                send_byte (LCD_ORIENTATION);    //00000000

                set_A0 ();

                for (j = 0; j < 128; j++)

                        send_byte (0x00);

        }

        lcd_xpos = 0;

        lcd_ypos = 0;

}

//-----------------------------------------------------------

void set_adress (uint16_t adress, uint8_t data)

{

        uint8_t page;

        uint8_t column;

        page = adress >> 7;

        clr_A0 ();

        send_byte (0xB0 + page);

        column = (adress & 0x7F) + LCD_ORIENTATION;

        send_byte (0x10 + (column >> 4));

        send_byte (column & 0x0F);

        set_A0 ();

        send_byte (data);

}

//-----------------------------------------------------------

void scroll (void)

{

        uint16_t adress;

        for (adress = 0; adress < 896; adress++)

        {

                display_buffer[adress] = display_buffer[adress + 128];

                set_adress (adress, display_buffer[adress]);

        }

        for (adress = 896; adress < 1024; adress++)

        {

                display_buffer[adress] = 0;

                set_adress (adress, 0);

        }

}

//####################################################################################

//####################################################################################

//-----------------------------------------------------------

// + Plot (set one Pixel)

//-----------------------------------------------------------

// mode:

// 0=Clear, 1=Set, 2=XOR

void lcd_plot (uint8_t xpos, uint8_t ypos, uint8_t mode)

{

        uint16_t adress;

        uint8_t mask;

        if ((xpos < DISP_W) && (ypos < DISP_H))

        {

                adress = (ypos / 8) * DISP_W + xpos;            // adress = 0/8 * 128 + 0   = 0

                mask = 1 << (ypos & 0x07);                                      // mask = 1<<0 = 1

                adress &= DISP_BUFFER - 1;

                switch (mode)

                {

                case 0:

                        display_buffer[adress] &= ~mask;

                        break;

                case 1:

                        display_buffer[adress] |= mask;

                        break;

                case 2:

                        display_buffer[adress] ^= mask;

                        break;

                }

                set_adress (adress, display_buffer[adress]);

        }

}

//-----------------------------------------------------------

//-----------------------------------------------------------

void lcdx_putc( uint8_t x, uint8_t y, uint8_t c, uint8_t mode, int8_t xoffs, int8_t yoffs )

{

        uint8_t ch;

        uint16_t adress;

        uint8_t x1,y1;

        uint8_t x0,y0;

        uint8_t xw;

        uint8_t mask;

        uint8_t bit;

        uint8_t *font;

    //------------------------

    // char translate

    //------------------------

        switch (c)

    {   // ISO 8859-1

        case 0xc4: c = 0x01; break;             // Ä

        case 0xe4: c = 0x02; break;             // ä

        case 0xd6: c = 0x03; break;             // Ö

        case 0xf6: c = 0x04; break;             // ö

        case 0xdc: c = 0x05; break;             // Ü

        case 0xfc: c = 0x06; break;             // ü

        case 0xdf: c = 0x1e; break;             // ß   c = 0x07;  ° (used by Jeti)

        }

    c &= 0x7f;

    //------------------------

    // Font Parameter setzen

    //------------------------

    if( mode <=2 )              // normaler font (8x6)

    {

        font = (uint8_t *) &font8x6[0][0];

        xw   = 6;

    }

    else                                // grosser font (8x8)

    {

        font = (uint8_t *) &Font8x8[0][0];

        xw   = 8;

    }

    //------------------------

    //------------------------

    x0 = (x*xw) + xoffs;

    y0 = (y*8)  + yoffs;

    if( yoffs == 0)

    {

                //----------------------------------------------------------

        // orginaler Character Algo

        //

        // funktioniert auch mit x Verschiebung aber nicht

        // mit y Verschiebung.

        //

        // Da 8 Bit aufeinmal gesetzt werden ist dieser Algo

        // bzgl. Geschwindigkeit effektiver als der Y-Algo.

                //----------------------------------------------------------

                if( mode==MINVERS || mode==MBIGINVERS )

                        lcd_frect( (x*xw)+xoffs, (y*8), xw-1, 7, 1); // invertierte Darstellung

                adress = y * 128 + x * xw + xoffs;

        adress &= 0x3FF;

        for( x1 = 0; x1 < xw; x1++)

        {

            ch = pgm_read_byte (font + x1 + c * xw);

                        if( mode==MINVERS || mode==MBIGINVERS )

                                display_buffer[adress + x1] ^= ch;

                        else

                                display_buffer[adress + x1] = ch;

            set_adress (adress + x1, display_buffer[adress + x1]);

        }      

        }

        else

        {

                //----------------------------------------------------------

                // Y-Algo

        // neuer Character Algo (nur wenn Pixel y-Verschiebung)

                //----------------------------------------------------------

                for( x1 = 0; x1 < xw; x1++ )

                {

                ch = pgm_read_byte (font + x1 + c * xw);

                        mask = 1;

                        for( y1 = 0; y1 < 8; y1++ )

                        {

                                bit = (ch & mask);

                                if( bit )

                                        lcd_plot( x0+x1, y0+y1, ( (mode==MINVERS || mode==MBIGINVERS) ? 0 : 1) );

                                else   

                                        lcd_plot( x0+x1, y0+y1, ( (mode==MINVERS || mode==MBIGINVERS) ? 1 : 0) );

                                mask = (mask << 1);

                        }              

                }              

        }

}

//-----------------------------------------------------------

//--- Kompatibilitaet

//-----------------------------------------------------------

void lcd_putc( uint8_t x, uint8_t y, uint8_t c, uint8_t mode )

{

        lcdx_putc( x, y, c, mode, 0,0 );

}

//####################################################################################

//####################################################################################

//-----------------------------------------------------------

void lcd_cls_line (uint8_t x, uint8_t y, uint8_t w)

{

        uint8_t lcd_width;

        uint8_t lcd_zpos;

        uint8_t i;

        uint8_t max = 21;

        lcd_width = w;

        lcd_xpos = x;

        lcd_ypos = y;

        if ((lcd_xpos + lcd_width) > max)

                lcd_width = max - lcd_xpos;

        lcd_zpos = lcd_xpos + lcd_width;

        for (i = lcd_xpos; i < lcd_zpos; i++)

                lcd_putc (i, lcd_ypos, 0x20, 0);

}

//-----------------------------------------------------------

void wait_1ms (void)

{

        _delay_ms (1);

}

//-----------------------------------------------------------

void wait_ms (uint16_t time)

{

        uint16_t i;

        for (i = 0; i < time; i++)

                wait_1ms ();

}

//-----------------------------------------------------------

void LCD_Init (uint8_t LCD_Mode)        // LCD_Mode 0= Default Mode 1= EEPROM-Parameter)

{

        lcd_xpos = 0;

        lcd_ypos = 0;

//      DDRB = 0xFF;

        // SPI max. speed

        // the DOGM128 lcd controller can work at 20 MHz

        SPCR = (1 << SPE) | (1 << MSTR) | (1 << CPHA) | (1 << CPOL);

        SPSR = (1 << SPI2X);

        set_cs ();

        clr_reset ();

        wait_ms (10);

        set_reset ();

        clr_cs ();

        clr_A0 ();

        send_byte (0x40);               //Display start line = 0

        if (LCD_Mode == 1)

        {

                if (LCD_ORIENTATION == 0)

                {

                        send_byte (0xA1); // A1 normal A0 reverse(original)

                        send_byte (0xC0); // C0 normal C8 reverse(original)

                }

                else

                {

                        send_byte (0xA0); // A1 normal A0 reverse(original)

                        send_byte (0xC8); // C0 normal C8 reverse(original)

                }

        }

        else

        {

                send_byte (0xA1); // A1 normal A0 reverse(original)

                send_byte (0xC0); // C0 normal C8 reverse(original)

        }

        if (LCD_Mode == 1)

        {

                if (Config.LCD_DisplayMode == 0)

                        send_byte (0xA6);               //Display normal, not mirrored

                else

                        send_byte (0xA7);               //Display reverse, not mirrored

        }

        else

                send_byte (0xA6);

        send_byte (0xA2);               //Set bias 1/9 (Duty 1/65)

        send_byte (0x2F);               //Booster, regulator and follower on

        send_byte (0xF8);               //Set internal booster to 4x

        send_byte (0x00);               //Set internal booster to 4x

        send_byte (0x27);               //resistor ratio set

        if (LCD_Mode == 1)

        {

                send_byte (0x81);               //Electronic volume     register set

                send_byte (Config.LCD_Kontrast);                //Electronic volume     register set

        }

        else

        {

                send_byte (0x81);

                send_byte (0x16);

        }

        send_byte (0xAC);               //Cursor

        send_byte (0x00);               //No Cursor

        send_byte (0xAF);               //No indicator

        if (Config.HWSound==0)

          {

            if (LCD_Mode == 1)

            {

                    // Helligkeit setzen

                    OCR2A = Config.LCD_Helligkeit * 2.55;

            }

            else

            {

                    OCR2A = 255;

            }

          }

        lcd_cls ();

}

//-----------------------------------------------------------

// sicher eine Zeile für die Statusanzeige

void copy_line (uint8_t y)

{

        uint8_t i;

        uint16_t adress;

        adress = y * 128 + 0 * 6;

        adress &= 0x3FF;

        for (i = 0; i < 6*21; i++)

        {

                line_buffer[i] = display_buffer[adress+i];

                set_adress (adress + i, display_buffer[adress + i]);

        }

}

//-----------------------------------------------------------

// holt gesicherte Zeile wieder zurück

void paste_line (uint8_t y)

{

        uint8_t i;

        uint16_t adress;

        adress = y * 128 + 0 * 6;

        adress &= 0x3FF;

        for (i = 0; i < 6*21; i++)

        {

                display_buffer[adress+i] =line_buffer[i];

                set_adress (adress + i, display_buffer[adress + i]);

        }

}

//-----------------------------------------------------------

//-----------------------------------------------------------

void lcdx_puts_at( uint8_t x, uint8_t y, const char *s, uint8_t mode, int8_t xoffs, int8_t yoffs)

{

        while (*s)

        {

                lcdx_putc(x, y, *s++, mode, xoffs,yoffs);

                x++;

        }

}/* lcd_puts */

//-----------------------------------------------------------

//-----------------------------------------------------------

void lcd_puts_at( uint8_t x, uint8_t y, const char *s, uint8_t mode )

{

  lcdx_puts_at( x, y, s, mode, 0,0 );

}

//-----------------------------------------------------------

void new_line (void)

{

        lcd_ypos++;

        if (lcd_ypos > 7)

        {

                scroll ();

                lcd_ypos = 7;

        }

}

//-----------------------------------------------------------

void lcd_printpns (const char *text, uint8_t mode)

{

        while (pgm_read_byte(text))

        {

                switch (pgm_read_byte(text))

                {

                case 0x0D:

                        lcd_xpos = 0;

                        break;

                case 0x0A:

                        new_line();

                        break;

                default:

                        lcd_putc (lcd_xpos, lcd_ypos, pgm_read_byte(text), mode);

                        lcd_xpos++;

                        if (lcd_xpos > 21)

                        {

                                lcd_xpos = 0;

//                              new_line ();

                        }

                        break;

                }

                text++;

        }

}

//-----------------------------------------------------------

void lcd_printpns_at (uint8_t x, uint8_t y, const char *text, uint8_t mode)

{

        lcd_xpos = x;

        lcd_ypos = y;

        lcd_printpns (text, mode);

}

//-----------------------------------------------------------

//-----------------------------------------------------------

void lcdx_printp (const char *text, uint8_t mode, int8_t xoffs, int8_t yoffs)

{

        while( pgm_read_byte(text) )

        {

                switch (pgm_read_byte(text))

                {

                case 0x0D:

                        lcd_xpos = 0;

                        break;

                case 0x0A:

                        new_line();

                        break;

                default:

                        lcdx_putc (lcd_xpos, lcd_ypos, pgm_read_byte(text), mode, xoffs,yoffs);

                        lcd_xpos++;

                        if (lcd_xpos > 21)

                        {

                                lcd_xpos = 0;

                                new_line ();

                        }

                        break;

                }

                text++;

        }

}

//-----------------------------------------------------------

//-----------------------------------------------------------

void lcd_printp (const char *text, uint8_t mode)

{

        lcdx_printp ( text, mode, 0,0);

}

//-----------------------------------------------------------

//-----------------------------------------------------------

void lcdx_printp_at (uint8_t x, uint8_t y, const char *text, uint8_t mode, int8_t xoffs, int8_t yoffs)

{

        lcd_xpos = x;

        lcd_ypos = y;

        lcdx_printp (text, mode, xoffs,yoffs);

}

//-----------------------------------------------------------

//-----------------------------------------------------------

void lcd_printp_at (uint8_t x, uint8_t y, const char *text, uint8_t mode)

{

        lcdx_printp_at ( x, y, text, mode, 0,0);

}

//-----------------------------------------------------------

void lcdx_print (uint8_t *text, uint8_t mode, int8_t xoffs, int8_t yoffs)

{

        while (*text)

        {

                switch (*text)

                {

                case 0x0D:

                        lcd_xpos = 0;

                        break;

                case 0x0A:

                        new_line();

                        break;

                default:

                        lcdx_putc (lcd_xpos, lcd_ypos, *text, mode, xoffs,yoffs);

                        lcd_xpos++;

                        if (lcd_xpos > 21)

                        {

                                lcd_xpos = 0;

                                new_line ();

                        }

                        break;

                }

                text++;

        }

}

//-----------------------------------------------------------

//--- lcd_print: Kompatibilitaet

//-----------------------------------------------------------

void lcd_print (uint8_t *text, uint8_t mode )

{

        lcdx_print (text, mode, 0,0 );

}

//-----------------------------------------------------------

void lcdx_print_at (uint8_t x, uint8_t y, uint8_t *text, uint8_t mode, int8_t xoffs, int8_t yoffs)

{

        lcd_xpos = x;

        lcd_ypos = y;

        lcdx_print (text, mode, xoffs, yoffs);

}

//-----------------------------------------------------------

//--- lcd_print_at: Kompatibilitaet

//-----------------------------------------------------------

void lcd_print_at (uint8_t x, uint8_t y, uint8_t *text, uint8_t mode )

{

        lcdx_print_at ( x, y, text, mode, 0,0);

}

//-----------------------------------------------------------

void print_display (uint8_t *text)

{

        while (*text)

        {

                lcd_putc (lcd_xpos, lcd_ypos, *text, 0);

                lcd_xpos++;

                if (lcd_xpos >= 20)

                {

                        lcd_xpos = 0;

                        new_line ();

                }

                text++;

        }

}

//-----------------------------------------------------------

void print_display_at (uint8_t x, uint8_t y, uint8_t *text)

{

        lcd_xpos = x;

        lcd_ypos = y;

        print_display (text);

}

//-----------------------------------------------------------

// + Line (draws a line from x1,y1 to x2,y2

// + Based on Bresenham line-Algorithm

// + found in the internet, modified by thkais 2007

//-----------------------------------------------------------

void lcd_line (unsigned char x1, unsigned char y1, unsigned char x2, unsigned char y2, uint8_t mode)

{

        int x, y, count, xs, ys, xm, ym;

        x = (int) x1;

        y = (int) y1;

        xs = (int) x2 - (int) x1;

        ys = (int) y2 - (int) y1;

        if (xs < 0)

                xm = -1;

        else

                if (xs > 0)

                        xm = 1;

                else

                        xm = 0;

        if (ys < 0)

                ym = -1;

        else

                if (ys > 0)

                        ym = 1;

                else

                        ym = 0;

        if (xs < 0)

                xs = -xs;

        if (ys < 0)

                ys = -ys;

        lcd_plot ((unsigned char) x, (unsigned char) y, mode);

        if (xs > ys) // Flat Line <45 degrees

        {

                count = -(xs / 2);

                while (x != x2)

                {

                        count = count + ys;

                        x = x + xm;

                        if (count > 0)

                        {

                                y = y + ym;

                                count = count - xs;

                        }

                        lcd_plot ((unsigned char) x, (unsigned char) y, mode);

                }

        }

        else // Line >=45 degrees

        {

                count =- (ys / 2);

                while (y != y2)

                {

                        count = count + xs;

                        y = y + ym;

                        if (count > 0)

                        {

                                x = x + xm;

                                count = count - ys;

                        }

                        lcd_plot ((unsigned char) x, (unsigned char) y, mode);

                }

        }

}

//-----------------------------------------------------------

// + Filled rectangle

// + x1, y1 = upper left corner

//-----------------------------------------------------------

void lcd_frect (uint8_t x1, uint8_t y1, uint8_t widthx, uint8_t widthy, uint8_t mode)

{

        uint16_t x2, y2;

        uint16_t i;

        if (x1 >= DISP_W)

                x1 = DISP_W - 1;

        if (y1 >= DISP_H)

                y1 = DISP_H - 1;

        x2 = x1 + widthx;

        y2 = y1 + widthy;

        if (x2 > DISP_W)

                x2 = DISP_W;

        if (y2 > DISP_H)

                y2 = DISP_H;

        for (i = y1; i <= y2; i++)

        {

                lcd_line (x1, i, x2, i, mode);

        }

}

//-----------------------------------------------------------

// + outline of rectangle

// + x1, y1 = upper left corner

//-----------------------------------------------------------

void lcd_rect (uint8_t x1, uint8_t y1, uint8_t widthx, uint8_t widthy, uint8_t mode)

{

        uint16_t x2, y2;