Subversion Repositories HomeAutomation

Rev

Rev 1805 | Rev 2214 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | SVN | RSS feed

  1. #include "dotmatrix.h"
  2. #include <avr/io.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5.  
  6. #include <avr/pgmspace.h>
  7.  
  8. //Some parts of the code is from proycon avrlib written by Pascal Stang:
  9. //*****************************************************************************
  10. //
  11. // File Name    : 'glcd.c'
  12. // Title        : Graphic LCD API functions
  13. // Author       : Pascal Stang - Copyright (C) 2002
  14. // Date         : 5/30/2002
  15. // Revised      : 5/30/2002
  16. // Version      : 0.5
  17. // Target MCU   : Atmel AVR
  18. // Editor Tabs  : 4
  19. //
  20. // NOTE: This code is currently below version 1.0, and therefore is considered
  21. // to be lacking in some functionality or documentation, or may not be fully
  22. // tested.  Nonetheless, you can expect most functions to work.
  23. //
  24. // This code is distributed under the GNU Public License
  25. //      which can be found at http://www.gnu.org/licenses/gpl.txt
  26. //
  27. //*****************************************************************************
  28. #ifndef GRAPHICS_WIDTH
  29. #error GRAPHICS_WIDTH, GRAPHICS_HEIGHT must be defined
  30. #endif
  31.  
  32. #define OUTPUT  0
  33. #define INPUT   1
  34.  
  35. volatile GrLcdStateType GrLcdState;
  36. uint8_t dotmatrixFramebuf[8][dotmatrixSIZEX/8];
  37. uint8_t dotmatrixRowCounter=0;
  38.  
  39. /* Write a byte on SPI */
  40. void dotmatrixSPIWrite(uint8_t data) {
  41.     uint8_t dummy = 0;
  42.     /* Wait for empty transmit buffer */
  43.     while ( !( UCSR0A & (1<<UDRE0)) );
  44.     // write data
  45.     dummy = UDR0;
  46.     UDR0 = data;
  47.     waitspi();
  48. }
  49.  
  50. void dotmatrixSetColor(uint8_t color){
  51.   GrLcdState.color=color;
  52. }
  53.  
  54. uint8_t dotmatrixGetColor(void){
  55.   return GrLcdState.color;
  56. }
  57.  
  58. /* Sets data into framebuffer, data arrives in a byte as a column */
  59. void dotmatrixSetData(uint8_t Data)
  60. {
  61.     /* Which ledmodule */
  62.     uint8_t module = GrLcdState.lcdXAddr>>3;
  63.     /* Which column in ledmodule */
  64.     uint8_t column = GrLcdState.lcdXAddr%8;
  65.     /* Which row */
  66. //  uint8_t row = GrLcdState.lcdYAddr%8;
  67.  
  68.     /* Check panel size */
  69.     if ((column < dotmatrixSIZEY) && (module < dotmatrixSIZEX/8))
  70.     {
  71.         dotmatrixFramebuf[column][module] = Data;
  72.     }
  73. }
  74.  
  75. uint8_t dotmatrixGetData(void){
  76.     /* Which ledmodule */
  77.     uint8_t module = GrLcdState.lcdXAddr>>3;
  78.     /* Which column in ledmodule */
  79.     uint8_t column = GrLcdState.lcdXAddr%8;
  80.     /* Which row */
  81. //  uint8_t row = GrLcdState.lcdYAddr%8;
  82.    
  83.     /* Check panel size */
  84.     if ((column < dotmatrixSIZEY) && (module < dotmatrixSIZEX/8))
  85.     {
  86.         return (dotmatrixFramebuf[column][module]);
  87.     }
  88.     else
  89.     {
  90.         return 0;
  91.     }
  92. }
  93.  
  94. void dotmatrixWriteData(uint8_t data, uint8_t color){
  95.     if (color == GLCD_COLOR_CLEAR)
  96.     {
  97.       data = ~data;
  98.     }
  99.     if (GrLcdState.color == GLCD_COLOR_BLACK)
  100.     {
  101.       dotmatrixSetData(data);
  102.     }
  103.     else
  104.     {
  105.       dotmatrixSetData(~data);
  106.     }
  107.    
  108.     GrLcdState.lcdXAddr++;
  109.  
  110.     if (GrLcdState.lcdXAddr > GRAPHICS_WIDTH ){
  111.         dotmatrixSetXY(0,GrLcdState.lcdYAddr+8);
  112.     }
  113. }
  114.  
  115. void dotmatrixWriteDataTransparent(uint8_t inputdata, uint8_t color){
  116.     uint8_t data = dotmatrixGetData();
  117.     if (GrLcdState.color != GLCD_COLOR_BLACK)
  118.     {
  119.       data = ~data;
  120.     }
  121.  
  122.     if (color == GLCD_COLOR_CLEAR)
  123.     {
  124.       data = data&(~inputdata);
  125.     }
  126.     else
  127.     {
  128.       data = data|inputdata;
  129.     }
  130.    
  131.     if (GrLcdState.color == GLCD_COLOR_BLACK)
  132.     {
  133.       dotmatrixSetData(data);
  134.     }
  135.     else
  136.     {
  137.       dotmatrixSetData(~data);
  138.     }
  139.  
  140.     GrLcdState.lcdXAddr++;
  141.  
  142.     if (GrLcdState.lcdXAddr > GRAPHICS_WIDTH ){
  143.         dotmatrixSetXY(0,GrLcdState.lcdYAddr+8);
  144.     }
  145. }
  146.  
  147. uint8_t dotmatrixReadData(void){
  148.     uint8_t data = 0;
  149.     if (GrLcdState.color == GLCD_COLOR_BLACK)
  150.     {
  151.       data = dotmatrixGetData();
  152.     }
  153.     else
  154.     {
  155.       data = ~dotmatrixGetData();
  156.     }
  157.  
  158.     return data;
  159. }
  160.  
  161. /* Callback run periodically to manage rows.
  162.    For each time callback is run, the next row is enabled and the last disabled
  163.  */
  164. void dotmatrixRefresh()
  165. {
  166.     /* Increase row counter */
  167.     if (dotmatrixRowCounter++ == 8) {dotmatrixRowCounter = 0;}
  168.  
  169.     /* Disable all rows */
  170.     gpio_clr_pin(dotmatrixROW_IO1);
  171.     gpio_clr_pin(dotmatrixROW_IO2);
  172.     gpio_clr_pin(dotmatrixROW_IO3);
  173.     gpio_clr_pin(dotmatrixROW_IO4);
  174.     gpio_clr_pin(dotmatrixROW_IO5);
  175.     gpio_clr_pin(dotmatrixROW_IO6);
  176.     gpio_clr_pin(dotmatrixROW_IO7);
  177.     gpio_clr_pin(dotmatrixROW_IO8);
  178.  
  179.     /* Write one column of frame buffer to shift registers */
  180.     dotmatrixSPIWrite(dotmatrixFramebuf[dotmatrixRowCounter][0]);
  181.     dotmatrixSPIWrite(dotmatrixFramebuf[dotmatrixRowCounter][1]);
  182.     dotmatrixSPIWrite(dotmatrixFramebuf[dotmatrixRowCounter][2]);
  183.     dotmatrixSPIWrite(dotmatrixFramebuf[dotmatrixRowCounter][3]);
  184.     /* Add more here to support 8-module panels */
  185.  
  186.     /* Toggle shift register latch */
  187.     gpio_clr_pin(dotmatrixLATCHCLOCK_IO);
  188.     gpio_set_pin(dotmatrixLATCHCLOCK_IO);
  189.  
  190.     /* Enable one row */
  191.     switch (dotmatrixRowCounter)
  192.     {
  193.         case 0:
  194.             gpio_set_pin(dotmatrixROW_IO1);
  195.             break;
  196.         case 1:
  197.             gpio_set_pin(dotmatrixROW_IO2);
  198.             break;
  199.         case 2:
  200.             gpio_set_pin(dotmatrixROW_IO3);
  201.             break;
  202.         case 3:
  203.             gpio_set_pin(dotmatrixROW_IO4);
  204.             break;
  205.         case 4:
  206.             gpio_set_pin(dotmatrixROW_IO5);
  207.             break;
  208.         case 5:
  209.             gpio_set_pin(dotmatrixROW_IO6);
  210.             break;
  211.         case 6:
  212.             gpio_set_pin(dotmatrixROW_IO7);
  213.             break;
  214.         case 7:
  215.             gpio_set_pin(dotmatrixROW_IO8);
  216.             break;
  217.            
  218.         default:
  219.             break;
  220.     }
  221. }
  222.  
  223. void dotmatrixInit(){
  224.     /* Set up row driver IO as low output */
  225.     gpio_clr_pin(dotmatrixROW_IO1);
  226.     gpio_set_out(dotmatrixROW_IO1);
  227.     gpio_clr_pin(dotmatrixROW_IO2);
  228.     gpio_set_out(dotmatrixROW_IO2);
  229.     gpio_clr_pin(dotmatrixROW_IO3);
  230.     gpio_set_out(dotmatrixROW_IO3);
  231.     gpio_clr_pin(dotmatrixROW_IO4);
  232.     gpio_set_out(dotmatrixROW_IO4);
  233.     gpio_clr_pin(dotmatrixROW_IO5);
  234.     gpio_set_out(dotmatrixROW_IO5);
  235.     gpio_clr_pin(dotmatrixROW_IO6);
  236.     gpio_set_out(dotmatrixROW_IO6);
  237.     gpio_clr_pin(dotmatrixROW_IO7);
  238.     gpio_set_out(dotmatrixROW_IO7);
  239.     gpio_clr_pin(dotmatrixROW_IO8);
  240.     gpio_set_out(dotmatrixROW_IO8);
  241.  
  242.     /* Set up PWM controlling brightness */
  243. //  TCCR0A |= (1<<COM0B1)|(1<<WGM01)|(1<<WGM00);
  244. //  TCCR0B |= (1<<CS00);
  245. //  OCR0B = 0xff-act_DotMatrix_INITIAL_BRIGHTNESS;
  246. //  DDRD |= (1<<PD5);
  247.  
  248.     /* Set up output latch clock */
  249.     gpio_clr_pin(dotmatrixLATCHCLOCK_IO);
  250.     gpio_set_out(dotmatrixLATCHCLOCK_IO);
  251.  
  252.     /* Initialize USART in SPI-mode */
  253.     UBRR0 = 0;
  254.     USART_SPI_XCK_DDR |= (1<<USART_SPI_XCK); // xck (sck) output
  255.     UCSR0C = (1<<UMSEL01)|(1<<UMSEL00)|(0<<UCPHA0)|(0<<UCPOL0);
  256.     UCSR0B = (1<<RXEN0)|(1<<TXEN0);
  257.     UBRR0 = 0;
  258.  
  259.     dotmatrixClear();
  260.  
  261.     GrLcdState.color = GLCD_COLOR_BLACK;
  262. }
  263.  
  264. void dotmatrixClear(){
  265.     /* Clear buffer memory */
  266.     for (uint8_t i=0; i<8; i++)
  267.     {
  268.         for (uint8_t j=0; j<4; j++)
  269.         {
  270.             dotmatrixFramebuf[i][j] = dotmatrixINITIAL_ROW;
  271.         }
  272.     }
  273. }
  274.  
  275. void dotmatrixSetXY(uint8_t x, uint8_t y){
  276.     GrLcdState.lcdXAddr = x;
  277.     GrLcdState.lcdYAddr = y;
  278.     GrLcdState.lcdYpage = y/8;
  279. }
  280.  
  281. uint8_t dotmatrixGetX(void){
  282.     return GrLcdState.lcdXAddr;
  283. }
  284.  
  285. uint8_t dotmatrixGetY(void){
  286.     return GrLcdState.lcdYAddr;
  287. }
  288.  
  289.