OK Mégsem
Fórum témák

» Több friss téma
Fórum » Arduino
A klónok CH340 Soros-USB illesztőjének drivere (Letöltés)
Lapozás: OK   289 / 864
(#) ha6qt válasza david10 hozzászólására (») Nov 5, 2016 /
 
Köszi Egy egyszerű hőmérőről van szó, és a hőmérsékletet több helyen is szeretném mutatni
(#) szikorapéter hozzászólása Nov 5, 2016 /
 
Sziasztok. Attiny 12-őt szeretnék programozni egyszerű arduino board-on keresztül. A kérdésem az volna hogy egyszerűen összekötöm ICSP-n és programozom vagy valamit be kell hozzá állítani?
(#) mateatek válasza agave hozzászólására (») Nov 5, 2016 / 1
 
A timer CTC módját használva be tudod állítani a pontos frekvenciát, és az impulzus szélességet is.
(#) mateatek válasza agave hozzászólására (») Nov 5, 2016 / 1
 
  1. TCCR1A = 0;
  2.   TCCR1B = 0;
  3.   TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM11);
  4.   TCCR1B = _BV(WGM13) | _BV(CS10) | _BV(WGM12);
  5.   ICR1   = 1066; //15kHz-es jel, illetve az OCR1A max erteke
  6.   OCR1A = 533; //50%-os kitoltes


A fenti kód az 1-es timert, a 16 biteset beállítja úgy, hogy mind a frekit, mind a kitöltési tényezőt tudod állítani.
(#) GPeti1977 hozzászólása Nov 5, 2016 /
 
Tudnátok abban segíteni ha feltöltöm ide a kódot, a kérdés hogy minden új tömb beolvasásakor elcsúsznak a betűk egy sorral felfelé. Vannak még apróságok pl az utolsó és első 5x8 mátrixot nem tudom kihasználni mert ott íródik át az új karakter, valami virtuális kijelzőre kellene írnom.
Fényújság

Ezt is tudja csak egy kapcsolóval ki kell választani melyik módot játssza le.
LED mátrix .bmp fájból.

  1. #include "FAB_LED.h"
  2. #include <SPI.h>
  3. #include <SD.h>
  4.  
  5. int effect;
  6. int dt = 35;
  7. const int line = 72;
  8. const int row = 8;
  9. const int numPixels = line*row;
  10.  
  11. uint8_t maxBrightness = 255;
  12. const int chipSelect = 53;
  13. //volatile int pos;
  14. unsigned int i;
  15. char* playfile;
  16. char* textfile;
  17. int n = 0;
  18. boolean m=true;
  19. int scene = 0;
  20. int scene1 = 0;
  21. byte r;
  22. byte g;
  23. byte b;
  24. int pos;
  25. int rr;
  26. byte tsh=0;
  27.  
  28. static const unsigned char font[] = {
  29.   0x00, 0x00, 0x00, 0x00, 0x00,
  30.   0x00, 0x00, 0x00, 0x00, 0x00,
  31.   0x00, 0x00, 0x00, 0x00, 0x00,
  32.   0x00, 0x00, 0x00, 0x00, 0x00,
  33.   0x00, 0x00, 0x00, 0x00, 0x00,
  34.   0x00, 0x00, 0x00, 0x00, 0x00,
  35.   0x00, 0x00, 0x00, 0x00, 0x00,
  36.   0x00, 0x00, 0x00, 0x00, 0x00,
  37.   0x00, 0x00, 0x00, 0x00, 0x00,
  38.   0x00, 0x00, 0x00, 0x00, 0x00,
  39.   0x00, 0x00, 0x00, 0x00, 0x00,
  40.   0x00, 0x00, 0x00, 0x00, 0x00,
  41.   0x00, 0x00, 0x00, 0x00, 0x00,
  42.   0x00, 0x00, 0x00, 0x00, 0x00,
  43.   0x00, 0x00, 0x00, 0x00, 0x00,
  44.   0x00, 0x00, 0x00, 0x00, 0x00,
  45.   0x00, 0x00, 0x00, 0x00, 0x00,
  46.   0x00, 0x00, 0x00, 0x00, 0x00,
  47.   0x00, 0x00, 0x00, 0x00, 0x00,
  48.   0x00, 0x00, 0x00, 0x00, 0x00,
  49.   0x00, 0x00, 0x00, 0x00, 0x00,
  50.   0x00, 0x00, 0x00, 0x00, 0x00,
  51.   0x00, 0x00, 0x00, 0x00, 0x00,
  52.   0x00, 0x00, 0x00, 0x00, 0x00,
  53.   0x00, 0x00, 0x00, 0x00, 0x00,
  54.   0x00, 0x00, 0x00, 0x00, 0x00,
  55.   0x00, 0x00, 0x00, 0x00, 0x00,
  56.   0x00, 0x00, 0x00, 0x00, 0x00,
  57.   0x00, 0x00, 0x00, 0x00, 0x00,
  58.   0x00, 0x00, 0x00, 0x00, 0x00,
  59.   0x00, 0x00, 0x00, 0x00, 0x00,
  60.   0x00, 0x00, 0x00, 0x00, 0x00,
  61.   0x00, 0x00, 0x00, 0x00, 0x00,
  62.   0x00, 0x00, 0x5F, 0x00, 0x00,
  63.   0x00, 0x07, 0x00, 0x07, 0x00,
  64.   0x14, 0x7F, 0x14, 0x7F, 0x14,
  65.   0x24, 0x2A, 0x7F, 0x2A, 0x12,
  66.   0x23, 0x13, 0x08, 0x64, 0x62,
  67.   0x36, 0x49, 0x56, 0x20, 0x50,
  68.   0x00, 0x08, 0x07, 0x03, 0x00,
  69.   0x00, 0x1C, 0x22, 0x41, 0x00,
  70.   0x00, 0x41, 0x22, 0x1C, 0x00,
  71.   0x2A, 0x1C, 0x7F, 0x1C, 0x2A,
  72.   0x08, 0x08, 0x3E, 0x08, 0x08,
  73.   0x00, 0x80, 0x70, 0x30, 0x00,
  74.   0x08, 0x08, 0x08, 0x08, 0x08,
  75.   0x00, 0x00, 0x60, 0x60, 0x00,
  76.   0x20, 0x10, 0x08, 0x04, 0x02,
  77.   0x3E, 0x51, 0x49, 0x45, 0x3E,
  78.   0x00, 0x42, 0x7F, 0x40, 0x00,
  79.   0x72, 0x49, 0x49, 0x49, 0x46,
  80.   0x21, 0x41, 0x49, 0x4D, 0x33,
  81.   0x18, 0x14, 0x12, 0x7F, 0x10,
  82.   0x27, 0x45, 0x45, 0x45, 0x39,
  83.   0x3C, 0x4A, 0x49, 0x49, 0x31,
  84.   0x41, 0x21, 0x11, 0x09, 0x07,
  85.   0x36, 0x49, 0x49, 0x49, 0x36,
  86.   0x46, 0x49, 0x49, 0x29, 0x1E,
  87.   0x00, 0x00, 0x14, 0x00, 0x00,
  88.   0x00, 0x40, 0x34, 0x00, 0x00,
  89.   0x00, 0x08, 0x14, 0x22, 0x41,
  90.   0x14, 0x14, 0x14, 0x14, 0x14,
  91.   0x00, 0x41, 0x22, 0x14, 0x08,
  92.   0x02, 0x01, 0x59, 0x09, 0x06,
  93.   0x3E, 0x41, 0x5D, 0x59, 0x4E,
  94.   0x7C, 0x12, 0x11, 0x12, 0x7C,
  95.   0x7F, 0x49, 0x49, 0x49, 0x36,
  96.   0x3E, 0x41, 0x41, 0x41, 0x22,
  97.   0x7F, 0x41, 0x41, 0x41, 0x3E,
  98.   0x7F, 0x49, 0x49, 0x49, 0x41,
  99.   0x7F, 0x09, 0x09, 0x09, 0x01,
  100.   0x3E, 0x41, 0x41, 0x51, 0x73,
  101.   0x7F, 0x08, 0x08, 0x08, 0x7F,
  102.   0x00, 0x41, 0x7F, 0x41, 0x00,
  103.   0x20, 0x40, 0x41, 0x3F, 0x01,
  104.   0x7F, 0x08, 0x14, 0x22, 0x41,
  105.   0x7F, 0x40, 0x40, 0x40, 0x40,
  106.   0x7F, 0x02, 0x1C, 0x02, 0x7F,
  107.   0x7F, 0x04, 0x08, 0x10, 0x7F,
  108.   0x3E, 0x41, 0x41, 0x41, 0x3E,
  109.   0x7F, 0x09, 0x09, 0x09, 0x06,
  110.   0x3E, 0x41, 0x51, 0x21, 0x5E,
  111.   0x7F, 0x09, 0x19, 0x29, 0x46,
  112.   0x26, 0x49, 0x49, 0x49, 0x32,
  113.   0x03, 0x01, 0x7F, 0x01, 0x03,
  114.   0x3F, 0x40, 0x40, 0x40, 0x3F,
  115.   0x1F, 0x20, 0x40, 0x20, 0x1F,
  116.   0x3F, 0x40, 0x38, 0x40, 0x3F,
  117.   0x63, 0x14, 0x08, 0x14, 0x63,
  118.   0x03, 0x04, 0x78, 0x04, 0x03,
  119.   0x61, 0x59, 0x49, 0x4D, 0x43,
  120.   0x00, 0x7F, 0x41, 0x41, 0x41,
  121.   0x02, 0x04, 0x08, 0x10, 0x20,
  122.   0x00, 0x41, 0x41, 0x41, 0x7F,
  123.   0x04, 0x02, 0x01, 0x02, 0x04,
  124.   0x40, 0x40, 0x40, 0x40, 0x40,
  125.   0x00, 0x03, 0x07, 0x08, 0x00,
  126.   0x20, 0x54, 0x54, 0x78, 0x40,
  127.   0x7F, 0x28, 0x44, 0x44, 0x38,
  128.   0x38, 0x44, 0x44, 0x44, 0x28,
  129.   0x38, 0x44, 0x44, 0x28, 0x7F,
  130.   0x38, 0x54, 0x54, 0x54, 0x18,
  131.   0x00, 0x08, 0x7E, 0x09, 0x02,
  132.   0x18, 0xA4, 0xA4, 0x9C, 0x78,
  133.   0x7F, 0x08, 0x04, 0x04, 0x78,
  134.   0x00, 0x44, 0x7D, 0x40, 0x00,
  135.   0x20, 0x40, 0x40, 0x3D, 0x00,
  136.   0x7F, 0x10, 0x28, 0x44, 0x00,
  137.   0x00, 0x41, 0x7F, 0x40, 0x00,
  138.   0x7C, 0x04, 0x78, 0x04, 0x78,
  139.   0x7C, 0x08, 0x04, 0x04, 0x78,
  140.   0x38, 0x44, 0x44, 0x44, 0x38,
  141.   0xFC, 0x18, 0x24, 0x24, 0x18,
  142.   0x18, 0x24, 0x24, 0x18, 0xFC,
  143.   0x7C, 0x08, 0x04, 0x04, 0x08,
  144.   0x48, 0x54, 0x54, 0x54, 0x24,
  145.   0x04, 0x04, 0x3F, 0x44, 0x24,
  146.   0x3C, 0x40, 0x40, 0x20, 0x7C,
  147.   0x1C, 0x20, 0x40, 0x20, 0x1C,
  148.   0x3C, 0x40, 0x30, 0x40, 0x3C,
  149.   0x44, 0x28, 0x10, 0x28, 0x44,
  150.   0x4C, 0x90, 0x90, 0x90, 0x7C,
  151.   0x44, 0x64, 0x54, 0x4C, 0x44,
  152.   0x00, 0x08, 0x36, 0x41, 0x00,
  153.   0x00, 0x00, 0x77, 0x00, 0x00,
  154.   0x00, 0x41, 0x36, 0x08, 0x00,
  155.   0x02, 0x01, 0x02, 0x04, 0x02,
  156.   0x3C, 0x26, 0x23, 0x26, 0x3C,
  157.   0x1E, 0xA1, 0xA1, 0x61, 0x12,
  158.   0x3A, 0x40, 0x40, 0x20, 0x7A,
  159.   0x38, 0x54, 0x54, 0x55, 0x59,
  160.   0x21, 0x55, 0x55, 0x79, 0x41,
  161.   0x22, 0x54, 0x54, 0x78, 0x42, // a-umlaut
  162.   0x21, 0x55, 0x54, 0x78, 0x40,
  163.   0x20, 0x54, 0x55, 0x79, 0x40,
  164.   0x0C, 0x1E, 0x52, 0x72, 0x12,
  165.   0x39, 0x55, 0x55, 0x55, 0x59,
  166.   0x39, 0x54, 0x54, 0x54, 0x59,
  167.   0x39, 0x55, 0x54, 0x54, 0x58,
  168.   0x00, 0x00, 0x45, 0x7C, 0x41,
  169.   0x00, 0x02, 0x45, 0x7D, 0x42,
  170.   0x00, 0x01, 0x45, 0x7C, 0x40,
  171.   0x7D, 0x12, 0x11, 0x12, 0x7D, // A-umlaut
  172.   0xF0, 0x28, 0x25, 0x28, 0xF0,
  173.   0x7C, 0x54, 0x55, 0x45, 0x00,
  174.   0x20, 0x54, 0x54, 0x7C, 0x54,
  175.   0x7C, 0x0A, 0x09, 0x7F, 0x49,
  176.   0x32, 0x49, 0x49, 0x49, 0x32,
  177.   0x3A, 0x44, 0x44, 0x44, 0x3A, // o-umlaut
  178.   0x32, 0x4A, 0x48, 0x48, 0x30,
  179.   0x3A, 0x41, 0x41, 0x21, 0x7A,
  180.   0x3A, 0x42, 0x40, 0x20, 0x78,
  181.   0x00, 0x9D, 0xA0, 0xA0, 0x7D,
  182.   0x3D, 0x42, 0x42, 0x42, 0x3D, // O-umlaut
  183.   0x3D, 0x40, 0x40, 0x40, 0x3D,
  184.   0x3C, 0x24, 0xFF, 0x24, 0x24,
  185.   0x48, 0x7E, 0x49, 0x43, 0x66,
  186.   0x2B, 0x2F, 0xFC, 0x2F, 0x2B,
  187.   0xFF, 0x09, 0x29, 0xF6, 0x20,
  188.   0xC0, 0x88, 0x7E, 0x09, 0x03,
  189.   0x20, 0x54, 0x54, 0x79, 0x41,
  190.   0x00, 0x00, 0x44, 0x7D, 0x41,
  191.   0x30, 0x48, 0x48, 0x4A, 0x32,
  192.   0x38, 0x40, 0x40, 0x22, 0x7A,
  193.   0x00, 0x7A, 0x0A, 0x0A, 0x72,
  194.   0x7D, 0x0D, 0x19, 0x31, 0x7D,
  195.   0x26, 0x29, 0x29, 0x2F, 0x28,
  196.   0x26, 0x29, 0x29, 0x29, 0x26,
  197.   0x30, 0x48, 0x4D, 0x40, 0x20,
  198.   0x38, 0x08, 0x08, 0x08, 0x08,
  199.   0x08, 0x08, 0x08, 0x08, 0x38,
  200.   0x2F, 0x10, 0xC8, 0xAC, 0xBA,
  201.   0x2F, 0x10, 0x28, 0x34, 0xFA,
  202.   0x00, 0x00, 0x7B, 0x00, 0x00,
  203.   0x08, 0x14, 0x2A, 0x14, 0x22,
  204.   0x22, 0x14, 0x2A, 0x14, 0x08,
  205.   0x55, 0x00, 0x55, 0x00, 0x55, // #176 (25% block) missing in old code
  206.   0xAA, 0x55, 0xAA, 0x55, 0xAA, // 50% block
  207.   0xFF, 0x55, 0xFF, 0x55, 0xFF, // 75% block
  208.   0x00, 0x00, 0x00, 0xFF, 0x00,
  209.   0x10, 0x10, 0x10, 0xFF, 0x00,
  210.   0x14, 0x14, 0x14, 0xFF, 0x00,
  211.   0x10, 0x10, 0xFF, 0x00, 0xFF,
  212.   0x10, 0x10, 0xF0, 0x10, 0xF0,
  213.   0x14, 0x14, 0x14, 0xFC, 0x00,
  214.   0x14, 0x14, 0xF7, 0x00, 0xFF,
  215.   0x00, 0x00, 0xFF, 0x00, 0xFF,
  216.   0x14, 0x14, 0xF4, 0x04, 0xFC,
  217.   0x14, 0x14, 0x17, 0x10, 0x1F,
  218.   0x10, 0x10, 0x1F, 0x10, 0x1F,
  219.   0x14, 0x14, 0x14, 0x1F, 0x00,
  220.   0x10, 0x10, 0x10, 0xF0, 0x00,
  221.   0x00, 0x00, 0x00, 0x1F, 0x10,
  222.   0x10, 0x10, 0x10, 0x1F, 0x10,
  223.   0x10, 0x10, 0x10, 0xF0, 0x10,
  224.   0x00, 0x00, 0x00, 0xFF, 0x10,
  225.   0x78, 0x14, 0x16, 0x15, 0x78,
  226.   0x10, 0x10, 0x10, 0xFF, 0x10,
  227.   0x00, 0x00, 0x00, 0xFF, 0x14,
  228.   0x00, 0x00, 0xFF, 0x00, 0xFF,
  229.   0x00, 0x00, 0x1F, 0x10, 0x17,
  230.   0x00, 0x00, 0xFC, 0x04, 0xF4,
  231.   0x14, 0x14, 0x17, 0x10, 0x17,
  232.   0x7C, 0x54, 0x56, 0x55, 0x44,
  233.   0x00, 0x00, 0xFF, 0x00, 0xF7,
  234.   0x14, 0x14, 0x14, 0x14, 0x14,
  235.   0x14, 0x14, 0xF7, 0x00, 0xF7,
  236.   0x14, 0x14, 0x14, 0x17, 0x14,
  237.   0x10, 0x10, 0x1F, 0x10, 0x1F,
  238.   0x14, 0x14, 0x14, 0xF4, 0x14,
  239.   0x10, 0x10, 0xF0, 0x10, 0xF0,
  240.   0x00, 0x00, 0x1F, 0x10, 0x1F,
  241.   0x00, 0x00, 0x00, 0x1F, 0x14,
  242.   0x00, 0x00, 0x00, 0xFC, 0x14,
  243.   0x00, 0x00, 0xF0, 0x10, 0xF0,
  244.   0x3C, 0x43, 0x42, 0x43, 0x3C,
  245.   0x14, 0x14, 0x14, 0xFF, 0x14,
  246.   0x10, 0x10, 0x10, 0x1F, 0x00,
  247.   0x00, 0x00, 0x00, 0xF0, 0x10,
  248.   0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  249.   0x3F, 0x40, 0x40, 0x40, 0x3F,//38
  250.   0xFF, 0xFF, 0xFF, 0x00, 0x00,
  251.   0x00, 0x00, 0x00, 0xFF, 0xFF,
  252.   0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
  253.   0x38, 0x44, 0x44, 0x38, 0x44,
  254.   0x20, 0x54, 0x56, 0x79, 0x40,
  255.   0x7E, 0x02, 0x02, 0x06, 0x06,
  256.   0x20, 0x54, 0x56, 0x79, 0x40,
  257.   0x63, 0x55, 0x49, 0x41, 0x63,
  258.   0x38, 0x44, 0x44, 0x3C, 0x04,
  259.   0x40, 0x7E, 0x20, 0x1E, 0x20,
  260.   0x06, 0x02, 0x7E, 0x02, 0x02,
  261.   0x99, 0xA5, 0xE7, 0xA5, 0x99,
  262.   0x38, 0x54, 0x56, 0x55, 0x18,
  263.   0x4C, 0x72, 0x01, 0x72, 0x4C,
  264.   0x30, 0x4A, 0x4D, 0x4D, 0x30,
  265.   0x30, 0x48, 0x78, 0x48, 0x30,
  266.   0x00, 0x44, 0x7F, 0x41, 0x00,
  267.   0x3E, 0x49, 0x49, 0x49, 0x00,
  268.   0x7E, 0x01, 0x01, 0x01, 0x7E,
  269.   0x2A, 0x2A, 0x2A, 0x2A, 0x2A,
  270.   0x44, 0x44, 0x5F, 0x44, 0x44,
  271.   0x40, 0x51, 0x4A, 0x44, 0x40,
  272.   0x38, 0x44, 0x46, 0x45, 0x38,
  273.   0x00, 0x00, 0xFF, 0x01, 0x03,
  274.   0xE0, 0x80, 0xFF, 0x00, 0x00,
  275.   0x38, 0x45, 0x44, 0x45, 0x38,
  276.   0x36, 0x12, 0x36, 0x24, 0x36,
  277.   0x06, 0x0F, 0x09, 0x0F, 0x06,
  278.   0x00, 0x00, 0x18, 0x18, 0x00,
  279.   0x3C, 0x40, 0x42, 0x21, 0x7C,
  280.   0x3C, 0x42, 0x41, 0x22, 0x7D,
  281.   0x00, 0x1F, 0x01, 0x01, 0x1E,
  282.   0x00, 0x19, 0x1D, 0x17, 0x12,
  283.   0x00, 0x3C, 0x3C, 0x3C, 0x3C,
  284.   0x00, 0x00, 0x00, 0x00, 0x00  
  285. };
  286.  
  287. byte once = 1;
  288. unsigned char x;
  289. unsigned char x1;
  290. unsigned char x2;
  291. unsigned char x3;
  292. unsigned char x4;
  293. unsigned char x5;
  294. unsigned char x6;
  295. unsigned char x7;
  296. unsigned char x8;
  297. unsigned char x9;
  298. unsigned char x10;
  299. unsigned char x11;
  300. unsigned char x12;
  301. unsigned int by;
  302. unsigned int by1;
  303. unsigned int by2;
  304. unsigned int by3;
  305. unsigned int by4;
  306. unsigned int by5;
  307. unsigned int by6;
  308. unsigned int by7;
  309. unsigned int by8;
  310. unsigned int by9;
  311. unsigned int by10;
  312. unsigned int by11;
  313. unsigned int by12;
  314. //ws2812b<D,6>  LEDstrip;
  315. ws2812b<E,4>  LEDstrip;
  316. //sk6812<D,6>   LEDstrip;
  317. //sk6812b<D,6>  LEDstrip;
  318. //apa104<D,6>   LEDstrip;
  319. //apa106<D,6>   LEDstrip;
  320. //apa102<D,6,D,5>  LEDstrip;
  321.  
  322. hbgr  pixels[numPixels] = {};
  323. //grb  pixels[numPixels] = {};
  324. //grbw  pixels[numPixels] = {}
  325. char sd[1023];
  326.  
  327. unsigned int poss;
  328. unsigned int poss1;
  329. unsigned int poss2;
  330. unsigned int poss3;
  331. unsigned int poss4;
  332. unsigned int poss5;
  333. unsigned int poss6;
  334. unsigned int poss7;
  335. unsigned int poss8;
  336. unsigned int poss9;
  337. unsigned int poss10;
  338. unsigned int poss11;
  339. unsigned int poss12;
  340. unsigned int posx;
  341. unsigned int posy;
  342. unsigned int count=0;
  343.  
  344. int co;
  345. int coold;
  346. int val;
  347. int val1;
  348. int mode = 0;
  349. int q=0;
  350. int st = 0;
  351. ////////////////////////////////////////////////////////////////////////////
  352. void setup()
  353. {
  354.   pinMode(12, INPUT_PULLUP);
  355.   pinMode(11, INPUT_PULLUP);
  356.   pinMode(10, INPUT_PULLUP);
  357.   pinMode(9, INPUT_PULLUP);
  358.   pinMode(8, INPUT_PULLUP);
  359.   pinMode(7, INPUT_PULLUP);
  360.   pinMode(6, INPUT_PULLUP);
  361.   delay(100);
  362.  
  363.   Serial.begin(115200);
  364.   delay(100);
  365.   val=digitalRead(12);
  366.   mode=digitalRead(11);
  367.   mode=0;
  368.   if(val>0) {
  369.  
  370.   int e1 = digitalRead(10);
  371.   int e2 = digitalRead(9);
  372.   int e3 = digitalRead(8);
  373.   int e4 = digitalRead(7);
  374.   int e5 = digitalRead(6);
  375.   effect = e1+2*e2+4*e3+8*e4+16*e5;
  376.    effect=10;
  377. }
  378.  
  379.   Serial.print("Initializing SD card...");
  380.  
  381.   if (!SD.begin(chipSelect)) {
  382.     Serial.println("Card failed, or not present");
  383.     return;
  384.   }
  385.   Serial.println("card initialized.");
  386.  
  387.  for (pos = 0; pos < numPixels; pos++) {
  388.     pixels[pos].h = 0xFF; // hgrb has h field
  389.     pixels[pos].g = 0;
  390.     pixels[pos].b = 0;
  391.     pixels[pos].r = 0;
  392.     //pixels[pos].w = 0; // grbw has w field
  393.   }
  394.  
  395.   // Clear display
  396.   LEDstrip.sendPixels(numPixels,pixels);
  397.   LEDstrip.refresh(); // Hack: needed for apa102 to display last pixels
  398.   q=0;
  399.   sdread();
  400.  
  401. }
  402. void loop()
  403.   {
  404.   if(mode==0) {
  405.  
  406. byte rt=50;
  407. byte gt=00;
  408. byte bt=00;
  409.  
  410. byte rt1=50;
  411. byte gt1=10;
  412. byte bt1=10;
  413.  
  414. byte rt2=50;
  415. byte gt2=00;
  416. byte bt2=20;
  417.  
  418. byte rt3=20;
  419. byte gt3=40;
  420. byte bt3=10;
  421.  
  422. byte rt4=40;
  423. byte gt4=20;
  424. byte bt4=10;
  425.  
  426. byte rt5=10;
  427. byte gt5=50;
  428. byte bt5=0;
  429.  
  430. byte rt6=00;
  431. byte gt6=50;
  432. byte bt6=0;
  433.  
  434. byte rt7=00;
  435. byte gt7=50;
  436. byte bt7=10;
  437.  
  438. byte rt8=00;
  439. byte gt8=40;
  440. byte bt8=20;
  441.  
  442. byte rt9=00;
  443. byte gt9=20;
  444. byte bt9=40;
  445.  
  446. byte rt10=00;
  447. byte gt10=00;
  448. byte bt10=50;
  449.  
  450. byte rt11=40;
  451. byte gt11=40;
  452. byte bt11=40;
  453.  
  454. byte bh = 0;
  455. byte gh = 0;
  456. byte rh = 0;
  457.  
  458. //Serial.println(q);
  459.  
  460. scene++;
  461. if(scene>= scene1) scene = 0;
  462. Serial.println(scene);
  463.  
  464.  
  465. //////////////////////////////////////////
  466. unsigned char sp;
  467. unsigned char sp1;
  468. unsigned char sp2;
  469. unsigned char sp3;
  470. unsigned char sp4;
  471. unsigned char sp5;
  472. unsigned char sp6;
  473. unsigned char sp7;
  474. unsigned char sp8;
  475. unsigned char sp9;
  476. unsigned char sp10;
  477. unsigned char sp11;
  478. unsigned char sp12;
  479.  
  480. unsigned char sp13 =(sd[scene*12]);
  481. unsigned char sp14=(sd[scene*12+1]);
  482. unsigned char sp15=(sd[scene*12+2]);
  483. unsigned char sp16=(sd[scene*12+3]);
  484. unsigned char sp17=(sd[scene*12+4]);
  485. unsigned char sp18=(sd[scene*12+5]);
  486. unsigned char sp19=(sd[scene*12+6]);
  487. unsigned char sp20=(sd[scene*12+7]);
  488. unsigned char sp21=(sd[scene*12+8]);
  489. unsigned char sp22=(sd[scene*12+9]);
  490. unsigned char sp23=(sd[scene*12+10]);
  491. unsigned char sp24=(sd[scene*12+11]);
  492.  
  493.  
  494. co=0;
  495. for(int shi = line; shi>=0; shi--) {
  496.  
  497. if (shi % 6 == 0) {
  498.  
  499.  switch(co) {
  500.   case 0:
  501.       sp=sp13;
  502.   break;
  503.   case 1:
  504.       sp1= sp14;
  505.   break;
  506.   case 2:
  507.       sp2= sp15;
  508.   break;
  509.   case 3:
  510.       sp3= sp16;
  511.   break;
  512.   case 4:
  513.       sp4= sp17;
  514.   break;
  515.   case 5:
  516.       sp5= sp18;
  517.   break;
  518.   case 6:
  519.       sp6= sp19;
  520.   break;
  521.   case 7:
  522.       sp7= sp20;
  523.   break;
  524.   case 8:
  525.       sp8= sp21;
  526.   break;
  527.   case 9:
  528.       sp9= sp22;
  529.   break;
  530.   case 10:
  531.       sp10= sp23;
  532.   break;
  533.   case 11:
  534.       sp11= sp24;
  535.   break;  
  536.  
  537.   default: break;
  538.  
  539. }
  540.  
  541. co++;
  542. }
  543.  
  544.   st=0;
  545.  
  546. for (posy =st; posy < row+st; posy++) {
  547.  
  548. for (posx = 0; posx < 5; posx++) {
  549.  
  550. poss = (posy*line+(posx+shi));
  551.  
  552. if(poss > numPixels ) poss= numPixels;
  553. if(poss < 0 ) poss = 0;
  554.  
  555. poss1 = (posy*line+(posx+shi+6));
  556. if(poss1> numPixels ) poss1= numPixels;
  557. if(poss1 < 0 ) poss1 = 0;
  558.  
  559. poss2 = (posy*line+(posx+shi+12));
  560. if(poss2 > numPixels ) poss2= numPixels;
  561. if(poss2 < 0 ) poss2 = 0;
  562.  
  563. poss3 = (posy*line+(posx+shi+18));
  564. if(poss3> numPixels ) poss3= numPixels;
  565. if(poss3 < 0 ) poss3 = 0;
  566.  
  567. poss4 = (posy*line+(posx+shi+24));
  568. if(poss4> numPixels ) poss4= numPixels;
  569. if(poss4 < 0 ) poss4= 0;
  570.  
  571. poss5 = posy*line+(posx+shi+30);
  572. if(poss5> numPixels ) poss5= numPixels;
  573. if(poss5 < 0 ) poss5= 0;
  574.  
  575. poss6 = posy*line+(posx+shi+36);
  576. if(poss6> numPixels ) poss6= numPixels;
  577. if(poss6 < 0 ) poss6= 0;
  578.  
  579. poss7 = posy*line+(posx+shi+42);
  580. if(poss7> numPixels ) poss7= numPixels;
  581. if(poss7 < 0 ) poss7= 0;
  582.  
  583. poss8 = posy*line+(posx+shi+48);
  584. if(poss8> numPixels ) poss8= numPixels;
  585. if(poss8 < 0 ) poss8= 0;
  586.  
  587. poss9 = posy*line+(posx+shi+54);
  588. if(poss9> numPixels ) poss9= numPixels;
  589. if(poss9 < 0 ) poss9= 0;
  590.  
  591. poss10 = posy*line+(posx+shi+60);
  592. if(poss10> numPixels ) poss10= numPixels;
  593. if(poss10 < 0 ) poss10= 0;
  594.  
  595. poss11 = posy*line+(posx+shi+66);
  596. if(poss11> numPixels ) poss11= numPixels;
  597. if(poss11 < 0 ) poss11= 0;
  598.  switch(posx){
  599. case 0:
  600. by =  font[sp*5];
  601. by1 =  font[sp1*5];
  602. by2 =  font[sp2*5];
  603. by3 =  font[sp3*5];
  604. by4 =  font[sp4*5];
  605. by5 =  font[sp5*5];
  606. by6 =  font[sp6*5];
  607. by7 =  font[sp7*5];
  608. by8 =  font[sp8*5];
  609. by9 =  font[sp9*5];
  610. by10 =  font[sp10*5];
  611. by11 =  font[sp11*5];
  612.  
  613. break;
  614. case 1:
  615. by = font[sp*5+1];
  616. by1 = font[sp1*5+1];
  617. by2 = font[sp2*5+1];
  618. by3 = font[sp3*5+1];
  619. by4 = font[sp4*5+1];
  620. by5 = font[sp5*5+1];
  621. by6 = font[sp6*5+1];
  622. by7 = font[sp7*5+1];
  623. by8 = font[sp8*5+1];
  624. by9 = font[sp9*5+1];
  625. by10 = font[sp10*5+1];
  626. by11 = font[sp11*5+1];
  627.  
  628. break;
  629. case 2:
  630. by = font[sp*5+2];
  631. by1 = font[sp1*5+2];
  632. by2 = font[sp2*5+2];
  633. by3 = font[sp3*5+2];
  634. by4 = font[sp4*5+2];
  635. by5 = font[sp5*5+2];
  636. by6 = font[sp6*5+2];
  637. by7 = font[sp7*5+2];
  638. by8 = font[sp8*5+2];
  639. by9 = font[sp9*5+2];
  640. by10 = font[sp10*5+2];
  641. by11 = font[sp11*5+2];
  642.  
  643. break;
  644. case 3:
  645. by = font[sp*5+3];
  646. by1 = font[sp1*5+3];
  647. by2 = font[sp2*5+3];
  648. by3 = font[sp3*5+3];
  649. by4 = font[sp4*5+3];
  650. by5 = font[sp5*5+3];
  651. by6 = font[sp6*5+3];
  652. by7 = font[sp7*5+3];
  653. by8 = font[sp8*5+3];
  654. by9 = font[sp9*5+3];
  655. by10 = font[sp10*5+3];
  656. by11 = font[sp11*5+3];
  657.  
  658. break;
  659. case 4:
  660. by =  font[sp*5+4];
  661. by1 =  font[sp1*5+4];
  662. by2 =  font[sp2*5+4];
  663. by3 =  font[sp3*5+4];
  664. by4 =  font[sp4*5+4];
  665. by5 =  font[sp5*5+4];
  666. by6 =  font[sp6*5+4];
  667. by7 =  font[sp7*5+4];
  668. by8 =  font[sp8*5+4];
  669. by9 =  font[sp9*5+4];
  670. by10 =  font[sp10*5+4];
  671. by11 =  font[sp11*5+4];
  672.  
  673. break;
  674.  
  675. default:
  676.  
  677. break;
  678.  
  679.  }
  680.  
  681.     x=bitRead(by,7-posy);
  682.     x1=bitRead(by1,7-posy);
  683.     x2=bitRead(by2,7-posy);
  684.     x3=bitRead(by3,7-posy);
  685.     x4=bitRead(by4,7-posy);
  686.     x5=bitRead(by5,7-posy);
  687.     x6=bitRead(by6,7-posy);
  688.     x7=bitRead(by7,7-posy);
  689.     x8=bitRead(by8,7-posy);
  690.     x9=bitRead(by9,7-posy);
  691.     x10=bitRead(by10,7-posy);
  692.     x11=bitRead(by11,7-posy);
  693.  
  694.     if(x != 0){
  695.      
  696.     pixels[poss].g = gt;
  697.     pixels[poss].b = bt;
  698.     pixels[poss].r = rt;
  699.     if(by>31) {
  700.     pixels[poss+1].g = gh;
  701.     pixels[poss+1].b = bh;
  702.     pixels[poss+1].r = rh;
  703.     }
  704.    
  705.     }
  706.      
  707.    else
  708.    {
  709.     pixels[poss].g = gh;
  710.     pixels[poss].b = bh;
  711.     pixels[poss].r = rh;  
  712.    }
  713.  
  714.     if(x1 != 0){
  715.      
  716.     pixels[poss1].g = gt1;
  717.     pixels[poss1].b = bt1;
  718.     pixels[poss1].r = rt1;
  719.     if(by1>31) {
  720.     pixels[poss1+1].g = gh;
  721.     pixels[poss1+1].b = bh;
  722.     pixels[poss1+1].r = rh;
  723.     }
  724.    
  725.     }
  726.      
  727.    else
  728.    {
  729.     pixels[poss1].g = gh;
  730.     pixels[poss1].b = bh;
  731.     pixels[poss1].r = rh;  
  732.    }
  733.  
  734.     if(x2 != 0){
  735.      
  736.     pixels[poss2].g = gt2;
  737.     pixels[poss2].b = bt2;
  738.     pixels[poss2].r = rt2;
  739.     if(by2>31) {
  740.     pixels[poss2+1].g = gh;
  741.     pixels[poss2+1].b = bh;
  742.     pixels[poss2+1].r = rh;
  743.     }
  744.    
  745.     }
  746.      
  747.    else
  748.    {
  749.     pixels[poss2].g = gh;
  750.     pixels[poss2].b = bh;
  751.     pixels[poss2].r = rh;  
  752.    }
  753.  
  754.     if(x3 != 0){
  755.      
  756.     pixels[poss3].g = gt3;
  757.     pixels[poss3].b = bt3;
  758.     pixels[poss3].r = rt3;
  759.     if(by3>31) {
  760.     pixels[poss3+1].g = gh;
  761.     pixels[poss3+1].b = bh;
  762.     pixels[poss3+1].r = rh;
  763.     }
  764.    
  765.     }
  766.      
  767.    else
  768.    {
  769.     pixels[poss3].g = gh;
  770.     pixels[poss3].b = bh;
  771.     pixels[poss3].r = rh;  
  772.    }
  773.  
  774.     if(x4 != 0){
  775.      
  776.     pixels[poss4].g = gt4;
  777.     pixels[poss4].b = bt4;
  778.     pixels[poss4].r = rt4;
  779.     if(by4>31) {
  780.     pixels[poss4+1].g = gh;
  781.     pixels[poss4+1].b = bh;
  782.     pixels[poss4+1].r = rh;
  783.     }
  784.    
  785.     }
  786.      
  787.    else
  788.    {
  789.     pixels[poss4].g = gh;
  790.     pixels[poss4].b = bh;
  791.     pixels[poss4].r = rh;  
  792.    }
  793.  
  794.     if(x5 != 0){
  795.      
  796.     pixels[poss5].g = gt5;
  797.     pixels[poss5].b = bt5;
  798.     pixels[poss5].r = rt5;
  799.     if(by5>31) {
  800.     pixels[poss5+1].g = gh;
  801.     pixels[poss5+1].b = bh;
  802.     pixels[poss5+1].r = rh;
  803.     }
  804.    
  805.     }
  806.      
  807.    else
  808.    {
  809.     pixels[poss5].g = gh;
  810.     pixels[poss5].b = bh;
  811.     pixels[poss5].r = rh;  
  812.    }
  813.  
  814.     if(x6 != 0){
  815.      
  816.     pixels[poss6].g = gt6;
  817.     pixels[poss6].b = bt6;
  818.     pixels[poss6].r = rt6;
  819.     if(by6>31) {
  820.     pixels[poss6+1].g = gh;
  821.     pixels[poss6+1].b = bh;
  822.     pixels[poss6+1].r = rh;
  823.     }
  824.    
  825.     }
  826.      
  827.    else
  828.    {
  829.     pixels[poss6].g = gh;
  830.     pixels[poss6].b = bh;
  831.     pixels[poss6].r = rh;  
  832.    }
  833.    
  834.     if(x7 != 0){
  835.      
  836.     pixels[poss7].g = gt7;
  837.     pixels[poss7].b = bt7;
  838.     pixels[poss7].r = rt7;
  839.     if(by7>31) {
  840.     pixels[poss7+1].g = gh;
  841.     pixels[poss7+1].b = bh;
  842.     pixels[poss7+1].r = rh;
  843.     }
  844.    
  845.     }
  846.      
  847.    else
  848.    {
  849.     pixels[poss7].g = gh;
  850.     pixels[poss7].b = bh;
  851.     pixels[poss7].r = rh;  
  852.    }
  853.  
  854.     if(x8 != 0){
  855.      
  856.     pixels[poss8].g = gt8;
  857.     pixels[poss8].b = bt8;
  858.     pixels[poss8].r = rt8;
  859.     if(by8>31) {
  860.     pixels[poss8+1].g = gh;
  861.     pixels[poss8+1].b = bh;
  862.     pixels[poss8+1].r = rh;
  863.     }
  864.    
  865.     }
  866.      
  867.    else
  868.    {
  869.     pixels[poss8].g = gh;
  870.     pixels[poss8].b = bh;
  871.     pixels[poss8].r = rh;  
  872.    }
  873.    
  874.     if(x9 != 0){
  875.      
  876.     pixels[poss9].g = gt9;
  877.     pixels[poss9].b = bt9;
  878.     pixels[poss9].r = rt9;
  879.     if(by9>31) {
  880.     pixels[poss9+1].g = gh;
  881.     pixels[poss9+1].b = bh;
  882.     pixels[poss9+1].r = rh;
  883.     }
  884.    
  885.     }
  886.      
  887.    else
  888.    {
  889.     pixels[poss9].g = gh;
  890.     pixels[poss9].b = bh;
  891.     pixels[poss9].r = rh;  
  892.    }
  893.    
  894.     if(x10 != 0){
  895.      
  896.     pixels[poss10].g = gt10;
  897.     pixels[poss10].b = bt10;
  898.     pixels[poss10].r = rt10;
  899.     if(by10>31) {
  900.     pixels[poss10+1].g = gh;
  901.     pixels[poss10+1].b = bh;
  902.     pixels[poss10+1].r = rh;
  903.     }
  904.    
  905.     }
  906.      
  907.    else
  908.    {
  909.     pixels[poss10].g = gh;
  910.     pixels[poss10].b = bh;
  911.     pixels[poss10].r = rh;  
  912.    }
  913.  
  914.     if(x11 != 0){
  915.      
  916.     pixels[poss11].g = gt11;
  917.     pixels[poss11].b = bt11;
  918.     pixels[poss11].r = rt11;
  919.     if(by11>31) {
  920.     pixels[poss11+1].g = gh;
  921.     pixels[poss11+1].b = bh;
  922.     pixels[poss11+1].r = rh;
  923.     }
  924.    
  925.     }
  926.      
  927.    else
  928.    {
  929.     pixels[poss11].g = gh;
  930.     pixels[poss11].b = bh;
  931.     pixels[poss11].r = rh;  
  932.    }    
  933. }
  934.  
  935. }
  936.  
  937. for(int d2 = 0; d2<row; d2++){
  938. for(int d1 = 67; d1<72; d1++){
  939. int dark = (d2*line+(d1));
  940. if (dark>numPixels) dark=numPixels;
  941. if (dark<0) dark = 0;
  942.     pixels[dark].g = 0;
  943.     pixels[dark].b = 0;
  944.     pixels[dark].r = 0;
  945.  
  946. }
  947. }
  948.  
  949. for(int d2 = 0; d2<row; d2++){
  950. for(int d1 = 0; d1<5; d1++){
  951. int dark = (d2*line+(d1));
  952. if (dark>numPixels) dark=numPixels;
  953. if (dark<0) dark = 0;
  954.     pixels[dark].g = 0;
  955.     pixels[dark].b = 0;
  956.     pixels[dark].r = 0;
  957.  
  958. }
  959. }
  960.  
  961.  
  962.   LEDstrip.sendPixels(numPixels,pixels);
  963.   LEDstrip.refresh();
  964.  
  965. delay(dt);
  966.  
  967. }
  968.  
  969. }
  970.  
  971. //void loop()
  972. if(mode==1)
  973. {
  974.  
  975.  // while(true) {}
  976.   if(effect>0){
  977.   switch(n) {
  978.     case 0:
  979.     playfile = "001.bmp";
  980.     break;
  981.     case 1:
  982.     playfile = "002.bmp";
  983.     break;
  984.     case 2:
  985.     playfile = "003.bmp";
  986.     break;
  987.     case 3:
  988.     playfile = "004.bmp";
  989.     break;
  990.     case 4:
  991.     playfile = "005.bmp";
  992.     break;
  993.     case 5:
  994.     playfile = "006.bmp";
  995.     break;
  996.     case 6:
  997.     playfile = "007.bmp";
  998.     break;
  999.     case 7:
  1000.     playfile = "008.bmp";
  1001.     break;
  1002.     case 8:
  1003.     playfile = "009.bmp";
  1004.     break;
  1005.     case 9:
  1006.     playfile = "010.bmp";
  1007.     break;
  1008.     case 10:
  1009.     playfile = "011.bmp";
  1010.     break;
  1011.     case 11:
  1012.     playfile = "012.bmp";
  1013.     break;
  1014.     case 12:
  1015.     playfile = "013.bmp";
  1016.     break;
  1017.     case 13:
  1018.     playfile = "014.bmp";
  1019.     break;
  1020.     case 14:
  1021.     playfile = "015.bmp";
  1022.     break;
  1023.     case 15:
  1024.     playfile = "016.bmp";
  1025.     break;
  1026.     case 16:
  1027.     playfile = "017.bmp";
  1028.     break;
  1029.     case 17:
  1030.     playfile = "018.bmp";
  1031.     break;
  1032.     case 18:
  1033.     playfile = "019.bmp";
  1034.     break;
  1035.     case 19:
  1036.     playfile = "020.bmp";
  1037.     break;
  1038.  
  1039.     case 20:
  1040.     playfile = "021.bmp";
  1041.     break;
  1042.  
  1043.     case 21:
  1044.     playfile = "022.bmp";
  1045.     break;
  1046.  
  1047.     case 22:
  1048.     playfile = "023.bmp";
  1049.     break;
  1050.  
  1051.     case 23:
  1052.     playfile = "024.bmp";
  1053.     break;
  1054.  
  1055.     case 24:
  1056.     playfile = "025.bmp";
  1057.     break;
  1058.  
  1059.     case 25:
  1060.     playfile = "026.bmp";
  1061.     break;
  1062.  
  1063.     case 26:
  1064.     playfile = "027.bmp";
  1065.     break;
  1066.  
  1067.     case 27:
  1068.     playfile = "028.bmp";
  1069.     break;
  1070.  
  1071.     case 28:
  1072.     playfile = "029.bmp";
  1073.     break;
  1074.  
  1075.     case 29:
  1076.     playfile = "030.bmp";
  1077.     break;
  1078.  
  1079.     case 30:
  1080.     playfile = "031.bmp";
  1081.     break;
  1082.  
  1083.     case 31:
  1084.     playfile = "032.bmp";
  1085.     break;
  1086.    
  1087.  
  1088.     default:
  1089.     playfile = "001.bmp";
  1090.   }
  1091.   }
  1092.   else
  1093.   {
  1094.     playfile = "000.bmp";
  1095.   }
  1096.  
  1097.  
  1098.   File dataFile = SD.open(playfile);
  1099.   Serial.println(playfile);
  1100.    
  1101.   if (dataFile) {
  1102.    
  1103.     while (dataFile.available()) {
  1104.      
  1105.       if(m==true) {
  1106.          m=false;
  1107.       for (i = 0; i <  54 ; i++) {
  1108.         dataFile.read();
  1109.        
  1110.       }
  1111.      
  1112.       }
  1113.        
  1114.       for (pos = 0; pos < numPixels ; pos++) {
  1115.       b = dataFile.read();
  1116.       pixels[pos].b = b;
  1117.      
  1118.       g = dataFile.read();
  1119.       pixels[pos].g = g;
  1120.      
  1121.       r =  dataFile.read();
  1122.       pixels[pos].r = r;
  1123.      
  1124.        }
  1125.        
  1126.       LEDstrip.sendPixels(numPixels, pixels);
  1127.       LEDstrip.refresh();
  1128.  
  1129.        
  1130.     }
  1131.     dataFile.close();
  1132.     m=true;
  1133.    
  1134.  
  1135.     //while(true) {}
  1136.   }
  1137.  
  1138.   else {
  1139.     Serial.println("error opening bmp");
  1140.   }
  1141.    n++;
  1142.    if (n>(effect)) n = 0;
  1143.  
  1144.   delay(dt);
  1145.  
  1146.   }
  1147. }
  1148. void sdread() {
  1149. if(once==1) {
  1150.   //once=0;
  1151.  
  1152.   textfile = "text.txt";
  1153.   File textFile = SD.open(textfile);
  1154.    Serial.println(textfile);
  1155.   if (textFile) {
  1156.    
  1157.     while (textFile.available()) {
  1158.       //Serial.write(textFile.read());
  1159.     char tb = textFile.read();
  1160.     sd[q]= tb;
  1161.     q++;
  1162.     if(q>1023) q=1023;
  1163.    
  1164.     }
  1165.    
  1166.     scene = q / 12;
  1167.     int modscene = q % 12;
  1168.     if (modscene > 0) {
  1169.       scene+=1;
  1170.      
  1171.     }
  1172.    
  1173.     scene1 = scene;
  1174.    
  1175.     textFile.close();
  1176.     Serial.println();
  1177.   }
  1178.  
  1179.   else {
  1180.     Serial.println("error opening txt");
  1181.   }
  1182.  
  1183. }
  1184. }
(#) GPeti1977 válasza GPeti1977 hozzászólására (») Nov 6, 2016 /
 
Mondjuk én sem gondoltam komolyan hogy itt valaki válaszolni tud a kérdésemre.
(#) kapu48 válasza GPeti1977 hozzászólására (») Nov 6, 2016 /
 
Szerintem az alsó sor, felülírja a felettelevő számítást:
  1. 375.    effect = e1+2*e2+4*e3+8*e4+16*e5;
  2. 376.    effect=10;


És az összeadásokat Zárójelezni kellen:
  1. effect = (e1+2)*(e2+4)*(e3+8)*(e4+16)*e5;


Melékesen kellene a linkje: #include "FAB_LED.h" ???
Hogy letudjuk futatni, mivel elöbb meg kellene érteni a müködés lényegét!
A hozzászólás módosítva: Nov 6, 2016
(#) GPeti1977 válasza kapu48 hozzászólására (») Nov 6, 2016 /
 
Köszi ez direkt van mert még nincs beforrasztva kapcsoló. A .h is itt van egy oldallal előtte vagy itt:
FAB_LED.h

Egy általános matematikai probléma lehet, csak nem jövök rá hogy mi.
A hozzászólás módosítva: Nov 6, 2016
(#) kapu48 válasza GPeti1977 hozzászólására (») Nov 6, 2016 /
 
Én nem találok linket a projectre!
A Headerekhez általában tartozik C vagy Cpp állomány is! ???
Kellene az egész lib!

Minden új tömb beolvasását intéző for ciklusoknál lehet a hiba. Valószínűleg növeled a sorok számát 1-el.
(#) GPeti1977 válasza kapu48 hozzászólására (») Nov 6, 2016 1 /
 
Igen a .h ban van az a rész is amit a .cpp be szoktak tenni, meg a libbel nem kell foglalkozni, csak a for ciklusokkal.
(#) kapu48 válasza GPeti1977 hozzászólására (») Nov 6, 2016 /
 
"libbel nem kell foglalkozni"
Akkor én itt kiszálok!
(#) GPeti1977 válasza kapu48 hozzászólására (») Nov 6, 2016 /
 
Nem mert ha másra használnád akkor is mennie kellene a számolgatásnak, a lib az jó.
(#) kapu48 válasza GPeti1977 hozzászólására (») Nov 6, 2016 / 1
 
Megírtam előzőleg, hogy a működés megértéséhez kellene a link!
Közben rákerestem a Githubon: Bővebben: Link

És tényleg televan dokumentációval!

Viszont az eddigi segítőkésséged hiánya miatt, én tényleg kiszálltam!
(#) Massawa válasza (Felhasználó 120038) hozzászólására (») Nov 6, 2016 /
 
Megvan a sikerélmény! Ma bedugta az Arduinot egy másik USB portba ( ezt korábban is probálta) és ma egyböl elindult a display. Köszönjük a segitséget.

(#) kapu48 válasza GPeti1977 hozzászólására (») Nov 6, 2016 / 1
 
Az első mérgem elmúltával!
Amit egy egyszerűnek tűnő kérés megkérdőjelezése okozót!
Most már, legalább akit érdekel, megtudhatja, hogy miről van szó.

Második bosszúság forrása volt a program szedésének teljesen olvashatatlansága!
Pl.: Az első if végét is művészet megtalálni! Nem, hogy még a hiba okát!
Az első tanács (Bár az eddigiekből kiindulva tök felesleges lesz!)

600. sortol:
  1. switch(posx){
  2.   case 0:
  3.     by =  font[sp*5];
  4.     by1 =  font[sp1*5];
  5.     by2 =  font[sp2*5];
  6.     by3 =  font[sp3*5];
  7.     by4 =  font[sp4*5];
  8.     by5 =  font[sp5*5];
  9.     by6 =  font[sp6*5];
  10.     by7 =  font[sp7*5];
  11.     by8 =  font[sp8*5];
  12.     by9 =  font[sp9*5];
  13.     by10 =  font[sp10*5];
  14.     by11 =  font[sp11*5];
  15. ….
  16. Switch helyet egyszerűbb lenne csak ennyi:
  17. by =  font[sp*5 + posx];
  18. by1 =  font[sp1*5 + posx];
  19. by2 =  font[sp2*5+ posx];
  20. by3 =  font[sp3*5+ posx];
  21. by4 =  font[sp4*5+ posx];
  22. by5 =  font[sp5*5+ posx];
  23. by6 =  font[sp6*5+ posx];
  24. by7 =  font[sp7*5+ posx];
  25. by8 =  font[sp8*5+ posx];
  26. by9 =  font[sp9*5+ posx];
  27. by10 =  font[sp10*5+ posx];
  28. by11 =  font[sp11*5+ posx];


Egyébként kösz a minuszolást, hogy egyáltalán folakozni próbáltam az olvashatatlan kódodal!
(#) GPeti1977 válasza kapu48 hozzászólására (») Nov 6, 2016 /
 
Köszi ezt mindjárt kipróbálom. Működik ugyanúgy
Ettől nem javult meg de lényegesen rövidebb lett a program.
Pontosan hogyan keressem a hibát? Eddig kiírtam egy csomó változót a soros portra de nem láttam semmi anomáliát.
Egyébként érdemes fényújsággal foglalkozni, már pár éve gondoltam rá hogy készítek, de akkoriban ilyen csodálatos ledszalag nem lévén csak IC temetővel, NYÁK lemezekkel meg rengeteg vezetékkel lehetett volna megoldani, főleg RGB kivitelben, nézem a városban a fényújságokat, legtöbb még ma is csak egyszínű.
A hozzászólás módosítva: Nov 6, 2016
(#) GPeti1977 válasza kapu48 hozzászólására (») Nov 6, 2016 /
 
  1. x=bitRead(by,7-posy);
  2.     x1=bitRead(by1,7-posy);
  3.     x2=bitRead(by2,7-posy);
  4.     x3=bitRead(by3,7-posy);
  5.     x4=bitRead(by4,7-posy);
  6.     x5=bitRead(by5,7-posy);
  7.     x6=bitRead(by6,7-posy);
  8.     x7=bitRead(by7,7-posy);
  9.     x8=bitRead(by8,7-posy);
  10.     x9=bitRead(by9,7-posy);
  11.     x10=bitRead(by10,7-posy);
  12.     x11=bitRead(by11,7-posy);


Ebben a részben döntődik el hogy y irányba milyen magasan legyenek a karakterek, a 7- azért kell mert akkor fordítva írja ki a karaktereket.
(#) (Felhasználó 120038) válasza Massawa hozzászólására (») Nov 6, 2016 /
 
Király!

Erre nem gondoltam, pedig velem is előfordult párszor.

Amúgy melyik megoldással megy? A régebbi sokparaméteressel, vagy az enyémmel? Szerintem mindegyikkel mennie kell, mivel kiderítettük, hogy az enyémbe is benne vannak azok a paraméterek, csak a lib-ben.
(#) Massawa válasza (Felhasználó 120038) hozzászólására (») Nov 6, 2016 /
 
Mindegyikkel, s már dolgozik a valodi feladaton ( léptetömotor vezérlés és ennek a kijelzése a displayen).

Kiváncsi leszek mikor készül el. A motor már forog, igy csak a köret hiányzik.....
(#) GPeti1977 válasza GPeti1977 hozzászólására (») Nov 6, 2016 /
 
Közben ezt a kódot kicseréltem erre, szintén csak kisebb lett, de maradt a hiba:
  1. x=(by<<posy)&0b10000000;
  2.   x1=(by1<<posy)&0b10000000;
  3.   x2=(by2<<posy)&0b10000000;
  4.   x3=(by3<<posy)&0b10000000;
  5.   x4=(by4<<posy)&0b10000000;
  6.   x5=(by5<<posy)&0b10000000;
  7.   x6=(by6<<posy)&0b10000000;
  8.   x7=(by7<<posy)&0b10000000;
  9.   x8=(by8<<posy)&0b10000000;
  10.   x9=(by9<<posy)&0b10000000;
  11.   x10=(by10<<posy)&0b10000000;
  12.   x11=(by11<<posy)&0b10000000;
(#) kapu48 válasza GPeti1977 hozzászólására (») Nov 6, 2016 /
 
  1. LEDstrip.sendPixels(numPixels,pixels);
  2.                 LEDstrip.refresh();  // <<<<< Talán ez a sor felesleges?????????
  3.  
  4.                 delay(dt);
  5.  
  6.         }
  7.  
  8. }
  9.  
  10. //void loop()


Mivel az meghívja ezt a rutint:
  1. ////////////////////////////////////////////////////////////////////////
  2.         /// @brief Sends N uint32_t in a row set to zero or 0xFFFFFFFF, to build
  3.         /// a frame for each pixel, and for a whole strip, SPI protocol only
  4.         ////////////////////////////////////////////////////////////////////////
  5.         static inline void
  6.         spiSoftwareSendFrame(const uint16_t count, bool high)
  7.         __attribute__ ((always_inline));

Ami beszúr 1 üres sort!

(Vagy lejjebb kel 1 }-jellel.)
A hozzászólás módosítva: Nov 6, 2016
(#) GPeti1977 válasza kapu48 hozzászólására (») Nov 6, 2016 /
 
Köszi tényleg nem kell, képzeld újra tudtam egyszerűsíteni pl:
x=((font[sp*5 + posx])<<posy)&0x80;

Már írtam több shiftelést is, de azt le kell videóznom, ha betűnként és nem soronként lépegetek akkor nem jó még mindig viszont ha az egész szövegenként történik a kiírás akkor nem tolódik a magasság.
Sajnos ennyire nem értek a C hez eddig magamtól tanultam amit tudok de most járok 2 évig szoftverfejlesztő tanfolyamra remélem a végére már ezeket is vágni fogom:
static inline void
spiSoftwareSendFrame(const uint16_t count, bool high)
__attribute__ ((always_inline));
(#) kapu48 válasza GPeti1977 hozzászólására (») Nov 6, 2016 /
 
Mondjuk itt elég lett volna a megjegyzést értelmezni:
Idézet:
„/// @brief Sends N uint32_t in a row set to zero or 0xFFFFFFFF, to build
/// a frame for each pixel, and for a whole strip, SPI protocol only”


Hogy tudjad, mit csinál az a sor!
(#) GPeti1977 válasza kapu48 hozzászólására (») Nov 6, 2016 /
 
Amit használva van az csak ASM ben írt bitbang, a héten megpróbálom PIC32 SPI portjaival is feléleszteni a LED szalagot.
(#) kapu48 válasza GPeti1977 hozzászólására (») Nov 7, 2016 /
 
Gondolom, szép gyorsulást értél el, futásidőben?
(#) kapu48 válasza GPeti1977 hozzászólására (») Nov 7, 2016 /
 
PIC32 nem érdekel!

Inkább erre jó lenne átírni: Bővebben: Mini STM32

Mivel ezt már az Arduino is tudja kezelni!
A hozzászólás módosítva: Nov 7, 2016
(#) andyka hozzászólása Nov 9, 2016 /
 
Hello
Ezzel az LCD-vel UNO-ra csatolva lefuttattam az „MCUFRIEND_kbv” lib „LCD_ID_readreg” kodjat es a kovetkezoket kaptam vissza a soros monitoron
  1. Read Registers on MCUFRIEND UNO shield
  2. controllers either read as single 16-bit
  3. e.g. the ID is at readReg(0)
  4. or as a sequence of 8-bit values
  5. in special locations (first is dummy)
  6.  
  7. reg(0x0000) 00 00       ID: ILI9320, ILI9325, ILI9335, ...
  8. reg(0x0004) 54 54 80 66 Manufacturer ID
  9. reg(0x0009) 00 00 61 00 00      Status Register
  10. reg(0x000A) 08 08       Get Powsr Mode
  11. reg(0x000C) 66 66       Get Pixel Format
  12. reg(0x0061) 00 00       RDID1 HX8347-G
  13. reg(0x0062) 00 00       RDID2 HX8347-G
  14. reg(0x0063) 00 00       RDID3 HX8347-G
  15. reg(0x0064) 00 00       RDID1 HX8347-A
  16. reg(0x0065) 00 00       RDID2 HX8347-A
  17. reg(0x0066) 00 00       RDID3 HX8347-A
  18. reg(0x0067) 00 00       RDID Himax HX8347-A
  19. reg(0x0070) 00 00       Panel Himax HX8347-A
  20. reg(0x00A1) 00 00 00 00 00      RD_DDB SSD1963
  21. reg(0x00B0) 00 00       RGB Interface Signal Control
  22. reg(0x00B4) 00 00       Inversion Control
  23. reg(0x00B6) 02 02 02 3B 00      Display Control
  24. reg(0x00B7) 06 06       Entry Mode Set
  25. reg(0x00BF) FF FF 68 14 00 FF   ILI9481, HX8357-B
  26. reg(0x00C0) 0E 0E 0E 00 00 00 00 00 00  Panel Control
  27. reg(0x00C8) 00 00 00 00 00 00 00 00 00 00 00 00 00      GAMMA
  28. reg(0x00CC) 00 00       Panel Control
  29. reg(0x00D0) 00 00 00    Power Control
  30. reg(0x00D2) 00 00 00 00 00      NVM Read
  31. reg(0x00D3) 00 00 94 86 ILI9341, ILI9488
  32. reg(0x00DA) 54 54       RDID1
  33. reg(0x00DB) 80 80       RDID2
  34. reg(0x00DC) 66 66       RDID3
  35. reg(0x00E0) 00 00 54 07 44 05 08 00 54 07 44 05 08 44 44 00     GAMMA-P
  36. reg(0x00E1) 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00     GAMMA-N
  37. reg(0x00EF) 00 00 00 00 00 00   ILI9327
  38. reg(0x00F2) 00 00 00 00 00 00 00 00 00 00 00 00 Adjust Control 2
  39. reg(0x00F6) 00 00 00 00 Interface Control

A kerdesem az lenne hogy akkor most milyen vezerlesu az LCD-m ?,
9320, 9325, 9335 vagy 9327, 9341, vagy tenyleg ILI9488 ?
(#) TavIR-AVR válasza andyka hozzászólására (») Nov 10, 2016 /
 
A szabványosítás előnyei
Ami ILI9488 az náléam pl. az UTFT-ben ILI9481 ill ILI9486-tal működik (azaz mintha a korábbi chipetr kellene aláhúzni). De volt, hogy a ChipID 0-t adott vissza, ekkor
_nekem kellett megmondani_ hogy az indentifier mi legyen. És azzal működött (ILI9431 ? ha jól emlékszem)

De az eladó mit mond?
A tesztelésem eredménye egy SW gyűjtemény lett, amit innen letölthetsz a kapcsolódó dokumentációk alól.
(#) andykaaa válasza TavIR-AVR hozzászólására (») Nov 11, 2016 /
 
Az elado ILI9488-at mond es 480x320
(#) elektroncso hozzászólása Nov 12, 2016 /
 
Sziasztok.
Valamit kerestem az előbb egy itteni apróhirdetéses oldalon és véletlenül bukkantam rá egy ARDUINO UNO klónra, amit 6€-ért kínálnak (vadonatúj). Szerintetek megéri? Plusz 2€ a posta utánvéttel, 1. osztályon feladva. Így 8€-ból volna egy UNO-m.
Eddig úgy voltam, hogy megvagyok én nélküle, de egyre jobban tetszik, bent a suliban is van, idén elkezdtünk tanulni programozni is (Turbo PASCAL), szóval beruháznék egy UNO-ra. USB B csatlakozóval van szerelve (visszább volt téma, ha jól emlékszem, hogy a micro USB hamar kontakt hibássá válik).
A válaszokat előre is köszönöm.
Ezekre szükség lehet! - HESTORE.HU

SP11/BK OFF-(ON)
SP12/GR
BT108 = BT1
PIC32MX764F128H-I/PT
RT100NT
Következő: »»   289 / 864
Bejelentkezés

Belépés
Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem