API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 28th, 2014
307
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 8.03 KB | None | 0 0
raw download clone embed print report
  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
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!