[Luke_CZ]

A, když shoří odpor, tak se na 99% přeruší = na pin pošleš rovnou 24V
B, 24V na pinu arduino spolehlivě odpálí

L.

[ArduXPP]

Návod je třeba zde : http://www.instructables.com/id/Getting-Started-With-the-ESP8266-ESP-01/?ALLSTEPS

ale váš modul esp8266 je verze 05, která se dělá ve dvouch verzí , a jedná z nich je podoba esp8266 k verzi 01. Adapter který je na odkazu je určen k verzi 01.
Adapter má už stabilizátor napětí, takže jde připojit k 5V a využít 5V logiku, protože modul je upravený i pro tento účel.

Jinak je postup stejný, arduino uno – esp8266 s adapterem
5V – VCC
gnd – gnd
RX – TX
TX – RX

[hcdady]

Zdravím, jen ještě takový asi hloupý dotaz, když použiji variantu s odporem http://circuits4you.com/2016/05/13/arduino-4-20mamp-current-loop/, která funguje super. Cos se stane s arduinem když shoří odpor? to ho odpálím , a nebo mu ten proud 24 mA nic neudělá i když tam bude 24V.

[Zbyšek Voda]

Také jich mám pár doma a snad všechny v sobě AT firmware měly. Spíše byl problém s rychlostí komunikace. Měl jsem za to, že je tam AT vždy, ale máte asi pravdu, že někdy je Číňan nepředvídatelný.

[Aleš]

V NOVÉM ESP8266-1 je bohužel nahrané cokoliv. Mám jich asi 6ks, a jenom jedno mi nějak odpovídalo na AT příkazy. U ostatních jsem vůbec nezjistil, co je v něm nahrané. Jestli AT fw, nebo nějaký NodeMCU. Takže když přijde nový, tak do něj automaticky nahrávám odzkoušený fw, aniž bych ztrácel čas zkoušením, co v něm vůbec je. V ESP8266-12 V3 bylo myslím dokonce nahrané blikání LEDkou 🙂

[mystriks]

Zrovna řeším to samé, a docetl jsem se ze pri pouziti ssrele a vetsiho vetraku muze dojit k velke zpetne indukci, nebo nemusi kvuli stridavemu napeti fungovat tak jak si predstavujem. pokud to uz nekdo zkousel tak by se rada hodila

[ArduXPP]

Jakou rychlost používáte pro serial ?

[MrApik]

Bohužel, toto zapojení mi nefunguje. Zkoušel jsem i jiný sketche a odpojení GPIO0 od groundu, ale stále nic.

[Zbyšek Voda]

Ano, potom stačí z Arduino programu posílat do ESP tyto AT příkazy přes Serial.println(„“); 🙂

[MrApik]

Děkuji, určitě hned to jdu vyzkoušet. Jinak chápu-li to dobře, do programu arduina pak lze tedy AT zpracovat a naopak do ESP posílat?

[Zbyšek Voda]

Když si necháte to zapojení, které zmiňujete v prvním postu:

ESP8266 –> Arduino Mega ADK
TX –> RX1
RX –> TX1
3V3 –> 3.3V (V Arduinu)
EN –> 3.3V (V Arduinu)
GND –> GND
GPIO0 –> GND

,tak si pak do loop() dejte

