Colony

/*

lcd-ar2.c - implementation for lcd functions

Author: CMU Robotics Club, Colony Project

This uses SPI.

lcd_init MUST be called before anything can be used.

*/

#include <avr/io.h>

#include <lcd.h>

#include <time.h>

#define LCD_RS    PB4 // Command/Data

#define LCD_RSTB  PE2 // reset line

#define LCD_CS    PB0

//////lcd defines

#define RST _BV(4)  // pd4 (GPIO)

#define SCE _BV(0)  // pb0 (~SS)

#define D_C _BV(5)  // pd5 (GPIO?)

#define SDI _BV(2)  // pb2 (MOSI)

#define SCK _BV(1) // pb1 (SCK)

#define LCDPORT PORTB

#define LCDDDR DDRB

#define LCDRESETPORT PORTD

#define LCDRESETDDR DDRD

// Internal Function Prototypes

// inialize OLED and SPI

void OLED_init(void);

// reset Controller

void Reset_SSD1339(void);

// write command or data

void write_c(unsigned char out_command);

void write_d(unsigned char out_data);

// these write data to the OLED on 8 bit data bus,  depends on MCU

void LCD_out(unsigned char cmd);

// these functions set / clear pins for OLED control lines.  they accecpt a 0 or 1 

void DC(char stat);

void RES(char stat);

void CS(char stat);

void lcd_putbyte(unsigned char b);

void crazycircle (void) {

/*  int i;

  // draw 100 random circles

  for(i = 0;i < 100;i++){

      write_c(0x86);    // draw circle command

      write_d(rand() % 130);

      write_d(rand() % 130);

      write_d(rand() % 64);

      write_d(rand());

      write_d(rand());

      write_d(rand());

      write_d(rand());

      delay_ms(10);

  }

*/

}

void OLEDtest (void) {

  //int   i = 0;

  // Initialize

  //Initialize();

  OLED_init();

  delay_ms(120);

  write_c(0x8e);    // clear window command

  write_d(0);

  write_d(0);

  write_d(130);

  write_d(130);

  delay_ms(100);

  write_c(0x92);    // fill enable command

  write_d(0x01); 

  delay_ms(10);

  crazycircle();

/*

  // write directly to ram,  this fills up bottom 1/3 of display with color pattern

  write_c(0x5c);

  for (i = 0; i < 2000; i++){

  write_c(0x5c);  

   write_d(i);

   write_d(i);

   write_d(i);

  }

  */

} 

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

                      Initialize

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

void OLED_init(void)

{

  // Setup SPI here

  SPCR = 0x5D; //  enable SPI, master, SPI mode 3

  DDRB |= 0x06; // enable MOSI and SCK as outputs

  LCD_out(0);

  DC(0);

  CS(0);

  Reset_SSD1339();

  write_c(0xa0); // Set Re-map / Color Depth

  write_d(0x34);//0xb4); // 262K 8bit R->G->B

  write_c(0xa1); // Set display start line

  write_d(0x00); // 00h start

  //write_c(0xa2); // Set display offset

  //write_d(0x80); // 80h start

  write_c(0xA6); // Normal display

  write_c(0xad); // Set Master Configuration

  write_d(0x8e); // DC-DC off & external VcomH voltage & external pre-charge voltage

  write_c(0xb0); // Power saving mode

  write_d(0x05);

  write_c(0xb1); // Set pre & dis_charge

  write_d(0x11); // pre=1h dis=1h

  write_c(0xb3); // clock & frequency

  write_d(0xf0); // clock=Divser+1 frequency=fh

  write_c(0xbb); // Set pre-charge voltage of color A B C

  write_d(0xff); // color A  was 1c

  write_d(0xff); // color B  was 1c

  write_d(0xff); // color C  was 1c

  write_c(0xbe); // Set VcomH

  write_d(0x1f); //

  write_c(0xc1); // Set contrast current for A B C

  write_d(0xCa); // Color A was AA

  write_d(0xD4); // Color B was B4

  write_d(0xF8); // Color C was C8

  write_c(0xc7); // Set master contrast

  write_d(0x0f); // no change

  write_c(0xca); // Duty

  write_d(0x7f); // 127+1

  write_c(0xaf); // Display on

}

void Reset_SSD1339(void)

{

  RES(0);

  delay_ms(100);

  RES(1);

}

void write_c(unsigned char out_command)

{

  DC(0);CS(0);

  //delay_ms(1);

  LCD_out(out_command);

 // delay_ms(1);

  DC(1);

  // potentially add NOP

  CS(1);

}

void write_d(unsigned char out_data)

{

  DC(1);CS(0);

 // delay_ms(1);

  LCD_out(out_data);

 // delay_ms(1);

  DC(1);

  //potentially add NOP

  CS(1);

}

// these functions set / clear pins for LCD control lines.  they accecpt a 0 or 1 

void DC(char stat)

{

        DDRB |= _BV(LCD_RS);                                // RS is P0.30, set to output

        if (stat)        

                PORTB |= _BV(LCD_RS);

        else

                PORTB &= ~(_BV(LCD_RS));

}

void RES(char stat)

{

        DDRE |= _BV(LCD_RSTB);                                // RSTB is P0.7, set to output

        if (stat)        

                PORTE |= _BV(LCD_RSTB);

        else

                PORTE &= ~(_BV(LCD_RSTB));

}

void CS(char stat)

{

        DDRB |= _BV(LCD_CS);                                // RSTB is P0.7, set to output

        if (stat)        

                PORTB |= _BV(LCD_CS);

        else

                PORTB &= ~(_BV(LCD_CS));

}

// send to the LCD

void LCD_out(unsigned char cmd)

{

        SPDR = cmd;

    // could also do this via interrupts

        loop_until_bit_is_set(SPSR, SPIF);

}

//**************************************Old shit below!*****************

/*

FontLookup - a lookup table for all characters

*/

static const unsigned char FontLookup [][5] =

{

    { 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp

    { 0x00, 0x00, 0x5f, 0x00, 0x00 },   // !

    { 0x00, 0x07, 0x00, 0x07, 0x00 },   // "

    { 0x14, 0x7f, 0x14, 0x7f, 0x14 },   // #

    { 0x24, 0x2a, 0x7f, 0x2a, 0x12 },   // $

    { 0x23, 0x13, 0x08, 0x64, 0x62 },   // %

    { 0x36, 0x49, 0x55, 0x22, 0x50 },   // &

    { 0x00, 0x05, 0x03, 0x00, 0x00 },   // '

    { 0x00, 0x1c, 0x22, 0x41, 0x00 },   // (

    { 0x00, 0x41, 0x22, 0x1c, 0x00 },   // )

    { 0x14, 0x08, 0x3E, 0x08, 0x14 },   // *

    { 0x08, 0x08, 0x3E, 0x08, 0x08 },   // +

    { 0x00, 0x00, 0x50, 0x30, 0x00 },   // ,

    { 0x10, 0x10, 0x10, 0x10, 0x10 },   // -

    { 0x00, 0x60, 0x60, 0x00, 0x00 },   // .

    { 0x20, 0x10, 0x08, 0x04, 0x02 },   // /

    { 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0

    { 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1

    { 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2

    { 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3

    { 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4

    { 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5

    { 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6

    { 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7

    { 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8

    { 0x06, 0x49, 0x49, 0x29, 0x1E },   // 9

    { 0x00, 0x36, 0x36, 0x00, 0x00 },   // :

    { 0x00, 0x56, 0x36, 0x00, 0x00 },   // ;

    { 0x08, 0x14, 0x22, 0x41, 0x00 },   // <

    { 0x14, 0x14, 0x14, 0x14, 0x14 },   // =

    { 0x00, 0x41, 0x22, 0x14, 0x08 },   // >

    { 0x02, 0x01, 0x51, 0x09, 0x06 },   // ?

    { 0x32, 0x49, 0x59, 0x51, 0x3E },   // @

    { 0x7E, 0x11, 0x11, 0x11, 0x7E },   // A

    { 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B

    { 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C

    { 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D

    { 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E

    { 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F

    { 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G

    { 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H

    { 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I

    { 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J

    { 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K

    { 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L

    { 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M

    { 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N

    { 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O

    { 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P

    { 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q

    { 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R

    { 0x46, 0x49, 0x49, 0x49, 0x31 },   // S

    { 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T

    { 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U

    { 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V

    { 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W

    { 0x63, 0x14, 0x08, 0x14, 0x63 },   // X

    { 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y

    { 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z

    { 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [

    { 0x02, 0x04, 0x08, 0x10, 0x20 },   // backslash

    { 0x00, 0x41, 0x41, 0x7F, 0x00 },   // ]

    { 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^

    { 0x40, 0x40, 0x40, 0x40, 0x40 },   // _

    { 0x00, 0x01, 0x02, 0x04, 0x00 },   // '

    { 0x20, 0x54, 0x54, 0x54, 0x78 },   // a

    { 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b

    { 0x38, 0x44, 0x44, 0x44, 0x20 },   // c

    { 0x38, 0x44, 0x44, 0x48, 0x7F },   // d

    { 0x38, 0x54, 0x54, 0x54, 0x18 },   // e

    { 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f

    { 0x0C, 0x52, 0x52, 0x52, 0x3E },   // g

    { 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h

    { 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i

    { 0x20, 0x40, 0x44, 0x3D, 0x00 },   // j

    { 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k

    { 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l

    { 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m

    { 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n

    { 0x38, 0x44, 0x44, 0x44, 0x38 },   // o

    { 0x7C, 0x14, 0x14, 0x14, 0x08 },   // p

    { 0x08, 0x14, 0x14, 0x18, 0x7C },   // q

    { 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r

    { 0x48, 0x54, 0x54, 0x54, 0x20 },   // s

    { 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t

    { 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u

    { 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v

    { 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w

    { 0x44, 0x28, 0x10, 0x28, 0x44 },   // x

    { 0x0C, 0x50, 0x50, 0x50, 0x3C },   // y

    { 0x44, 0x64, 0x54, 0x4C, 0x44 },    // z

    { 0x00, 0x08, 0x36, 0x41, 0x41 },   // {

    { 0x00, 0x00, 0x7F, 0x00, 0x00 },   // |

    { 0x41, 0x41, 0x36, 0x08, 0x00 },   // }

    { 0x02, 0x01, 0x01, 0x02, 0x01 },   // ~

    { 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // del

};

/**

 * @defgroup lcd LCD

 * @brief Functions for the LCD

 * Functions for writing to the LCD.

 * All functions may be found in lcd.h.

 *

 * @{

 **/

/**

 * Initializes the LCD. Must be called before any other

 * LCD functions.

 **/

void lcd_init(void)

{

        LCDDDR |= (SCE | SDI | SCK);

        LCDRESETDDR |= (RST|D_C);

        LCDPORT &= ~( SCE | SDI | SCK);

        LCDRESETPORT &=~(D_C);

        SPCR |= 0x50;//0b01010000; // no SPI int, SPI en, Master, sample on rising edge, fosc/2

        SPSR |= 0x01;       // a continuation of the above

        LCDRESETPORT |= RST;

        delay_ms(10);

        LCDRESETPORT &= (~RST);

        delay_ms(100);

        LCDRESETPORT |= RST;

    lcd_putbyte( 0x21 );  // LCD Extended Commands.

    lcd_putbyte( 0xC8 );  // Set LCD Vop (Contrast).

    lcd_putbyte( 0x06 );  // Set Temp coefficent.

    lcd_putbyte( 0x13 );  // LCD bias mode 1:48.

    lcd_putbyte( 0x20 );  // LCD Standard Commands, Horizontal addressing mode.

    lcd_putbyte( 0x0C );  // LCD in normal mode.

        LCDRESETPORT |= D_C;                //put it in init instead of main

        lcd_clear_screen();

}

/**

 * Clears the LCD screen. lcd_init must be called first.

 * 

 * @see lcd_init

 **/

void lcd_clear_screen( void ) {

        int i;

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

                        lcd_putbyte(0x0);

        lcd_gotoxy(0,0);

}

/**

 * Prints a character on the LCD screen. lcd_init

 * must be called before this function may be used.

 *

 * @param c the character to print

 *

 * @see lcd_init

 **/

void lcd_putc(char c)

{

        int i;

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

                lcd_putbyte(FontLookup[c-32][i]);

        lcd_putbyte(0);

}

/*

print an entire string to the lcd

*/

void lcd_puts(char *s)

{

        char *t = s;

        while (*t != 0)

        {

                lcd_putc(*t);

                t++;

        }

}

/*

go to coordinate x, y

y: vertically - 1 char

x: horizontally - 1 pixel

multiply x by 6 if want to move 1 entire character

origin (0,0) is at top left corner of lcd screen

*/

/**

 * Move the current cursor position to the one specified.

 * lcd_init must be called before this function may be used.

 * 

 * @param x The x coordinate of the new position

 * @param y The y coordinate of the new position

 *

 * @see lcd_init

 **/

void lcd_gotoxy(int x, int y)

{

  LCDRESETPORT &= ~(D_C);

  lcd_putbyte(0x40 | (y & 0x07));

  lcd_putbyte(0x80 | (x & 0x7f));

  LCDRESETPORT |= D_C;

}

/*

prints an int to the lcd

code adapted from Chris Efstathiou's code (hendrix@otenet.gr)

*/

/**

 * Print an integer to the LCD screen.

 * lcd_init must be called before this function may be used.

 * 

 * @param value the integer to print

 *

 * @see lcd_init

 **/

void lcd_puti(int value ) {

        unsigned char lcd_data[6]={'0','0','0','0','0','0' }, position=sizeof(lcd_data), radix=10; 

        /* convert int to ascii  */ 

        if(value<0) { lcd_putc('-'); value=-value; }    

        do { position--; *(lcd_data+position)=(value%radix)+'0'; value/=radix;  } while(value); 

        /* start displaying the number */

        for(;position<=(sizeof(lcd_data)-1);position++)

          {

            lcd_putc(lcd_data[position]);

          }

        return;

}

/** @} **/ //end defgroup

void lcd_putbyte(unsigned char b)

{

        SPDR = b;

        while (!(SPSR & 0x80)); /* Wait until SPI transaction is complete */

}