Lab aberto para visitas

Idéia para laboratório aberto para visitantes

Pessoal,
   Hoje fui ao 8o. Encontro Internacional de Tecnologia e Informação para Pessoas com Deficiência. Havia um showcase que achei bem interessante - é o que eu imagino no nosso laboratório aberto para visitantes. Seguem fotos:


https://drive.google.com/open?id=0B2aucTjhMlIVSUpzclYyMVJHY2c

https://drive.google.com/open?id=0B2aucTjhMlIVY2JDQndhV0xYOHM

Grupo HabitsID

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:

Fotos dos Projetos.

Preparação para encontro 6

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.

Projeto postura:
- Velcro

Introdução ao Wittyboard

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.

Servidor web no ESP-07 usando wittyboard como programador.

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;
  }
}