while(Serial.available()) Serial1.write(Serial.read());
while(Serial1.available() Serial.write(Serial1.read());

Toto by mělo přeposílat mezi sériovými porty sdílenými s PC a porty RX1 a TX1. Toto mám ozkoušené (dokonce i na ADK) a dá se tak ESP ovládat.

Ty errory, co vám to píše, jsou způsobené tím, že se nahrávací software nedokáže „zkontaktovat“ s EPS8266. Asi za to může to, co psal Aleš.

[MrApik]

Bohužel na AT příkazy ESP nereaguje (myslím připojené přes arduino), jelikož když si otevřu sériový monitor a napíši do něj AT příkaz, nemá to žádnou odezvu. Podle mě je to zapříčiněno stejnou „věcí“ jako jsou ty errory, co mi to hodilo při pokusu updatovat firmware.

[Zbyšek Voda]

Pokud vám jde jen o to, abyste přes ESP připojil Arduino k WiFi, tak je ESP z výroby vybaveno firmware, který přijímá přes sériovou linku AT příkazy, přes které jej lze ovládat. Viz http://www.pridopia.co.uk/pi-doc/ESP8266ATCommandsSet.pdf.

Pak není nutné nijak měnit firmware ESP. Na druhou stranu jsou AT příkazy trochu neohrabané. Existují knihovny, které pracují nad AT příkazy, takže vám ulehčí práci při ovládání ESP – viz například https://github.com/itead/ITEADLIB_Arduino_WeeESP8266.

[Aleš]

WEBserver na Arduinu MEGA udělat půjde. Na internetu se toho najde spousta.
V BR@Y terminálu je potřeba dole zaškrtnout CR=CR+LF

[MrApik]

Aleši, no já to celkem dost zjednodušil, na tom senzoru jsem se hlavně chtěl naučit, jak z arduina púdělat takový malý „server“, přes který by mohli jít dělat různé věci (jakože zhasínat nějakou led v druhém patře, nebo kouknout, jestli bych už to topení v obýváku neměl vypnout).

Takže spíš bych ten můj dotaz upravil na:
Jde z arduina pomocí ESP8266 modulu udělat „server“ ? Nebo je jednodušší programovat přímo ESP8266?

Díky.

[darira]

Zdravím, cca 2 dny jsem zkoušel přehrát na ESP firmware 9.5.2 AT (díky Aleši za návod na xanadu). Napájení jsem měl z externího zdroje, stejný převodník PL2303HX i piny měli definované připojení na Vcc nebo GND podle návodu. Při nahrání firmware jsem se ale vždy zasekl (někdy na 9% nebo 54%, pokaždé jinak). Zkoušel jsem i kondenzátor mezi Vcc a GND podle nějakého jiného návodu. Mezi PC a převodníkem jsem používal cca 1m prodlužovací USB kabel. Po jeho odstranění proběhlo přehrání firmware v pořádku.Vůbec mě nenapadlo, že by to mohlo mít takový vliv na stabilitu přenosu. Třeba to někomu pomůže. Zatím mě ještě neodpovídá terminál BR@Y. Po zadání příkazu se v obou oknech zobrazí zadaný příkaz, žádný výpis OK nebo verze firmwaru. Asi mám něco špatně nastaveno.

Edit: Ten USB kabel používám pro nahrávání do Arduina, vadný není

[Aleš]

Prohlížet údaje z DHT senzoru přes prohlížeč jde. Nejjednodušší asi bude použít server třetích stran, např. Thingspeak. Potom to vypadá např. takto:
https://thingspeak.com/apps/plugins/24693

[Aleš]

To: Zbyšek Voda
Připojit na TX0 a RX0 jde jedině v případě, že se dá vytáhnout procesor z patice. Jinak to nepůjde. Když ho budete držet v resetu, tak piny procesoru, které jsou připojené na RX a TX budou signály někam stahovat (0 nebo 1). Zkoušel jsem i do MEGA nahrát program, který převádí RX/TX0 na RX/TX1. Potom to sice jako převodník funguje, z terminálu se dají zadávat AT příkazy a ESP na ně odpovídá, ale flashnout FW přes to nejde. Zřejmě vadí zpoždění, které vzniká při převodu z jednoho TX/RX na druhý.

[MrApik]

Díky vám za ochotu, můj cíl je ten, abych si mohl údaje z DHT senzoru prohlédnout přes prohlížeč. Podle vašich příspěvků ale nevím, jestli to je vůbec možné.

[Zbyšek Voda]

Dobrý den, teoreticky by to možné bylo. To, čeho chcete dosáhnout, je použití sériového převodníku Ardina pro naprogramování ESP. Určitě tedy musíte mít připojené ESP na piny RX0 a TX0 (ty jsou pro sériovou linku z PC).

Pak je tam ale další problém. Arduino vám bude do programování „kecat“, protože se i ono bude snažit komunikovat přes sériovou linku. Toto se řešilo tuším rezistorem mezi RST a GND u Arduina, ale bohužel se mi teď nedaří najít podrobnosti. Rezistor by měl dočasně vyřadit Atmegu na Arduinu z provozu, aby se nemíchalo do sériovky.

Asi bych vám doporučil pořídit si převodník USB-Serial. Ušetří vám to spoustu starostí 🙂

[Aleš]

Chcete nahrát firmware do ESP8266 přes MEGA? To nejde. Musíte použít převodník USB-TTL.

[mystriks]

tak jsem pouzil spfd5408 akorat touch je nejak otoceny x a y

[mystriks]

pouzil jsem id reader a pri tom se na display objevi jakoby radkovani kazdy druhy pixel.

Initializing LCD…
Reading ID…0x0000
Loading LCD registers…
Filling the screen…
Done filling…
If your screen filled red, you may be able to use the library at http://misc.ws

/*********************************************************************
*
* LCD_ID_Reader
*
* This sketch is meant only to attempt to read the driver ID code
* from inexpensive touchscreen LCDs found on eBay without needing to
* load any additional libraries.  The hope is to identify the most 
* common varieties and choose the best library for the screen you have.
*
* This has been successfully tested so far on 992X and 778X variety
* screens.
*
* Usage: 
*
* Compile the sketch and run it on your board with the screen
* attached.  In the serial monitor, you should see a message containing
* the driver code.  The tricky thing is that if it does not work, the
* results may be undetermined.  However, if we can compile a list,
* the difference between working and not may become more evident.
*
* Please visit http://misc.ws/lcd_information for more information.
*
* Version 1.2 - January 29th, 2015
* 
*********************************************************************/

/*********************************************************************
*
* PIN ASSIGNMENTS
*
* You can alter the pin assignments to reflect any configuration you
* wish.  I've provided the default shield configuration, which works
* on both the Arduino UNO and Mega 2560.
* 
*********************************************************************/
//-- Arduino UNO or Mega 2560 Plugged as shield
#define LCD_RST A4
#define LCD_CS A3
#define LCD_RS A2
#define LCD_WR A1
#define LCD_RD A0

#define LCD_D0 8
#define LCD_D1 9
#define LCD_D2 2
#define LCD_D3 3
#define LCD_D4 4
#define LCD_D5 5
#define LCD_D6 6
#define LCD_D7 7

/*********************************************************************
*
* Attempt to initialize and reset LCD, then read its Driver Code
* at register index 0.
* 
*********************************************************************/
void setup() {
  
  char hexString[7];
  uint16_t id;
  
  Serial.begin(9600);
  Serial.println("Initializing LCD...");
  lcdInit();
  lcdReset();
  
  delay(500);
  
  Serial.print("Reading ID...");
  id = lcdReadID();
  sprintf(hexString, "0x%0.4X", id); 
  Serial.println( hexString );
  
  if( id == 0x7783 ) {
    lcdRegister7783();
    lcdFillScreen(0xF800);
    Serial.println("If your screen filled red, then you may be able to use the library at ;
  } else if( id == 0x0154 ) {
    lcdRegister0154();
    lcdFillScreen(0xF800);
    Serial.println("If your screen filled red, please report it at ;
    Serial.println("There is currently no known working library.");
  } else {
    lcdRegisterOther();
    lcdFillScreen(0xF800);
    Serial.println("If your screen filled red, you may be able to use the library at http://misc.ws");
  } 
  
  //print_all_regs();
}

void print_all_regs() {
  char str[60];
  uint16_t i, val;

  for(i=0; i < 256; i++ )
  {
    delay(40);
    val = lcdReadRegister(i);
    sprintf(str, "Register 0x%0.2X : 0x%0.4X", i, val);
    Serial.println( str );
  }  
}

void loop() {
  
}

/*********************************************************************
*
*   LCD Functions - Inefficient but should be good enough 
*                   to read the ID.
*
*********************************************************************/
void lcdRegister0154() {
  lcdWriteRegister(0x000C, 0x130); 
  lcdWriteRegister(0x0080, 0x8d);
  lcdWriteRegister(0x0092, 0x10);
  lcdWriteRegister(0x0011, 0x1b);
  lcdWriteRegister(0x0012, 0x3101);
  lcdWriteRegister(0x0013, 0x105f);
  lcdWriteRegister(0x0014, 0x667f);
  lcdWriteRegister(0x0010, 0x800);
  delay(20); 
  lcdWriteRegister(0x0011, 0x11b);
  delay(20); 
  lcdWriteRegister(0x0011, 0x31b);
  delay(20); 
  lcdWriteRegister(0x0011, 0x71b);
  delay(20); 
  lcdWriteRegister(0x0011, 0xf1b);
  delay(20); 
  lcdWriteRegister(0x0011, 0xf3b);
  delay(30); 
  lcdWriteRegister(0x0001, 0x2128);
  lcdWriteRegister(0x0002, 0x100);
  lcdWriteRegister(0x0003, 0x1030);
  lcdWriteRegister(0x0007, 0); 
  lcdWriteRegister(0x0008, 0x808);
  lcdWriteRegister(0x000B, 0x1100);
  lcdWriteRegister(0x000F, 0xf01);
  lcdWriteRegister(0x0015, 0);
  lcdWriteRegister(0x0030, 0);
  lcdWriteRegister(0x0034, 319); 
  lcdWriteRegister(0x0035, 0); 
  lcdWriteRegister(0x0036, 239); 
  lcdWriteRegister(0x0037, 0); 
  lcdWriteRegister(0x0038, 319); 
  lcdWriteRegister(0x0039, 0); 
  lcdWriteRegister(0x0050, 0);
  lcdWriteRegister(0x0051, 0xf00);
  lcdWriteRegister(0x0052, 0xa03);
  lcdWriteRegister(0x0053, 0x300);
  lcdWriteRegister(0x0054, 0xc05);
  lcdWriteRegister(0x0055, 0xf00);
  lcdWriteRegister(0x0056, 0xf00);
  lcdWriteRegister(0x0057, 3);
  lcdWriteRegister(0x0058, 0x1f07);
  lcdWriteRegister(0x0059, 0x71f);
  delay(20);
  lcdWriteRegister(0x0007, 0x12);
  delay(20);
  lcdWriteRegister(0x0007, 0x13);
}

void lcdRegisterOther() {
  Serial.println("Loading LCD registers...");
  lcdWriteRegister(0x00e5,0x8000);
  lcdWriteRegister(0x0000,0x0001);
  lcdWriteRegister(0x0001,0x0100);
  lcdWriteRegister(0x0002,0x0700);
  lcdWriteRegister(0x0003,0x1030);
  lcdWriteRegister(0x0004,0x0000);
  lcdWriteRegister(0x0008,0x0202);
  lcdWriteRegister(0x0009,0x0000);
  lcdWriteRegister(0x000a,0x0000);
  lcdWriteRegister(0x000c,0x0000);
  lcdWriteRegister(0x000d,0x0000);
  lcdWriteRegister(0x000f,0x0000);
  lcdWriteRegister(0x0010,0x0000);
  lcdWriteRegister(0x0011,0x0000);
  lcdWriteRegister(0x0012,0x0000);
  lcdWriteRegister(0x0013,0x0000);
  lcdWriteRegister(0x0010,0x17b0);
  lcdWriteRegister(0x0011,0x0037);
  lcdWriteRegister(0x0012,0x0138);
  lcdWriteRegister(0x0013,0x1700);
  lcdWriteRegister(0x0029,0x000d);
  lcdWriteRegister(0x0020,0x0000);
  lcdWriteRegister(0x0021,0x0000);
  lcdWriteRegister(0x0030,0x0001);
  lcdWriteRegister(0x0031,0x0606);
  lcdWriteRegister(0x0032,0x0304);
  lcdWriteRegister(0x0033,0x0202);
  lcdWriteRegister(0x0034,0x0202);
  lcdWriteRegister(0x0035,0x0103);
  lcdWriteRegister(0x0036,0x011d);
  lcdWriteRegister(0x0037,0x0404);
  lcdWriteRegister(0x0038,0x0404);
  lcdWriteRegister(0x0039,0x0404);
  lcdWriteRegister(0x003c,0x0700);
  lcdWriteRegister(0x003d,0x0a1f);
  lcdWriteRegister(0x0050,0x0000);
  lcdWriteRegister(0x0051,0x00ef);
  lcdWriteRegister(0x0052,0x0000);
  lcdWriteRegister(0x0053,0x013f);
  lcdWriteRegister(0x0060,0x2700);
  lcdWriteRegister(0x0061,0x0001);
  lcdWriteRegister(0x006a,0x0000);
  lcdWriteRegister(0x0090,0x0010);
  lcdWriteRegister(0x0092,0x0000);
  lcdWriteRegister(0x0093,0x0003);
  lcdWriteRegister(0x0095,0x0101);
  lcdWriteRegister(0x0097,0x0000);
  lcdWriteRegister(0x0098,0x0000);
  lcdWriteRegister(0x0007,0x0021);
  lcdWriteRegister(0x0007,0x0031);
  lcdWriteRegister(0x0007,0x0173);
}

void lcdRegister7783() {
    
  lcdWriteRegister(0x0001,0x0100);    
  lcdWriteRegister(0x0002,0x0700);    
  lcdWriteRegister(0x0003,0x1030);    
  lcdWriteRegister(0x0008,0x0302);    
  lcdWriteRegister(0x0009,0x0000);   
  lcdWriteRegister(0x000A,0x0008);    
  lcdWriteRegister(0x0010,0x0790);    
  lcdWriteRegister(0x0011,0x0005);    
  lcdWriteRegister(0x0012,0x0000);   
  lcdWriteRegister(0x0013,0x0000); 
  lcdWriteRegister(0x0010,0x12B0);    
  lcdWriteRegister(0x0011,0x0007);  
  lcdWriteRegister(0x0012,0x008C);   
  lcdWriteRegister(0x0013,0x1700);    
  lcdWriteRegister(0x0029,0x0022);    
  lcdWriteRegister(0x0030,0x0000);    
  lcdWriteRegister(0x0031,0x0505);    
  lcdWriteRegister(0x0032,0x0205);    
  lcdWriteRegister(0x0035,0x0206);    
  lcdWriteRegister(0x0036,0x0408);    
  lcdWriteRegister(0x0037,0x0000);   
  lcdWriteRegister(0x0038,0x0504);
  lcdWriteRegister(0x0039,0x0206);    
  lcdWriteRegister(0x003C,0x0206);   
  lcdWriteRegister(0x003D,0x0408);    
  lcdWriteRegister(0x0050,0x0000);
  lcdWriteRegister(0x0051,0x00EF);   
  lcdWriteRegister(0x0052,0x0000);   
  lcdWriteRegister(0x0053,0x013F);   
  lcdWriteRegister(0x0060,0xA700);   
  lcdWriteRegister(0x0061,0x0001);   
  lcdWriteRegister(0x0090,0x0033); 
  lcdWriteRegister(0x0007,0x0133);
  lcdWriteRegister(0x0001,0x0100);
  lcdWriteRegister(0x0002,0x0700);    
  lcdWriteRegister(0x0003,0x1030);    
  lcdWriteRegister(0x0008,0x0302);    
  lcdWriteRegister(0x0009,0x0000);   
  lcdWriteRegister(0x000A,0x0008);    
  lcdWriteRegister(0x0010,0x0790);    
  lcdWriteRegister(0x0011,0x0005);    
  lcdWriteRegister(0x0012,0x0000);  
  lcdWriteRegister(0x0013,0x0000);    
  lcdWriteRegister(0x0010,0x12B0);    
  lcdWriteRegister(0x0011,0x0007);    
  lcdWriteRegister(0x0012,0x008C);    
  lcdWriteRegister(0x0013,0x1700);    
  lcdWriteRegister(0x0029,0x0022);    
  lcdWriteRegister(0x0030,0x0000);    
  lcdWriteRegister(0x0031,0x0505);    
  lcdWriteRegister(0x0032,0x0205);    
  lcdWriteRegister(0x0035,0x0206);    
  lcdWriteRegister(0x0036,0x0408);   
  lcdWriteRegister(0x0037,0x0000);    
  lcdWriteRegister(0x0038,0x0504);
  lcdWriteRegister(0x0039,0x0206);    
  lcdWriteRegister(0x003C,0x0206);    
  lcdWriteRegister(0x003D,0x0408);   
  lcdWriteRegister(0x0050,0x0000);
  lcdWriteRegister(0x0051,0x00EF);   
  lcdWriteRegister(0x0052,0x0000);   
  lcdWriteRegister(0x0053,0x013F);   
  lcdWriteRegister(0x0060,0xA700);   
  lcdWriteRegister(0x0061,0x0001);   
  lcdWriteRegister(0x0090,0x0033);
  lcdWriteRegister(0x0007,0x0133);
}

void lcdInit() {
  pinMode(LCD_CS, OUTPUT);
  digitalWrite(LCD_CS, HIGH);
  pinMode(LCD_RS, OUTPUT);
  digitalWrite(LCD_RS, HIGH);
  pinMode(LCD_WR, OUTPUT);
  digitalWrite(LCD_WR, HIGH);
  pinMode(LCD_RD, OUTPUT);
  digitalWrite(LCD_RD, HIGH);
  pinMode(LCD_RST, OUTPUT);
  digitalWrite(LCD_RST, HIGH);  
}

void lcdReset() {
  digitalWrite(LCD_RST, LOW);
  delay(2); 
  digitalWrite(LCD_RST, HIGH);
  lcdWriteData(0);
  lcdWriteData(0);
  lcdWriteData(0);
  lcdWriteData(0);
}

void lcdWrite8(uint16_t data) {
  digitalWrite(LCD_D0, data & 1);
  digitalWrite(LCD_D1, (data & 2) >> 1);
  digitalWrite(LCD_D2, (data & 4) >> 2);
  digitalWrite(LCD_D3, (data & 8) >> 3);
  digitalWrite(LCD_D4, (data & 16) >> 4); 
  digitalWrite(LCD_D5, (data & 32) >> 5);
  digitalWrite(LCD_D6, (data & 64) >> 6);
  digitalWrite(LCD_D7, (data & 128) >> 7);  
}

uint16_t lcdRead8() {
  uint16_t result = digitalRead(LCD_D7);
  result <<= 1;
  result |= digitalRead(LCD_D6);
  result <<= 1;
  result |= digitalRead(LCD_D5);
  result <<= 1; 
  result |= digitalRead(LCD_D4); 
  result <<= 1;
  result |= digitalRead(LCD_D3);
  result <<= 1;
  result |= digitalRead(LCD_D2); 
  result <<= 1;
  result |= digitalRead(LCD_D1);
  result <<= 1;
  result |= digitalRead(LCD_D0); 
  
  return result;
}

void lcdSetWriteDir() {
  pinMode(LCD_D0, OUTPUT);
  pinMode(LCD_D1, OUTPUT);
  pinMode(LCD_D2, OUTPUT);
  pinMode(LCD_D3, OUTPUT);  
  pinMode(LCD_D4, OUTPUT);  
  pinMode(LCD_D5, OUTPUT);
  pinMode(LCD_D6, OUTPUT);
  pinMode(LCD_D7, OUTPUT);  
}

void lcdSetReadDir() {
  pinMode(LCD_D0, INPUT);
  pinMode(LCD_D1, INPUT);
  pinMode(LCD_D2, INPUT);
  pinMode(LCD_D3, INPUT);  
  pinMode(LCD_D4, INPUT);  
  pinMode(LCD_D5, INPUT);
  pinMode(LCD_D6, INPUT);
  pinMode(LCD_D7, INPUT);    
}

void lcdWriteData(uint16_t data) {
  
  lcdSetWriteDir();
  digitalWrite(LCD_CS, LOW);
  digitalWrite(LCD_RS, HIGH);
  digitalWrite(LCD_RD, HIGH);
  digitalWrite(LCD_WR, HIGH);
  
  lcdWrite8(data >> 8);
  
  digitalWrite(LCD_WR, LOW);
  delayMicroseconds(10);
  digitalWrite(LCD_WR, HIGH);
  
  lcdWrite8(data);
  
  digitalWrite(LCD_WR, LOW);
  delayMicroseconds(10);
  digitalWrite(LCD_WR, HIGH);
  
  digitalWrite(LCD_CS, HIGH);  
}

void lcdWriteCommand(uint16_t command) {
  lcdSetWriteDir(); 
  digitalWrite(LCD_CS, LOW);
  digitalWrite(LCD_RS, LOW);
  digitalWrite(LCD_RD, HIGH);
  digitalWrite(LCD_WR, HIGH);  
  lcdWrite8(command >> 8);
  digitalWrite(LCD_WR, LOW);
  delayMicroseconds(10);
  digitalWrite(LCD_WR, HIGH);
  lcdWrite8(command);
  digitalWrite(LCD_WR, LOW);
  delayMicroseconds(10);
  digitalWrite(LCD_WR, HIGH);
  digitalWrite(LCD_CS, HIGH);    
}

int lcdReadData() {
  uint16_t result;
  lcdSetReadDir();
  digitalWrite(LCD_CS, LOW);
  digitalWrite(LCD_RS, HIGH);
  digitalWrite(LCD_RD, HIGH);
  digitalWrite(LCD_WR, HIGH);
  
  digitalWrite(LCD_RD, LOW);  
  delayMicroseconds(10);
  result = lcdRead8() << 8;
  digitalWrite(LCD_RD, HIGH);
  
  delayMicroseconds(10);
  
  digitalWrite(LCD_RD, LOW);
  delayMicroseconds(10);
  result |= lcdRead8();
  
  digitalWrite(LCD_RD, HIGH);
  digitalWrite(LCD_CS, HIGH);
  
  return result;
}

void lcdWriteRegister(uint16_t addr, uint16_t data) {
  lcdWriteCommand(addr);
  lcdWriteData(data);
}

uint16_t lcdReadRegister(uint16_t reg) {
  lcdWriteCommand(reg);
  return lcdReadData();
}

uint16_t lcdReadID() {
  return lcdReadRegister(0x00);
}

void lcdFillScreen(uint16_t color) {
  
  Serial.println("Filling the screen...");
  
  /*lcdWriteRegister(0x0050, 0);
  lcdWriteRegister(0x0051, 219);  
  lcdWriteRegister(0x0052, 0);
  lcdWriteRegister(0x0053, 319);  
  */
  lcdWriteRegister(0x0020, 0);
  lcdWriteRegister(0x0021, 0);
  lcdWriteCommand(0x0022);
  
  digitalWrite(LCD_CS, LOW);
  digitalWrite(LCD_RS, HIGH);
  digitalWrite(LCD_RD, HIGH);
  digitalWrite(LCD_WR, HIGH);
 
  lcdSetWriteDir();
  
  uint32_t i = 320;
  i *=240;

  while( i-- ) {
    lcdWrite8(color >> 8);
    digitalWrite(LCD_WR, LOW);
    delayMicroseconds(10);
    digitalWrite(LCD_WR, HIGH); 
    lcdWrite8(color);
    digitalWrite(LCD_WR, LOW);
    delayMicroseconds(10);
    digitalWrite(LCD_WR, HIGH); 
  }
  
  digitalWrite(LCD_CS, HIGH); 
  Serial.println("Done filling...");
  
}

[mystriks]

zkoušel jsem zprovoznit tftlcd shield (ili9341) pouzil jsem adafruit_tftlcd a graphictest ale píše mi to tohle:

TFT LCD test
Using Adafruit 2.8″ TFT Arduino Shield Pinout
TFT size is 240×320
Unknown LCD driver chip: 0
If using the Adafruit 2.8″ TFT Arduino shield, the line:
#define USE_ADAFRUIT_SHIELD_PINOUT
should appear in the library header (Adafruit_TFT.h).
If using the breakout board, it should NOT be #defined!
Also if using the breakout, double-check that all wiring
matches the tutorial.

piny mam definovane takhle mely by bit spravne
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0

#define LCD_RESET A4 // Can alternately just connect to Arduino’s reset pin

Attachments:

1. 

   IMG_20170217_153201.jpg
   

[Vojtěch Vosáhlo]

Pokud to tedy chápu správně, místo použití příkazu switch mám použít vypsaní všech možností podmínkou if

To úplně neříkám. Já použil if pouze protože jsem volal jen jednu funkci, jen kvůli jednoduchosti. Vy můžete nadále používat switch case. Pokud byste chtěl mít kód optimalizovaný na max, dá se použít něco takového:

#include <Adafruit_NeoPixel.h>
#include"IRremote2.h"

///Deklarace pouzitych funci
void funkce1();
void funkce2();

#define pinIN 4
#define PIN   6
// Parametr 1 = počet pixelů (LED diod) na pásek
// Parametr 2 = číslo PINu Arduina
// Parametr 3 = pixel type flags, add together as needed:
// NEO_KHZ800  800 KHz kmitočet pro pásky s WS2812 LED diodami)
// NEO_GRB  Pixely jsou zasílány ve formátu GRB 
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(36, 6, NEO_GRB + NEO_KHZ800);
IRrecv dalkoveOvl(pinIN);
decode_results vysledek;
char pozice;

typedef void (* Caller)();
Caller funkce[] = {&funkce1, &funkce2}; ///FUNKCE KTERE CHCETE VOLAT
char serial_prikazy[] = {'1', '2'}; ///PRIKAZY KORESPONDUJICI S FUNKCEMI tzn. 1 vola funkce1
int32_t ir_prikazy[] = {0x00FFA25D, 0xFFE21D};
char data;

void setup(){
  pixels.begin();
  Serial.begin(9600);
  pixels.show();
  delay(250);
  dalkoveOvl.enableIRIn();
}

///////////////////////////////////////////////////////////////////////
//////////////FUNKCE KTERE BUDOU VOLANE PRIKAZY //////////////////////
void funkce1(){
  dalkoveOvl.resume();

  while(!(Serial.available() || dalkoveOvl.decode(&vysledek)))
  {
    pixels.setPixelColor(6, pixels.Color(255,255,255));
    pixels.show();
    delay(1000);
    pixels.setPixelColor(6, pixels.Color(0,0,0));
    pixels.show();
    delay(200);    
    pixels.setPixelColor(6, pixels.Color(255,255,255));
    pixels.show();
    delay(1000);
    pixels.setPixelColor(6, pixels.Color(0,0,0));
    pixels.show();
    delay(200);
  }
}

void funkce2(){
  dalkoveOvl.resume();

  while(!(Serial.available() || dalkoveOvl.decode(&vysledek)))
  {
    pixels.setPixelColor(16, pixels.Color(255,255,255));
    pixels.show();
    delay(1000);
    pixels.setPixelColor(16, pixels.Color(0,0,0));
    pixels.show();
    delay(200);    
    pixels.setPixelColor(16, pixels.Color(255,255,255));
    pixels.show();
    delay(1000);
    pixels.setPixelColor(16, pixels.Color(0,0,0));
    pixels.show();
    delay(200);
  }
}

/////////////////////////////////////////////////////////////////////

void loop(){
  
    if(Serial.available() || dalkoveOvl.decode(&vysledek)){
      
    data = Serial.read();
    
        for(int i = 0; i < sizeof(funkce); i++){
            if(data == serial_prikazy[i] || vysledek.value == ir_prikazy[i]){
              
                funkce[i]();
              
              }
          
          }
          
    }
}

Prakticky si na začátku zapíšete všechny různé funkce a pak už se jen volají podle příkazů. Je to kratší a nemusíte používat switch case.
Nejdůležitější je deklarovat si na začátku všechny „blikací a svítící“ funkce asi takto

void funkce1();
void funkce2();

Těch tam může být kolik chce.
Poté si zapíšete příkazy které funkce spouští jako tady: `Caller funkce[] = {&funkce1, &funkce2}; ///FUNKCE KTERE CHCETE VOLAT
char serial_prikazy[] = {‚1‘, ‚2‘}; ///PRIKAZY KORESPONDUJICI S FUNKCEMI tzn. 1 vola funkce1
int32_t ir_prikazy[] = {0x00FFA25D, 0xFFE21D};`

V Caller funkce[] jsou zapsány samotné funkce které se budou volat, zapisujete je jako &nazevfunkce. V serial_prikazy[] jsou sériové příkazy které spouští dané funkce tzn. příkaz na 1. pozici spustí funkci na 1. pozici v tom Caller funkce[]. V poli ir_prikazy[] jsou opět korespondující příkazy které spouští funkce. Musí být zapsány jako 0x00vasirkod. Ten kód co jsem přihodil by měl fungovat jako ten váš se switch case nebo if. Schválně zkuste a uvidíme.

Obnovení předešlé animace kdyžtak vyřešíme jestli tohle bude fungovat.

[Dominic]

A jaky ovladac?…toho funduina una?…a kde ho najdu?

[ArduXPP]

Asi děláte ve windows XP poprvé ? Je to stejný jako třeba u USB flash, když ho chci používat, tak musím nainstalovat driver ( ovladač) , to stejný je u arduino uno či Funduino UNO R3.

[Hint]

Tak po menší úpravě vašeho návrhu už zřejmě funguje jak má, přepíná po sériové lince i přes IR. Pokud to tedy chápu správně, místo použití příkazu switch mám použít vypsaní všech možností podmínkou if
a zárověň mě napadlo zda jde ještě nějak zapsat podmínka, když nepřijme data která má v podmínkach, neudělá nic a bude pokračovat v předchozím efektu. Uvědomil jsem si totiž že při ovladaní TV bude IR ovlivňovat i arduino přijímač a vypínat efekty.

#include <Adafruit_NeoPixel.h>
#include"IRremote2.h"

#define pinIN 4
#define PIN   6
// Parametr 1 = počet pixelů (LED diod) na pásek
// Parametr 2 = číslo PINu Arduina
// Parametr 3 = pixel type flags, add together as needed:
// NEO_KHZ800  800 KHz kmitočet pro pásky s WS2812 LED diodami)
// NEO_GRB  Pixely jsou zasílány ve formátu GRB 
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(36, 6, NEO_GRB + NEO_KHZ800);
IRrecv dalkoveOvl(pinIN);
decode_results vysledek;
char pozice;

void setup() {
  pixels.begin();
  Serial.begin(9600);
  pixels.show();
  delay(250);
  dalkoveOvl.enableIRIn();
}

void loop()
{
  if (dalkoveOvl.decode(&vysledek)) 
  {
    detekceKlaves();
    dalkoveOvl.resume();
  }
  if (Serial.available() > 0)
  {
    pozice = Serial.read();
    if(pozice == '1') blika();
    if(pozice == '2') blika1();
  }
}

void detekceKlaves() 
{
  if(vysledek.value == 0xFFA25D) 
  {

      Serial.println("Stisknuto CH-");
      blika();

  // pauza pro přehlednější výpis
  delay(500);
  }
  if(vysledek.value == 0xFFE21D) 
  {

      Serial.println("Stisknuto CH-");
      blika1();

  // pauza pro přehlednější výpis
  delay(500);
  }
  
}

void blika()
{
 dalkoveOvl.resume();

  while(!(Serial.available() || dalkoveOvl.decode(&vysledek)))
  {
    pixels.setPixelColor(6, pixels.Color(255,255,255));
    pixels.show();
    delay(1000);
    pixels.setPixelColor(6, pixels.Color(0,0,0));
    pixels.show();
    delay(200);    
    pixels.setPixelColor(6, pixels.Color(255,255,255));
    pixels.show();
    delay(1000);
    pixels.setPixelColor(6, pixels.Color(0,0,0));
    pixels.show();
    delay(200);
  }
}

void blika1()
{
 dalkoveOvl.resume();

  while(!(Serial.available() || dalkoveOvl.decode(&vysledek)))
  {
    pixels.setPixelColor(16, pixels.Color(255,255,255));
    pixels.show();
    delay(1000);
    pixels.setPixelColor(16, pixels.Color(0,0,0));
    pixels.show();
    delay(200);    
    pixels.setPixelColor(16, pixels.Color(255,255,255));
    pixels.show();
    delay(1000);
    pixels.setPixelColor(16, pixels.Color(0,0,0));
    pixels.show();
    delay(200);
  }
}

[Vojtěch Vosáhlo]

Zkuste něco takového jako zjednodušený kód. Mělo by to blikat s prvním pixelem pokud zmáčknete CH- nebo pošlete 1. Pokud přijde něco jiného, smyčka by se měla přerušit.

#include <Adafruit_NeoPixel.h>
#include"IRremote2.h"

#define pinIN 4
#define PIN   6
// Parametr 1 = počet pixelů (LED diod) na pásek
// Parametr 2 = číslo PINu Arduina
// Parametr 3 = pixel type flags, add together as needed:
// NEO_KHZ800  800 KHz kmitočet pro pásky s WS2812 LED diodami)
// NEO_GRB  Pixely jsou zasílány ve formátu GRB 
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(36, 6, NEO_GRB + NEO_KHZ800);
IRrecv dalkoveOvl(pinIN);
decode_results vysledek;
char pozice;

void setup() {
  pixels.begin();
  Serial.begin(9600);
  pixels.show();
  int delayval = 300;
  delay(250);
  dalkoveOvl.enableIRIn();
}

void loop()
{
  if (dalkoveOvl.decode(&vysledek)) 
  {
    detekceKlaves();
    dalkoveOvl.resume();
  } 
  if (Serial.available() > 0)
  {
  pozice = Serial.read();
    if(pozice == 1) blikejLed();
  }
}

void detekceKlaves() {
  if(vysledek.value == 0xFFA25D) {

      Serial.println("Stisknuto CH-");
      blikejLed();

  // pauza pro přehlednější výpis
  delay(500);
}

void blikejLed(){
 dalkoveOvl.resume();

  while(!(Serial.available() || dalkoveOvl.decode(&vysledek))){

    pixels.setPixelColor(1, pixels.Color(255,255,255));
    pixels.show();
    delay(1000);
    pixels.setPixelColor(1, pixels.Color(0,0,0));
    pixels.show();
    delay(1000);

  }
 
}

[krcmar.tomas@gmail.com]

ahj, diky moc za vase snazeni, byl jsem ted par dni mimo, ale zase se do toho chci pustit

muzu poprosit o to zjednodusene schema, nasel jsem na fb neco hodne podobneho

a jeste jsem chtel pozadat, jak presne zapojit tu klapku

http://marcomplet.cz/docs/Belimo/belimo_cm24-SR.pdf

diky moc pratele

Attachments:

1. 

   1-10V.jpg
   

[Autor]

Příspěvky