O Grupo HabitsID, composto por Carlos Aguni, Bárbara Albuquerque, Louise Martins, Felipe Caravaggio e Eiji Kawahira, está desenvolvendo um projeto para o controle e coleta dos frequentadores e visitantes do prédio da Habits, localizada na incubadora da EACH – USP Leste.
O desenvolvimento do projeto pode ser acessado através desse link:
Amanhã levarei para o lab: (ATUALIZAÇÃO 19.092016-12:24BRST): Já está tudo no lab inclusive a ventoinha)
Projeto loja:
- 1 x arduino mega
- 2 x fototransistores TIL 78 com ponto vermelho
- 2 x LED infravermelho: TIL 32 com ponto preto
- canudos
- fita isolante
A idéia é direcionar a captação de luz do TIL78 usando os canudos cobertos com uma camada de fita isolante. Caso necessário direcionar a emissão do TIL32 da mesma forma.
O arduino mega foi pedido para poder usar o Johnny5. Esta parte deve ser bem documentada.
Projeto estufa:
- 3 x garrafas de água - ventoinha
A idéia é usá-las como vasos.
Projeto hidroponia:
- caixa 50l
- jogo de serra de copo
- bomba de 14W,1000l/h
- 6m de mangueira e conexões.
- cola epoxi
- cola de pvc
- lm35
- pH-metro
As idéias são: usar a caixa como depósito da solução; Usar as serras de copo para completar a preparação dos canos; Bomba e mangueira para distribuir a solução (acho que o melhor uso da pressão da bomba é ter um único cano de subida e distribuir em cima); hackear o pH-metro para transmitir as leituras através do arduino; Fazer o sensor de temperatura à prova d'agua usando lm35, soldando fios nos seus terminais, isolando e encapando com fita isolante (para não colar os terminais) e passando uma camada de cola epóxi.
Wittyboard é uma placa para desenvolvimento de hardware baseada no System on a Chip (SoC) ESP8266-12F.
Um SoC é praticamente um computador em um chip - já contendo processador, memória, periféricos,... No caso do ESP8266 o periférico que o diferencia é a interface wifi (IEEE 802.11).
Além de wifi, ESP8266 tem portas seriais (RS232), portas de entrada e saída analógica e digital mas nem sempre elas são acessiveis externamente.
No Brasil o membro da família mais fácil de encontrar no varejo comum é o ESP8266-01 com firmware "oficial", por exemplo em http://www.filipeflop.com/pd-1f55ad-modulo-wifi-esp8266-esp-01.html?ct=41d98&p=2&s=1
O ESP-01 além do TX e RX da interface serial tem duas portas de IO (GPIO0 e GPIO2) acessiveis externamente e 512kbytes de memória FLASH. O firmware "oficial" pode ser encontrado em http://espressif.com/.
Até agora parece que é tirar do envelope e usar, mas...
1-) Todos os ESP são alimentados a 2.7-3.6V, e os pinos não são preparados para sobretensão então não dá para conectar diretamente a maioria dos arduinos e sensores, que funcionam a 5V.
2-) O regulador de tensão do arduino e do FTDI232 (até 150mA) não suporta a carga de um ESP (até 300mA).
2-) O firmware oficial é baseado em comandos AT (o que não é um problema, mas é estranho num mundo em que se fala em serviços e APIs). A linguagem é pobre para a variedade de usos do componente.
3-) Tem muitas funcionalidades ativadas pelas condições em que é ligado, mas é mal documentado. Há dois anos atrás era muito trabalhoso descobrir como usar direito (tanto o hardware quanto o software).
Era um componente difícil de usar, mas pelo interesse e esforço de empresas e comunidades foram destrinchando o funcionamento e criando facilitadores para usar o dispositivo:
1-) NodeMCU é uma placa IoT open source baseada em ESP com firmware adaptado (NodeMCU Lua);
2-) Arduino IDE versão 1.6.5 e superiores permite incluir placas novas e baixar os arquivos de suporte automaticamente;
3-) ESP8266.com é uma comunidade onde foi desenvolvido o firmware NodeMCU Arduino (http://www.esp8266.com/viewforum.php?f=25&sid=d777d5b91c608688faae30c23670e15b). Um firmware substituto que torna possível programar o NodeMCU usando Arduino IDE.
Wittyboard é um conjunto programador+ESP8266-12F em duas placas separadas - ao contrário de NodeMCU que tem programador e ESP em uma única placa.
(acrescentado em 24.09.2016) Segundo https://blog.the-jedi.co.uk/2016/01/02/wifi-witty-esp12f-board/ (ainda não chequei) o led RGB está conectado em :
vermelho = GPIO15, verde = GPIO12, azul =
GPIO13.O botão está em GPIO4 com um PULLUP então pressionado a leitura é LOW (NOTA: no Arduino quando um pino é INPUT_PULLUP a leitura é invertida: solto a leitura é LOW apertado a leitura é HIGH.
Interessei-me por ele pois tinha achado no mercado livre Brasil e pareceu possível trocar o breakout com o ESP8266-12F por um ESP-07 (tenho alguns com firmware indeterminado) e um punhado de resistores.
O video mostra a placa funcionando depois que consegui programá-la.
Segui as instruções em https://yoursunny.com/t/2016/WittyCloud-first/ para instalar e configurar as ferramentas de programação e enviar o primeiro exemplo.
Achei muitos pontos interessantes:
0-) O ESP ligado a um FTDI (ou similar) ainda precisa de circuitos auxiliares para ser programado. O programador do Wittyboard tem esses circuitos.
1-) a construção da placa permite separar o programador do ESP e consequentemente facilita adaptações no circuito para poder programar outros ESP.
2-) a programação dispensa apertar botões - o programador faz um truque com DTR e RTS.
3-) NodeMCU Arduino regrava toda a memória flash do ESP a cada upload, então ESPs comprados com firmware indeterminado são "corrigidos" e passam a funcionar.
Wittyboard consists in an ESP8266-12F and circuitry to connect it to the USB port separated in two boards. It enable us to flash programs into ESP using arduino IDE.
I found the instructions to install the programming tools at https://yoursunny.com/t/2016/WittyCloud-first/
advantages I noticed:
0-) ESP connected do FTDI (or similar) still require additional circuitry to be programmed. Wittyboard has the circuitry.
1-) board physical configuration enable us to separate programmer from ESP breakout board. It facilitates circuit adaptation to connect other ESP (I made it with ESP-07).
2-) No need to press buttons to flash ESP. Circuit uses DTR and RTS serial signals to "do the trick".
3-) NodeMCU Arduino reflashes ESP on each
upload so ESPs with unknown firmware are "corrected" and start functioning.
C++ code colored by C++2HTML
Veja o servidor em ação:
Sketch do arduino adaptado de https://www.arduino.cc/en/Tutorial/WiFiWebServer:
/*
Tentativa de usar o wifi do witty board
tentativa 6 baseado na tentativa 5
objetivo: levantar um servidor web.
levantou, funcionou, tirei foto (mas nao dah para incluir aqui)
O copy da pagina no browser deu:
analog input 0 is 266
analog input 1 is 0
analog input 2 is 1023
analog input 3 is 0
analog input 4 is 1023
analog input 5 is 1023
olha so que fantastico o que o dah para ver no lado do servidor:
SSID set: 0
Scanning available networks...
** Scan Networks **
number of available networks:5
0) Rxxxxx Lxxxx Axxxx Signal: -91 dBm Encryption: Auto
1) Exxxx Lxxxx Signal: -91 dBm Encryption: WEP
2) Exxxxxx Signal: -90 dBm Encryption: Auto
3) andro Signal: -86 dBm Encryption: Auto
4) 122 Signal: -92 dBm Encryption: WPA
192.168.0.101
new client
GET / HTTP/1.1
Host: 192.168.0.101
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:47.0) Gecko/20100101 Firefox/47.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*//*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: keep-alive
Cache-Control: max-age=0
client disonnected
Connected
-- 18.09.2016
Consegui usar com o ESP-7.
A saida pela serial:
Connected
MAC: 71:2B:2:7F:CF:5C
Mode: STA
PHY mode: N
Channel: 11
AP id: 0
Status: 5
Auto connect: 1
SSID (5): andro
Passphrase (15): kkkkkk
BSSID set: 0
Scanning available networks...
** Scan Networks **
number of available networks:3
0) Exxx Lxxxx Signal: -93 dBm Encryption: WEP
1) Edxxxx Signal: -76 dBm Encryption: Auto
2) andro Signal: -72 dBm Encryption: Auto
192.168.0.107
Connected
dump do browser:
analog input 0 is 218
analog input 1 is 0
analog input 2 is 1023
analog input 3 is 0
analog input 4 is 0
analog input 5 is 0
*/
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#if 0
char ssid[] = "andro"; // your network SSID (name)
char pass[] = "kkkkkkk"; // your network password
#else
char ssid[] = "G4_8450"; // your network SSID (name)
char pass[] = "12345678"; // your network password
#endif
wl_status_t status = WL_DISCONNECTED; /* enum definido em
fabio@fabio-PORTEGE-M400:~/.arduino15/packages/esp8266/hardware/
esp8266/2.3.0/libraries/ESP8266WiFi/src/include/wl_definitions.h
*/
WiFiServer server(80);
int no_server=1;
void setup() {
//Initialize serial and wait for port to open:
Serial.begin(115200);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB port only
}
// check for the presence of the shield:
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println("WiFi shield not present");
// don't continue:
while (true);
}
// Print WiFi MAC address:
printMacAddress();
WiFi.mode(WIFI_STA);
}
void loop() {
// Print WiFi MAC address:
printMacAddress();
WiFi.printDiag(Serial);
// scan for existing networks:
Serial.println("Scanning available networks...");
listNetworks();
if ( status != WL_CONNECTED) {
Serial.print("Attempting to connect to WPA SSID: ");
Serial.println(ssid);
// Connect to WPA/WPA2 network:
status = WiFi.begin(ssid, pass); // este status nao informa se
// existe handshake de conexao em progresso
} else {
IPAddress ip;
ip = WiFi.localIP();
Serial.println (ip);
/*https://www.arduino.cc/en/Tutorial/WiFiWebServer */
if (no_server) {
server.begin();
no_server=0;
}
WiFiClient client = server.available();
if (client) {
Serial.println("new client");
// an http request ends with a blank line
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
// if you've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so you can send a reply
if (c == '\n' && currentLineIsBlank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close"); // the connection will be closed after completion of the response
client.println("Refresh: 5"); // refresh the page automatically every 5 sec
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
// output the value of each analog input pin
for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
int sensorReading = analogRead(analogChannel);
client.print("analog input ");
client.print(analogChannel);
client.print(" is ");
client.print(sensorReading);
client.println("<br />");
}
client.println("</html>");
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
}
else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1);
// close the connection:
client.stop();
Serial.println("client disonnected");
/*****/
}
}
printStatus (status);
delay(10000);
status = WiFi.status(); // consulta o status novamente para
// verificar se o handshake terminou com sucesso.
}
void printMacAddress() {
// the MAC address of your Wifi shield
byte mac[6];
// print your MAC address:
WiFi.macAddress(mac);
Serial.print("MAC: ");
Serial.print(mac[5], HEX);
Serial.print(":");
Serial.print(mac[4], HEX);
Serial.print(":");
Serial.print(mac[3], HEX);
Serial.print(":");
Serial.print(mac[2], HEX);
Serial.print(":");
Serial.print(mac[1], HEX);
Serial.print(":");
Serial.println(mac[0], HEX);
}
void listNetworks() {
// scan for nearby networks:
Serial.println("** Scan Networks **");
int numSsid = WiFi.scanNetworks();
if (numSsid == -1) {
Serial.println("Couldn't get a wifi connection");
while (true);
}
// print the list of networks seen:
Serial.print("number of available networks:");
Serial.println(numSsid);
// print the network number and name for each network found:
for (int thisNet = 0; thisNet < numSsid; thisNet++) {
Serial.print(thisNet);
Serial.print(") ");
Serial.print(WiFi.SSID(thisNet));
Serial.print("\tSignal: ");
Serial.print(WiFi.RSSI(thisNet));
Serial.print(" dBm");
Serial.print("\tEncryption: ");
printEncryptionType(WiFi.encryptionType(thisNet));
}
}
void printEncryptionType(int thisType) {
// read the encryption type and print out the name:
switch (thisType) {
case ENC_TYPE_WEP:
Serial.println("WEP");
break;
case ENC_TYPE_TKIP:
Serial.println("WPA");
break;
case ENC_TYPE_CCMP:
Serial.println("WPA2");
break;
case ENC_TYPE_NONE:
Serial.println("None");
break;
case ENC_TYPE_AUTO:
Serial.println("Auto");
break;
}
}
void printStatus (wl_status_t st) {
// string message of the status
switch (st) {
case WL_NO_SHIELD:
Serial.println("No shield (should not happen on ESP/WITTYBOARD/NODEMCU)");
break;
case WL_IDLE_STATUS:
Serial.println("Idle status");
break;
case WL_NO_SSID_AVAIL:
Serial.println("No SSID Available");
break;
case WL_SCAN_COMPLETED:
Serial.println("Scan Completed");
break;
case WL_CONNECTED:
Serial.println("Connected");
break;
case WL_CONNECT_FAILED:
Serial.println("CONNECTION FAILED");
break;
case WL_CONNECTION_LOST:
Serial.println("CONNECTION LOST");
break;
case WL_DISCONNECTED:
Serial.println("DISCONNECTED");
break;
default:
Serial.print(st);
Serial.println("unknown status");
break;
}
}
Este post descreve o circuito que montei para conectar o ESP-07 à placa de comunicação/programação do wittyboard.
O circuito é uma adaptação do nodemcu (https://github.com/nodemcu/nodemcu-devkit). Esquemático: https://raw.githubusercontent.com/nodemcu/nodemcu-devkit/master/Documents/NODEMCU_DEVKIT_SCH.png
Lista de conexões
ESP pin
Wittyboard pin
additional info
TXD0
16 (TXD)
-
RXD0
15 (RXD)
-
GPIO0
12 (GPIO0)
PULLED UP
GPIO2
NC
PULLED UP
GPIO15
NC
PULLED DOWN
GND
9 (GND)
pilhas GND
VCC
NC (!)
pilhas 3.6V
GPIO16
4 (GPIO16)
-
EN (or CH_PD)
NC
PULLED UP
RST
REST (1)
PULLED UP
(!) Não uso o VCC do Wittyboard pois não uso para alimentar o ESP. Uso 3 pilhas recarregáveis para alimentar o ESP - são 3.6V.
Os resistores PULL UP e PULL DOWN são de 10k.
A numeração dos pinos do wittyboard é feita com a antena para baixo (ou o conector USB para cima), no sentido anti-horário. O pino 1 é o inferior direito (veja na foto abaixo). Os nomes são os impressos no breakout do ESP do wittyboard.
Coloquei um capacitor de 100uF entre 3.6V e GND.
Conversei com o grupo deste projeto hoje sobre que caixa usar. A idéia que tive é usar uma caixa transparente, que eu não sabia de que material é até uns minutos atrás, e que descobri ser de acetato, como estas: http://www.marcopoloembalagens.com.br/Embalagens.asp.
São mais baratas e podem ser cortadas com tesoura, mas não têm rigidez suficiente.
Para dar rigidez, usar um quadro de madeira, como este: http://www.anariebrasil.com.br/quadros-de-madeira (tenho uns em casa)
e para colocar plantas e terra uma bandeja como esta: http://www.obalanceiro.com.br/produto-204-Bandeja_biopratika_75_litros_43x29x7_Ref0737.
Unir tudo com fita, cola quente, braçadeiras, pregos.
Ficaria algo parecido com esta luminária: https://bricolagem.files.wordpress.com/2013/10/12b.jpg
Atualização 18.09.2016: Foto do grupo montando a caixa:
