#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <err.h>
#include <errno.h>
#include <string.h>
#include <math.h>
#include <time.h>

#include <sys/ioctl.h>
#include <sys/gpio.h>
#include <dev/spi/spi_io.h>

#define GPIO "/dev/gpio0"
#define PIN_RESET   12
#define PIN_SELECT  25

#define SPI "/dev/spi0"
#define MODE 3
#define ADDR 0

#define _X(a,b) ((a)?(b):0)

/* table 0 */
#define CLEAR_DISPLAY 1
#define RETURN_HOME 2
#define ENTRY_MODE_SET(id,s) (0x04 | ((id)?2:0) | ((s)?1:0))
#define DISPLAY_ONOFF(d,c,b) (0x08 | _X(d,4) | _X(c,2) | _X(b,1))
#define CURSOR_OR_DISPLAY_SHIFT(sc,rl) (0x10 | _X(sc,8) | _X(rl,4))
#define FUNCTION_SET(dl,n,dh,is) (0x20 | _X(dl,16) | _X(n,8) | _X(dh,4) | ((is) & 0x3))
#define SET_CGRAM(ac) (0x40 | ((ac) & 0x3f))
#define SET_DDRAM(ac) (0x80 | ((ac) & 0x7f))

/* table 1 */
#define BIAS_SET(bs,fx) (0x10 | _X(bs,8) | _X(fx,1))
#define SET_IRAM(ac) (0x40 | ((ac) & 0xf))
#define POWER_SET(ion,bon,c) (0x50 | _X(ion,8) | _X(bon,4) | (((c)>>4)&0x3))
#define FOLLOWER_CONTROL(fon,rab) (0x60 | _X(fon,8) | ((rab) & 0x7))
#define CONTRAST_SET(c) (0x70 | ((c) & 0xf))

/* table 2 */
#define DOUBLE_HEIGHT(ud) (0x10 | _X(ud,8))

typedef struct {
       int gfd;
       int sfd;

       int select_pin;
       int reset_pin;
       int rows;
       int columns;
       int addr;

       int enabled;
       int cursor;
       int blink;
       int dbl;
} lcd_t;

void
delay(double seconds)
{
       unsigned hz = 100;
       unsigned micros = 1000000u / hz;
       useconds_t ticks = ceil(seconds * hz);

       usleep(ticks * micros);
}

int
gpio_set(int fd, int pin, int val)
{
       struct gpio_req gp;

       gp.gp_name[0] = '\0';
       gp.gp_pin = pin;
       gp.gp_value = val;

       if (ioctl(fd, GPIOWRITE, &gp) == -1)
               return errno;
       return 0;
}

int
spi_configure(int fd, int addr, uint32_t mode, uint32_t speed)
{
       spi_ioctl_configure_t sic;

       sic.sic_addr = addr;
       sic.sic_mode = mode;
       sic.sic_speed = speed;

       if (ioctl(fd, SPI_IOCTL_CONFIGURE, &sic) == -1)
               return errno;
       return 0;
}

int
spi_transfer(int fd, int addr, void *send, size_t slen, void *recv, size_t rlen)
{
       spi_ioctl_transfer_t sit;

       sit.sit_addr = addr;
       sit.sit_send = send;
       sit.sit_sendlen = slen;
       sit.sit_recv = recv;
       sit.sit_recvlen = rlen;

       if (ioctl(fd, SPI_IOCTL_TRANSFER, &sit) == -1)
               return errno;
       return 0;
}

int
read_busy(lcd_t *lcd)
{
       uint8_t buf;

       spi_transfer(lcd->sfd, lcd->addr, NULL, 0, &buf, 1);

       return (int)buf;
}

void
write_char(lcd_t *lcd, uint8_t c)
{
       gpio_set(lcd->gfd, lcd->select_pin, GPIO_PIN_HIGH);
       spi_transfer(lcd->sfd, lcd->addr, &c, 1, NULL, 0);
       delay(50e-6);
}

void
write_string(lcd_t *lcd, uint8_t *s)
{
       gpio_set(lcd->gfd, lcd->select_pin, GPIO_PIN_HIGH);
       while (*s) {
               spi_transfer(lcd->sfd, lcd->addr, s++, 1, NULL, 0);
               delay(30e-6);
       }
}

void
write_instruction_set(lcd_t *lcd, int set)
{
       uint8_t cmd = FUNCTION_SET(1, 1, lcd->dbl, set);

       gpio_set(lcd->gfd, lcd->select_pin, GPIO_PIN_LOW);
       spi_transfer(lcd->sfd, lcd->addr, &cmd, 1, NULL, 0);
       delay(30e-6);
}

