dioxik

CS1694 / arduino

Nov 27th, 2014
402
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. #define getBit(value, bitn) ((((value)&(1<<(bitn)))>>(bitn))?HIGH:LOW)
  3.  
  4. int ledPin = 13;                // LED connected to digital pin 13
  5. int clkPin = 4;
  6. int dataPin = 2;
  7. int csPin = 3;
  8. int delaySetup = 10;
  9. int delayByte = 20;
  10. int main_i=0;
  11. int push_i=0;
  12.  
  13. byte KEY1 = 0x04;
  14. byte KEY2 = 0x10;
  15. byte KEY3 = 0x20;
  16.  
  17. byte ET6202DIG[6];
  18.  
  19. byte LED[10] = {
  20. 0x7E,   // 0 a,b,c,d,e,f - 01111110
  21. 0x30,   // 1 b+c - 00110000
  22. 0x6D,   // 2 a+b+d+e+h - 01101101
  23. 0x79,   // 3 a+b+c+d+h - 01111001
  24. 0x33,   // 4  b+c+f+h - 00110011
  25. 0x5B,   // 5  a,c,d,f,h - 01011011
  26. 0x5F,   // 6  a,c,d,e,f,h - 01011111
  27. 0x70,   // 7  a,b,c - 01110000
  28. 0x7F,   // 8 01111111
  29. 0x7B,   // 9 01111011
  30. };
  31.  
  32. byte POINT[4] = {
  33.   0x00,  // none
  34.   0x04,  // e   00000100 1-left
  35.   0x02,  // f   00000010 2-right
  36.   0x06,  // e,f 00000110 1|2 = 3 - left+right
  37. };
  38.  
  39. unsigned long prev_key=0;
  40.  
  41. void setup()                    // run once, when the sketch starts
  42. {
  43.   Serial.begin(9600);
  44.   Serial.print('dupa');
  45.   pinMode(ledPin, OUTPUT);      // sets the digital pin as output
  46.   pinMode(dataPin, OUTPUT);
  47.   pinMode(clkPin, OUTPUT);
  48.   pinMode(csPin, OUTPUT);
  49.   digitalWrite(dataPin, HIGH);
  50.   digitalWrite(clkPin, HIGH);
  51.   digitalWrite(csPin, HIGH);
  52.   initET6202();
  53.  
  54.   setDigit(LED[1], 0);
  55.   setDigit(LED[2], 1);
  56.   setDigit(LED[3], 2);
  57.   setDigit(LED[4], 3);
  58.   setDigit(LED[5], 4);
  59.   setDigit(POINT[3], 5);
  60.   updateET6202();
  61.  
  62. }
  63.  
  64. void loop()                     // run over and over again
  65. {
  66.  
  67.   order1();
  68. order1_init();
  69.  
  70.  // helloolga();
  71. //  order3_init();
  72. //order3();
  73. //delay(1000);
  74.  // Serial.print('dupa');
  75. //  unsigned long key=0;
  76.  
  77. //key=sendCmd(0x42, NULL, 0, 2);
  78. //€delay(1000);
  79.  
  80. //  if(prev_key != key){
  81. //      prev_key = key;
  82. //      if(key != 0){
  83. //          if((key & KEY1) > 0){
  84. //              push_i = push_i==0?0:push_i-1;
  85. //          }
  86. //          if((key & KEY2) > 0){
  87. //             push_i = push_i+1;
  88. //          }
  89. //         sendCmd((0x88 | (push_i%8)), NULL, 0, false);
  90. //      }
  91. //  }
  92.  
  93. }
  94.  
  95. void helloolga(){
  96.     if(main_i==0){
  97.       main_i=1;
  98.     //  delay(1000);
  99.     //  order2();
  100.       order3_2();
  101.       //order1();
  102.       //order4();
  103.       digitalWrite(ledPin, LOW);      
  104.     }
  105.     else{
  106.       main_i=0;
  107.    //   delay(1000);
  108.      // order2();
  109.       order3();
  110.      // order1();
  111.      // order4();
  112.       digitalWrite(ledPin, HIGH);
  113.     }    
  114. }
  115.  
  116. void initET6202(){
  117.     delay(200);
  118.     order2_init();
  119.     order3_init();
  120.     order1_init();
  121.     order4_init();
  122.     ///delay(delayByte);
  123.     order2();
  124.     order3();
  125.     order1();
  126.     order4();
  127. }
  128.  
  129. unsigned long sendCmd(int cmd, int * data, int size, int nocshigh ){
  130.     int i=0;
  131.     int j=0;
  132.     noInterrupts();
  133.     digitalWrite(csPin, LOW);    
  134.  
  135.     for (i=0; i<8; i++){
  136.       digitalWrite(clkPin, LOW);
  137.       digitalWrite(dataPin, getBit(cmd, i));
  138.       digitalWrite(clkPin, HIGH);
  139.     }
  140.  
  141.     if(data != NULL){
  142.         for(j=0; j<size; j++){
  143.             for (i=0; i<8; i++){
  144.                 digitalWrite(clkPin, LOW);
  145.                 digitalWrite(dataPin, getBit(data[j], i));
  146.                 digitalWrite(clkPin, HIGH);
  147.             }    
  148.         }
  149.     }
  150.  
  151.     if(nocshigh == false){
  152.       digitalWrite(csPin, HIGH);
  153.       digitalWrite(dataPin, HIGH);
  154.       digitalWrite(clkPin, HIGH);
  155.     }
  156.  
  157.     unsigned long reskey = 0x00000000;
  158.     int tmp = 0;
  159.     int sh = 0;
  160.     if(nocshigh == 2){
  161.         pinMode(dataPin, INPUT);
  162.         for (j=0; j<5; j++){
  163.             for (i=0; i<8; i++){
  164.                 digitalWrite(clkPin, LOW);
  165.                 digitalWrite(clkPin, HIGH);
  166.                 if(i == 0 || i ==1 || i == 3 || i ==4){
  167.                     sh = i>2 ? i-1 : i;
  168.                     tmp = digitalRead(dataPin);
  169.                     reskey = reskey | (((unsigned long)(tmp & 0x01)) << (j*4 + sh));
  170.                     //Serial.print((j*4 + sh));
  171.                     //Serial.print(" ");
  172.                 }
  173.             }
  174.         }
  175.         pinMode(dataPin, OUTPUT);
  176.         //Serial.println(reskey, HEX);
  177.  
  178.         digitalWrite(csPin, HIGH);
  179.         digitalWrite(dataPin, HIGH);
  180.         digitalWrite(clkPin, HIGH);
  181.     }
  182.  
  183.     interrupts();
  184.     return reskey;
  185. }
  186.  
  187. void order2_init(){
  188.     int cmd = 0x40;
  189.     sendCmd(cmd, NULL, 0, false);
  190. }
  191.  
  192. void order3_init(){
  193.     int cmd = 0xC0;
  194.     int data[14] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0};
  195.     sendCmd(cmd, data, 14, false);
  196. }
  197.  
  198. void order1_init(){
  199.     int cmd = 0x03;
  200.     sendCmd(cmd, NULL, 0, false);
  201. }
  202.  
  203. void order4_init(){
  204.     int cmd = 0x80;
  205.     sendCmd(cmd, NULL, 0, false);
  206. }
  207.  
  208.  
  209. void order2(){
  210.     int cmd = 0x40; //0100 0000
  211.     sendCmd(cmd, NULL, 0, false);
  212. }
  213. void order3(){
  214.     int cmd = 0xC0;
  215. //                   1(a)    2(b)     3(c)     4(d)       7(h)     6(f)      5(e)
  216.     int data[14] = {0x12, 0, 0x11, 0, 0x11, 0, 0x1E,  0, 0x03, 0, 0x1F, 0x0, 0x1F, 0x00}; // 'HELLO'
  217.     // This PCB has tricky layout
  218.     //   1 - SG4, 2 - SG5, 3 - SG6, 4 - SG7, 5 - SG8
  219.     //   points - SG3, left - e(DIG7), right - f (DIG6)
  220.     // a - DIG1, b - DIG2, c - DIG3, d - DIG4, e - DIG7, f - DIG6, h - DIG5
  221.  
  222.     sendCmd(cmd, data, 14, false);  
  223. }
  224.  
  225. void order3_2(){
  226.     int cmd = 0xC0;
  227.     int data[14] = {0x1A, 0, 0x12, 0, 0x1A, 0, 0x0E,  0, 0x10, 0, 0x1E, 0x0, 0x1E, 0x00}; // ' OLGA'
  228.     sendCmd(cmd, data, 14, false);  
  229. }
  230.  
  231.  
  232. void order1(){
  233.     int cmd = 0x03;
  234.     sendCmd(cmd, NULL, 0, false);
  235. }
  236.  
  237. void order4(){
  238.     int cmd = 0x8F;
  239.     sendCmd(cmd, NULL, 0, false);
  240. }
  241.  
  242.  
  243. void readKey(){
  244.     //2
  245.     sendCmd(0x42, NULL, 0, 2); // normal mode, incremental, read key scan data
  246.     //3
  247.     //sendCmd(0xC0, NULL, 0, false); // address set to 00H
  248.     //1
  249.     //sendCmd(0x03, NULL, 0, false); // mode 10x7
  250.     //4
  251.     //sendCmd(0x80, NULL, 0, false);  // display off for scaning key matrix
  252. }
  253.  
  254. void setDigit(int digit, int num){
  255.     //digit - digit for show
  256.     // num - num of a LED where to show digit
  257.     if(num < 0 || num > 5){ return; }
  258.     ET6202DIG[num] = digit;
  259. }
  260.  
  261. void updateET6202(){
  262.     int mem[14] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0, 0, 0, 0};
  263.     byte i=0, j=0;
  264.     int sh=0;
  265.     for(i=0; i<6; i++){
  266.         for(j=0; j<7; j++){
  267. //                     1        2        3       4          7        6          5
  268. //    int data[14] = {0x12, 0, 0x11, 0, 0x11, 0, 0x1E,  0, 0x03, 0, 0x1F, 0x0, 0x1F, 0x00}; // 'HELLO'
  269.    //                 0        1        2        3         4        5         6
  270.    //                 6        5        4        3         0        1         2  
  271.             sh = j==6 ? 2 : (j==4 ? 0 : 6-j);  //
  272.             mem[j*2] &= ~(1 << i);  // clear bit
  273.             mem[j*2] |= (getBit(ET6202DIG[i], sh) << i); //set bit
  274.         }
  275.         Serial.println(ET6202DIG[i], HEX);
  276.     }
  277.     sendCmd(0x40, NULL, 0, false);
  278.     sendCmd(0xC0, mem, 14, false);  
  279.     sendCmd(0x03, NULL, 0, false);
  280.     sendCmd(0x8F, NULL, 0, false);
  281. }
RAW Paste Data