Advertisement
Guest User

Untitled

a guest
May 28th, 2014
227
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdint.h>
  2. #include <unistd.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <getopt.h>
  7. #include <fcntl.h>
  8. #include <sys/ioctl.h>
  9. #include <linux/types.h>
  10. #include <linux/spi/spidev.h>
  11.  
  12. typedef struct {
  13.      const uint8_t *data;
  14.      uint16_t width;
  15.      uint16_t height;
  16.      } tImage;
  17.  
  18. #include "mojo.h"
  19. #include "marc.h"
  20. #include "grin.h"
  21.  
  22. #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
  23.  
  24. static void pabort(const char *s)
  25. {
  26.     perror(s);
  27.     abort();
  28. }
  29.  
  30. static const char *device = "/dev/spidev0.1";
  31. static uint8_t mode;
  32. static uint8_t bits = 8;
  33. static uint32_t speed = 20000000;
  34. static uint16_t delay;
  35. int fd;
  36.  
  37. void init_gpios() {
  38.     system("echo 24 > /sys/class/gpio/export");
  39.     system("echo out > /sys/class/gpio/gpio24/direction");
  40.     system("echo 25 > /sys/class/gpio/export");
  41.     system("echo out > /sys/class/gpio/gpio25/direction");
  42. }
  43. void Reset() {
  44.     system("echo 0 > /sys/class/gpio/gpio25/value");
  45.     usleep(150);
  46.         system("echo 1 > /sys/class/gpio/gpio25/value");
  47.     usleep(150);
  48. }
  49. void write_command(uint8_t *command) {
  50.     int ret;
  51.    
  52.     system("echo 0 > /sys/class/gpio/gpio24/value"); // dc=0
  53.  
  54.     struct spi_ioc_transfer tr = {
  55.         .tx_buf = (unsigned long)command,
  56.         .len = 1,
  57.         .delay_usecs = delay,
  58.         .speed_hz = speed,
  59.         .bits_per_word = bits,
  60.     };
  61.  
  62.     ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
  63.     if (ret < 1)
  64.         pabort("can't send spi message");
  65. }
  66. void write_data(uint8_t *data, size_t tam) {
  67.     int ret;
  68.    
  69.     system("echo 1 > /sys/class/gpio/gpio24/value"); // dc=0
  70.  
  71.     struct spi_ioc_transfer tr = {
  72.         .tx_buf = (unsigned long)data,
  73.         .len = tam,
  74.         .delay_usecs = delay,
  75.         .speed_hz = speed,
  76.         .bits_per_word = bits,
  77.     };
  78.  
  79.     ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
  80.     if (ret < 1)
  81.         pabort("can't send spi message");
  82. }
  83. void write_data2(uint8_t *data, size_t tam) {
  84.     int ret;
  85.  
  86.     struct spi_ioc_transfer tr = {
  87.         .tx_buf = (unsigned long)data,
  88.         .len = tam,
  89.         .delay_usecs = delay,
  90.         .speed_hz = speed,
  91.         .bits_per_word = bits,
  92.     };
  93.  
  94.     ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
  95.     if (ret < 1)
  96.         pabort("can't send spi message");
  97. }
  98. void lcd_init() {
  99.     unsigned int i=0, k=0;
  100.    
  101.     printf("inicializando lcd\n");
  102.     printf("lcd reset.....");
  103.     Reset();
  104.     printf("[ok]\n");
  105.     //-------------------Software Reset-------------------------------//
  106.  
  107.     printf("lcd setextc.....");
  108.     write_command((uint8_t[]){0xB9});
  109.     write_data( (uint8_t[]){0xFF, 0x83, 0x53}, 3 );
  110.     printf("[ok]\n");
  111.    
  112.     printf("lcd radj.....");
  113.     write_command((uint8_t[]){0xB0});//RADJ
  114.     write_data( (uint8_t[]){0x3C, 0x01}, 2 );
  115.     printf("[ok]\n");
  116.    
  117.     printf("lcd vcom.....");
  118.     write_command((uint8_t[]){0xB6});//VCOM define el high level voltage
  119.     write_data( (uint8_t[]){0x94, 0x6C, 0x50}, 3 );
  120.     printf("[ok]\n");
  121.  
  122.     printf("lcd pwr.....");
  123.     write_command((uint8_t[]){0xB1});//PWR set power control
  124.     write_data( (uint8_t[]) {0x00, 0x01, 0x1B, 0x03, 0x01, 0x08, 0x77, 0x89}, 8);
  125.     printf("[ok]\n");
  126.  
  127.     printf("lcd gamma.....");
  128.     write_command((uint8_t[]){0xE0}); //Gamma setting for tpo Panel
  129.     write_data( (uint8_t[]) {0x50, 0x77, 0x40, 0x08, 0xBF, 0x00, 0x03,
  130.     0x0F, 0x00, 0x01, 0x73, 0x00, 0x72, 0x03, 0xB0, 0x0F, 0x08, 0x00,
  131.     0x0F, 0x3A, 0x05}, 21 );
  132.     printf("[ok]\n");
  133.     usleep(150);   
  134.    
  135.     write_command((uint8_t[]){0x3A}); // interface pixel format
  136.     write_data((uint8_t[]){0x05},1);    // 16 Bit/Pixel
  137.    
  138.     usleep(150);   
  139.    
  140.     write_command((uint8_t[]){0x36}); // memory access control
  141.     write_data( (uint8_t[]) {0x70}, 1 ); // controla la dirección en que se recorre
  142.     printf("[ok]\n"); // la memoria interna al volcar a pantalla
  143.        
  144.     printf("lcd slpout.....");
  145.     write_command((uint8_t[]){0x11}); // SLPOUT sleep out. Sale del modo sleep
  146.     printf("[ok]\n");
  147.  
  148.     usleep(150);   
  149.  
  150.     printf("lcd on.....");
  151.     write_command((uint8_t[]){0x29});    // display on
  152.     printf("[ok]\n");
  153.  
  154.     usleep(150);
  155.  
  156.     printf("lcd lookup table.....");
  157.     uint8_t lookup[128];
  158.    
  159.     write_command((uint8_t[]){0x2D});  //Look up table
  160.     for(i=0;i<32;i++)
  161.         lookup[k++] = 2*i;
  162.     for(i=0;i<64;i++)
  163.         lookup[k++] = i;
  164.     for(i=0;i<32;i++)
  165.         lookup[k++] = 2*i; 
  166.        
  167.     write_data( lookup, 128 );
  168.     printf("[ok]\n");
  169.    
  170.     usleep(150);
  171.    
  172.     write_command((uint8_t[]){0x2A});
  173.  
  174.     write_data((uint8_t[]){0x00, 0x00, 0x00, 159}, 4);
  175.  
  176.     write_command((uint8_t[]){0x2B});
  177.     write_data((uint8_t[]){0x00, 0x00, 0x00, 127}, 4);
  178.  
  179.     printf("lcd inicializado\n");
  180. }
  181.  
  182. void lcd_fill(unsigned int color) {
  183.     unsigned int i, j, k=0;
  184.    
  185.     uint8_t tx[320];
  186.    
  187.     for (i = 0; i < 160; i++) {
  188.         tx[k++] = color>>8;
  189.         tx[k++] = color&0xff;
  190.     }
  191.    
  192.     write_command((uint8_t[]){0x2C});  //Memory write
  193.    
  194.     system("echo 1 > /sys/class/gpio/gpio24/value"); // dc=0
  195.    
  196.     for (i = 0; i < 128; i++)
  197.         write_data2(tx, 320);
  198.    
  199.     write_command((uint8_t[]){0x00});
  200. }
  201.  
  202. void show_image( const unsigned char img[] ) {
  203.     unsigned int i, j, k=0;
  204.    
  205.     uint8_t tx[320];
  206.    
  207.     write_command((uint8_t[]){0x2C});  //Memory write
  208.     system("echo 1 > /sys/class/gpio/gpio24/value"); // dc=0
  209.    
  210.     for (i = 0; i < 128; i++) {
  211.         memcpy( tx, img+(320*i), 320 );
  212.         write_data2( tx, 320 );
  213.     }
  214.    
  215.     write_command((uint8_t[]){0x00});
  216. }
  217.  
  218. static void print_usage(const char *prog)
  219. {
  220.     printf("Usage: %s [-DsbdlHOLC3]\n", prog);
  221.     puts("  -D --device   device to use (default /dev/spidev0.1)\n"
  222.          "  -s --speed    max speed (Hz)\n"
  223.          "  -d --delay    delay (usec)\n"
  224.          "  -b --bpw      bits per word \n"
  225.          "  -l --loop     loopback\n"
  226.          "  -H --cpha     clock phase\n"
  227.          "  -O --cpol     clock polarity\n"
  228.          "  -L --lsb      least significant bit first\n"
  229.          "  -C --cs-high  chip select active high\n"
  230.          "  -3 --3wire    SI/SO signals shared\n");
  231.     exit(1);
  232. }
  233.  
  234. static void parse_opts(int argc, char *argv[])
  235. {
  236.     while (1) {
  237.         static const struct option lopts[] = {
  238.             { "device",  1, 0, 'D' },
  239.             { "speed",   1, 0, 's' },
  240.             { "delay",   1, 0, 'd' },
  241.             { "bpw",     1, 0, 'b' },
  242.             { "loop",    0, 0, 'l' },
  243.             { "cpha",    0, 0, 'H' },
  244.             { "cpol",    0, 0, 'O' },
  245.             { "lsb",     0, 0, 'L' },
  246.             { "cs-high", 0, 0, 'C' },
  247.             { "3wire",   0, 0, '3' },
  248.             { "no-cs",   0, 0, 'N' },
  249.             { "ready",   0, 0, 'R' },
  250.             { NULL, 0, 0, 0 },
  251.         };
  252.         int c;
  253.  
  254.         c = getopt_long(argc, argv, "D:s:d:b:lHOLC3NR", lopts, NULL);
  255.  
  256.         if (c == -1)
  257.             break;
  258.  
  259.         switch (c) {
  260.         case 'D':
  261.             device = optarg;
  262.             break;
  263.         case 's':
  264.             speed = atoi(optarg);
  265.             break;
  266.         case 'd':
  267.             delay = atoi(optarg);
  268.             break;
  269.         case 'b':
  270.             bits = atoi(optarg);
  271.             break;
  272.         case 'l':
  273.             mode |= SPI_LOOP;
  274.             break;
  275.         case 'H':
  276.             mode |= SPI_CPHA;
  277.             break;
  278.         case 'O':
  279.             mode |= SPI_CPOL;
  280.             break;
  281.         case 'L':
  282.             mode |= SPI_LSB_FIRST;
  283.             break;
  284.         case 'C':
  285.             mode |= SPI_CS_HIGH;
  286.             break;
  287.         case '3':
  288.             mode |= SPI_3WIRE;
  289.             break;
  290.         case 'N':
  291.             mode |= SPI_NO_CS;
  292.             break;
  293.         case 'R':
  294.             mode |= SPI_READY;
  295.             break;
  296.         default:
  297.             print_usage(argv[0]);
  298.             break;
  299.         }
  300.     }
  301. }
  302.  
  303. int main(int argc, char *argv[])
  304. {
  305.     int ret = 0, i;
  306.  
  307.     parse_opts(argc, argv);
  308.  
  309.     fd = open(device, O_RDWR);
  310.     if (fd < 0)
  311.         pabort("can't open device");
  312.  
  313.     /*
  314.      * spi mode
  315.      */
  316.     ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
  317.     if (ret == -1)
  318.         pabort("can't set spi mode");
  319.  
  320.     ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
  321.     if (ret == -1)
  322.         pabort("can't get spi mode");
  323.  
  324.     /*
  325.      * bits per word
  326.      */
  327.     ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
  328.     if (ret == -1)
  329.         pabort("can't set bits per word");
  330.  
  331.     ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
  332.     if (ret == -1)
  333.         pabort("can't get bits per word");
  334.  
  335.     /*
  336.      * max speed hz
  337.      */
  338.     ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
  339.     if (ret == -1)
  340.         pabort("can't set max speed hz");
  341.  
  342.     ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
  343.     if (ret == -1)
  344.         pabort("can't get max speed hz");
  345.  
  346.     printf("spi mode: %d\n", mode);
  347.     printf("bits per word: %d\n", bits);
  348.     printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);
  349.    
  350.     init_gpios();
  351.    
  352.     lcd_init();
  353.     lcd_fill(0x0000);
  354.     while(1) {
  355.         for(i=0; i<20; i++) {
  356.             show_image(marc);
  357.             show_image(mojo);
  358.             show_image(grin);
  359.         }
  360.         lcd_fill(0x0000);
  361.     }
  362.     close(fd);
  363.     return ret;
  364. }
Advertisement
RAW Paste Data Copied
Advertisement