void
write_command(lcd_t *lcd, uint8_t cmd, int set)
{

       gpio_set(lcd->gfd, lcd->select_pin, GPIO_PIN_LOW);
       write_instruction_set(lcd, set);
       spi_transfer(lcd->sfd, lcd->addr, &cmd, 1, NULL, 0);
       delay(30e-6);
}

void
update_display_mode(lcd_t *lcd)
{
       write_command(lcd,
               DISPLAY_ONOFF(lcd->enabled,lcd->cursor,lcd->blink),
               0);
       write_command(lcd,
               DOUBLE_HEIGHT(lcd->dbl >> 1),
               2);
}

void
set_bias(lcd_t *lcd, int bias)
{
       write_command(lcd, BIAS_SET(bias, 1), 1);
}

void
set_contrast(lcd_t *lcd, int contrast)
{
       write_command(lcd, POWER_SET(1,1,contrast), 1);
       write_command(lcd, FOLLOWER_CONTROL(1,3), 1);
       delay(200e-3);
       write_command(lcd, CONTRAST_SET(contrast), 1);
}

void
set_display_mode(lcd_t *lcd, int enabled, int cursor, int blink)
{
       lcd->enabled = enabled;
       lcd->cursor = cursor;
       lcd->blink = blink;
       update_display_mode(lcd);
}

void
enable_cursor(lcd_t *lcd, int set)
{
       lcd->cursor = set;
       update_display_mode(lcd);
}

void
enable_blink(lcd_t *lcd, int set)
{
       lcd->blink = set;
       update_display_mode(lcd);
}

void
set_cursor_offset(lcd_t *lcd, int offset)
{
       write_command(lcd, SET_DDRAM(offset), 0);
       delay(50e-6);
}

void
set_cursor_position(lcd_t *lcd, int row, int column)
{
       int stride, n;

       switch (lcd->rows) {
       case 1: stride = 0; break;
       case 2: stride = 64; break;
       case 3: stride = 16; break;
       default:
               return;
       }

       n = row * stride + column;
       if (n >= 0 && n < 128)
               set_cursor_offset(lcd, n);
}

void
home(lcd_t *lcd)
{
       set_cursor_position(lcd, 0, 0);
}

void
clear(lcd_t *lcd)
{
       write_command(lcd, CLEAR_DISPLAY, 0);
       delay(2e-3);
}

void
reset(lcd_t *lcd)
{
       gpio_set(lcd->gfd, lcd->reset_pin, GPIO_PIN_LOW);
       delay(0.001);
       gpio_set(lcd->gfd, lcd->reset_pin, GPIO_PIN_HIGH);
}

void
setup(lcd_t *lcd)
{

       lcd->select_pin = PIN_SELECT;
       lcd->reset_pin = PIN_RESET;
       lcd->rows = 3;
       lcd->columns = 16;
       lcd->addr = ADDR;

       lcd->enabled = 1;
       lcd->cursor = 0;
       lcd->blink = 0;
       lcd->dbl = 1;

       spi_configure(lcd->sfd, lcd->addr, MODE, 0);
       spi_configure(lcd->sfd, lcd->addr, MODE, 1000000);

       gpio_set(lcd->gfd, lcd->select_pin, GPIO_PIN_HIGH);
       reset(lcd);
       delay(40e-3);
}


int main()
{
       lcd_t L;
       int i;

       L.gfd = open(GPIO, O_RDWR);
       if (L.gfd == -1)
               err(1,"open %s",GPIO);
       L.sfd = open(SPI, O_RDWR);
       if (L.sfd == -1)
               err(1,"open %s",SPI);

       setup(&L);

       update_display_mode(&L);
       write_command(&L, ENTRY_MODE_SET(1,0), 0);

       set_bias(&L, 1);

       set_display_mode(&L, 1, 0, 0);
       set_contrast(&L, 40);
       clear(&L);

for (;;) {
       time_t now;
       struct tm *tm;
       static int mday;
       char *tz;
       char buf[26];

       time(&now);
       tm = localtime(&now);
       asctime_r(tm, buf);
       tz = tm->tm_zone;

       buf[10] = '\0';
       buf[19] = '\0';
       buf[24] = '\0';

       if (tm->tm_mday != mday) {
               set_cursor_position(&L, 0, 0);
               write_string(&L, &buf[0]);
               set_cursor_position(&L, 0, 12);
               write_string(&L, &buf[20]);
               mday = tm->tm_mday;
       }

       set_cursor_position(&L, 1, 0);
       write_string(&L, &buf[11]);
       set_cursor_position(&L, 1, 9);
       write_string(&L, tz);

       delay(1.0);
}

       //printf("%d\n", read_busy(&L));

       close(L.sfd);
       close(L.gfd);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.