Programar el chip wifi ESP8266 como si fuera un microcontrolador (1/2)

9 respuestas

En esta tanda de dos artículos explicaré cómo olvidarse de los comandos AT del módulo ESP8266 ESP-01 (aunque lo escrito vale para toda la familia ESP) y poder programarlo como un chip independiente: conectando la wifi, manejando el puerto serie, usando los pines GPIO, etc. La gran ventaja es que tenemos un microprocesador más potente, más versátil, más rápido y además en muchos casos es más barato que si usáramos los microcontroladores PIC o AVR (como contrapartida tiene menos pines de E/S).

CONSTRUYENDO EL TOOLCHAIN

El primer paso que tenemos que hacer para programarlo es construir el toolchain para poder compilar los programas para este chip con el compilador cruzado. Para ello recomiendo tener un linux donde construirlo (ya sea físico o virtualizado), no recomiendo usar windows y cygwin. Yo estoy usando el ubuntu 14.04 LTS.

Lo primero es instalar las herramientas necesarias, para ello ejecutar:

sudo apt-get install make unrar autoconf automake libtool gcc g++ gperf flex bison texinfo gawk ncurses-dev libexpat-dev python sed unzip git

1	sudo apt-get install make unrar autoconf automake libtool gcc g++ gperf flex bison texinfo gawk ncurses-dev libexpat-dev python sed unzip git

Vamos a usar el toolchain de https://github.com/pfalcon/esp-open-sdk, con el que el proceso de creación es bastante sencillo (ejecútalo en la raíz de tu directorio personal):

git clone https://github.com/pfalcon/esp-open-sdk.git

1	git clone https://github.com/pfalcon/esp-open-sdk.git

Esto habrá creado una carpeta esp-open-sdk. Entra dentro de está y haz un make (con el parámetro STANDALONE=y) para crear todo el toolchain (puede tardar un rato dependiendo de tu ordenador):

cd esp-open-sdk
make STANDALONE=y

1 2	cd esp-open-sdk make STANDALONE=y

Ahora vamos a poner en la variable de entorno PATH la ruta a los binarios, ya que el esptool no funciona si no se pone (cambia oscar por tu usuario):

PATH=$PATH:/home/oscar/esp-open-sdk/xtensa-lx106-elf/bin
export PATH

1 2	PATH=$PATH:/home/oscar/esp-open-sdk/xtensa-lx106-elf/bin export PATH

COMPILANDO PROGRAMAS

Vamos a descargarnos unos ejemplos ya hechos:

git clone https://github.com/esp8266/source-code-examples.git

1	git clone https://github.com/esp8266/source-code-examples.git

Esto creará una carpeta llamada source-code-examples. Entra dentro de esta carpeta y edita el fichero example.Makefile.

cd source-code-examples
nano example.Makefile

1 2	cd source-code-examples nano example.Makefile

Modifica las siguientes lineas (recuerda cambiar oscar por tu usuario):

XTENSA_TOOLS_ROOT ?= /opt/Espressif/crosstool-NG/builds/xtensa-lx106-elf/bin

1	XTENSA_TOOLS_ROOT ?= /opt/Espressif/crosstool-NG/builds/xtensa-lx106-elf/bin

POR

XTENSA_TOOLS_ROOT ?= /home/oscar/esp-open-sdk/xtensa-lx106-elf/bin

1	XTENSA_TOOLS_ROOT ?= /home/oscar/esp-open-sdk/xtensa-lx106-elf/bin

SDK_BASE ?= /opt/Espressif/ESP8266_SDK

1	SDK_BASE ?= /opt/Espressif/ESP8266_SDK

POR

SDK_BASE ?= /home/oscar/esp-open-sdk/sdk

1	SDK_BASE ?= /home/oscar/esp-open-sdk/sdk

ESPTOOL ?= esptool.py

1	ESPTOOL ?= esptool.py

POR

ESPTOOL ?= /home/oscar/esp-open-sdk/esptool/esptool.py

1	ESPTOOL ?= /home/oscar/esp-open-sdk/esptool/esptool.py

El campo ESPPORT debes cambiarlo si no coincide con la ruta al dispositivo asociado a tu dongle usb a serie.
Ahora entra dentro del direcotrio blinky, copia el fichero anteriormente editado como Makefile y haz un make para compilar el firmware:

cd blinky
cp ../example.Makefile Makefile
make

cd blinky

cp ../example.Makefile Makefile

make

Si todo ha ido bien habremos compilado el firmware para nuestro ESP8266:

PROGRAMANDO EL ESP8266

Para poder programar nuestro módulo ESP8266 necesitamos un dongle usb a serie (USB2TTL) como este:

Después es necesario añadir al usuario que estemos utilizando (en el ejemplo, oscar) en el grupo dialout para poder acceder al dongle:

sudo adduser oscar dialout

1	sudo adduser oscar dialout

Ahora sólo queda subir el programa al módulo ESP8266, para ello debes cablear el módulo de la siguiente forma (estando éste sin alimentación):

Las líneas rojas van a VCC (3,3V) y las negras a GND (masa). Ahora alimenta el módulo.

Si es la primera vez que vas a programar el módulo wifi, debes borrar las configuraciones por defecto, esto se consigue ejecutando el siguiente comando:

~/esp-open-sdk/esptool/esptool.py --port /dev/ttyUSB0 write_flash 0x7C000 ~/esp-open-sdk/esp_iot_sdk_v1.0.1/bin/esp_init_data_default.bin 0x7E000 ~/esp-open-sdk/esp_iot_sdk_v1.0.1/bin/blank.bin

1	~/esp-open-sdk/esptool/esptool.py --port /dev/ttyUSB0 write_flash 0x7C000 ~/esp-open-sdk/esp_iot_sdk_v1.0.1/bin/esp_init_data_default.bin 0x7E000 ~/esp-open-sdk/esp_iot_sdk_v1.0.1/bin/blank.bin

Las siguientes veces ya no será necesario repetir este paso. Si has hecho este paso vuelve a apagar y encender el módulo.

Finalmente para programar el firmware creado, ejecuta el comando:

make flash

1	make flash

Enhorabuena, acabas de programar por primera vez tu módulo ESP8266. Ahora desconecta el cable que va al pin de programacion (así el módulo no estará en modo de programación), conecta un led entre el GPIO 2 (el que no aparece conectado a ningún sitio en la fila de GND de la foto anterior de las conexiones) y masa. Así es como luce el «hola mundo» del chip ESP8266:

En el siguiente artículo explicaré cómo hacer tus propios programas en C para el esp8266.

Elecrab: una startup española

Deja un comentario

Hay gente que, a pesar de la situación actual, son valientes y se atreven a lanzan startups que marquen una diferencia. En el artículo de hoy voy a comentar el caso de Elecrab. Una empresa muy pequeña cuyo fundador, Jorge M., tiene como objetivo crear algo parecido a Pololu, Sparkfun o Adafruit desde cero.

Jorge, Ingeniero Industrial, tiene una dilatada experiencia en el mundo del hardware abierto, no en vano es uno de los creadores de la placa VinciDuino, escritor de blog del cire y jmnlab,

En su primera incursión en el desarrollo de productos de hardware libre ha creado 4 placas para que, quien quiera adentrarse en el mundo de la electrónica, pueda empezar a experimentar por un precio irrisorio.

Estas placas que a continuación detallaré, están a la venta en tindie, un portal donde la gente que quiera vender sus creaciones lo puede hacer sin tener que crear desde cero un tienda online y donde los compradores pueden buscar productos novedosos de forma sencilla y centralizada.

De izquierda a derecha tenemos:

Una placa con un microcontrolador ATtiny841, cuya principal carácterística es que tiene dos puertos serie por hardware.

–ecSwitch: placa con botón pulsador, y cuya electrónica está diseñada para evitar los famosos rebotes cuando es pulsado.

–ecLeds: placa con 4 diodos led.

–ecPower: placa para alimentar una protoboard y que puede enchufarse a un puerto micro usb (como los cargadores de los móviles) y que se puede seleccionar si la salida es de 5V. o de 3,3V gracias a un regulador de tensión.

Estas placas tiene un nivel muy avanzado en cuanto a su producción, ya que por un lado es una empresa china la que fabrica las placas en lotes, y por otro los componentes son soldados usando técnicas empresariales como plantillas (stencils) y soldadura por horno. El acabado es totalmente profesional.

Tener un hardware así para iniciarse en la electrónica está bien, pero si no sabemos por donde empezar a utilizarlo de poco nos servirá, por ello en la misma página de Elecrab tenemos unos detallados tutoriales donde se explica desde un principio cómo sacarle provecho a estas placas. Y si nos interesa cómo han sido diseñadas y los motivos por los cuales se han tomado algunas decisiones, puedes verlo más detenidamente en la sección de productos.

Si tienes curiosidad por la electrónica pero no te atreves a adentrarte por su complejidad o tus conocimientos son bajos, esta es una excelente oportunidad de hacerte con hardware libre, barato y completamente funcional para que te sirva como punto de partida en el apasionante mundo de la electrónica.

Programando un Arduino remotamente con el módulo ESP8266

69 respuestas

Una de mis viejas aspiraciones cuando construyo robots es poder programarlos sin tener que recogerlos, enchufarles un cable usb o un programador ICSP y volverlos a dejar en su sitio.

En este artículo explicaré cómo con un Arduino UNO y un módulo ESP8266 (llamado WI07C) se puede programar un sketch de Arduino en la placa sin tener que estar cerca de esta, todo mediante wifi y sockets tcp/ip.

Descripción general

Como se puede ver en el vídeo tenemos un Arduino UNO conectado a un display HD44780 y a un módulo wifi ESP8266. Arduino envía cadenas hello world al servidor sockettest que está escuchando por el puerto 49000. Se modifica el código Arduino en el IDE poniendo hello folks, se compila y el fichero .hex generado (se puede ver donde está activandolo en Archivo/Preferencias/compilación) se copia a la carpeta del programa en python. Cuando Arduino recibe un comando reboot se conecta al servidor python por el puerto 50000 entrando en modo de datos, acto seguido se reinicia y empieza la programación remota de Arduino. El proceso se reliza dos veces en el vídeo.

Lo que se aprovecha es el método que tiene Arduino para programarse, ya que usando el puerto serie después de un reset se puede programar un Arduino si se sigue el protocolo STK500 implementado en el bootloader.

Esquema de conexiones

El Arduino y el display HD44780 se alimentan a 5 voltios, el módulo ESP8266 se alimenta a 3,3 voltios. Como el pin rx del módulo wifi sólo puede funcionar a 3,3V se usa un diodo zener de 3,3 voltios junto con una resistencia de 100 Ω.

En las placas Arduino, el pin de reset del microcontrolador está conectado a una resistencia y esta a su vez está conectada a VCC, con lo que para el microcontrolador el pin está a nivel alto. Cuando se pulsa el botón de reset lo que se hace es derivar la corriente hacia masa (ya que el bóton está conectado a esta) y el microcontrolador, al estar a nivel bajo el pin de reset, realiza un reseteo. Cuando el microcontrolador arranca, todos los pines están configurados como entradas (alta impedancia) y por eso no le afecta que el pin de reset esté conectado directamente al pin 12. Si se configura el pin 12 como salida y luego se conecta a masa (nivel bajo o LOW) se provoca el mismo efecto que si se pulsase el botón de reset, además, al existir la resistencia anteriormente mencionada, no hay que preocuparse de que se produzca un cortocircuito al unir VCC con masa (GND).

Sketch de Arduino

// Copyright (C) 2014 SISTEMAS O.R.P.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include <LiquidCrystal.h>

#define SEARCH_AFTER_RESET "ready"
#define INTRO "\r\n"

#define AP_NORMAL "SISTEMASORP"
#define PWD_NORMAL "mypassword"
#define HOST_NORMAL "192.168.1.33"
#define PORT_NORMAL "49000"

#define AP_BOOTLOADER "SISTEMASORP"
#define PWD_BOOTLOADER "mypassword"
#define HOST_BOOTLOADER "192.168.1.33"
#define PORT_BOOTLOADER "50000"


boolean ok = false;
int counter = 0;
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);
//-----------------------------------------------------------------------------------------------------------------------------------
/*
Parameters:
  show: The string to be printed.
Returns: 
  Nothing.
Description: 
  It clears the LCD and print the string.
*/
void print_lcd(String show)
{
  lcd.clear();
  lcd.print(show);
}
//-----------------------------------------------------------------------------------------------------------------------------------
/*
Parameters:
  command: The string to send.
  timeout: The maximum time in milliseconds the function can be running before a time out.
  wait_for1: The search string when the command succeeded.
  wait_for1: The search string when the command failed.
Returns: 
  The string contained in wait_for1, wait_for2 or the string TIMEOUT.
Description: 
  It sends the command trough the serial port and waits for one of the expected strings or exit with timeout
*/
String send(String command, int timeout, String wait_for1, String wait_for2)
{
  unsigned long time = millis();
  String received = "";
  
  Serial.print(command);
  Serial.print(INTRO);
  
  while(millis() < (time + timeout))
  {
    if(Serial.available() > 0)
    {
      received.concat(char(Serial.read()));
      if(received.indexOf(wait_for1) > -1)
      {
        return wait_for1;
      }
      else if(received.indexOf(wait_for2) > -1)
      {
        return wait_for2;
      }
    }
  }
  
  return "TIMEOUT";
}
//-----------------------------------------------------------------------------------------------------------------------------------
/*
Parameters:
  wait_for: The search string.
  timeout: The maximum time in milliseconds the function can be running before a time out.
Returns: 
  True if the string was found, otherwise False.
Description: 
  It waits for the expected string.
*/
boolean look_for(String wait_for, int timeout)
{
  unsigned long time = millis();
  String received = "";
  
  while(millis() < (time + timeout))
  {
    if(Serial.available() > 0)
    {
      received.concat(Serial.readString());
      if(received.indexOf(wait_for) > -1)
      {
        return true;
      }
    }
  }
  
  return false;
}
//-----------------------------------------------------------------------------------------------------------------------------------
/*
Parameters:
  command: The string to send.
  timeout: The maximum time in milliseconds the function can be running before a timeout.
  wait_for1: The search string when the command succeeded.
  wait_for1: The search string when the command failed.
Returns: 
  True if the wait_for1 string was found, otherwise False.
Description: 
  It sends the command trough the serial port and waits for one of the expected strings or exit with timeout.
*/
boolean send_command(String command, int timeout, String wait_for1, String wait_for2)
{
  String state;
  
  state = send(command, timeout, wait_for1, wait_for2);
  if(state == wait_for1)
  {
    return true;
  }
  else if(state == wait_for2)
  {
    // do something on error
  }
  else
  {
    // do something on timeout
  }
  
  return false;
}
//-----------------------------------------------------------------------------------------------------------------------------------
/*
Parameters:
  Nothing
Returns: 
  True if all commands were successfully, otherwise False.
Description: 
  It initializes the module, joins to the access point and connects to the server.
*/
boolean init_commands()
{
  print_lcd("Changing mode");
  if(send_command("AT+CWMODE=1", 5000, "OK", "ERROR"))
  {
    print_lcd("Resetting module");
    if (send_command("AT+RST", 5000, SEARCH_AFTER_RESET, "ERROR"))
    {
      print_lcd("Joining AP");
  
      String cwjap = "AT+CWJAP=\"";
      cwjap += AP_NORMAL;
      cwjap += "\",\"";
      cwjap += PWD_NORMAL;
      cwjap += "\"";
      if (send_command(cwjap, 20000, "OK", "FAIL"))
        if (send_command("AT+CIPMUX=0", 2000, "OK", "ERROR"))
          if (send_command("AT+CIPMODE=0", 2000, "OK", "ERROR"))
          {
            print_lcd("Connecting host");
            
            String cipstart = "AT+CIPSTART=\"TCP\",\"";
            cipstart += HOST_NORMAL;
            cipstart += "\",";
            cipstart += PORT_NORMAL;
            if (send_command(cipstart, 5000, "OK", "ERROR"))
              return true;
          }
    }
  }
            
  return false;
}
//-----------------------------------------------------------------------------------------------------------------------------------
/*
Parameters:
  Nothing
Returns: 
  True if all commands were successfully, otherwise False.
Description: 
  It initializes the module, joins to the access point, connects to the server and starts the protocol.
*/
boolean boot_commands()
{
  print_lcd("Joining AP");
  
  String cwjap = "AT+CWJAP=\"";
  cwjap += AP_BOOTLOADER;
  cwjap += "\",\"";
  cwjap += PWD_BOOTLOADER;
  cwjap += "\"";
  if (send_command(cwjap, 20000, "OK", "FAIL"))
    if (send_command("AT+CIPMUX=0", 2000, "OK", "ERROR"))
      if (send_command("AT+CIPMODE=1", 2000, "OK", "ERROR"))
      {
        print_lcd("Connecting host");
        
        String cipstart = "AT+CIPSTART=\"TCP\",\"";
        cipstart += HOST_BOOTLOADER;
        cipstart += "\",";
        cipstart += PORT_BOOTLOADER;
        if (send_command(cipstart, 5000, "OK", "ERROR"))
          if (send_command("AT+CIPSEND", 2000, ">", "ERROR"))
          {
            print_lcd("Init protocol");
            if (send_command("hello", 2000, "welcome", "error"))
              if (send_command("Arduino_remote_example.cpp.hex", 2000, "ok", "error"))
                return true;
          }
      }
            
  return false;
}
//-----------------------------------------------------------------------------------------------------------------------------------
/*
Parameters:
  Nothing
Returns: 
  True if all commands were successfully, otherwise False.
Description: 
  It sends a string to the remote host and show it in the display.
*/
boolean test()
{
  String command = "AT+CIPSEND=";
  String to_send = "hello guys! ";
  to_send += counter;
  command += to_send.length() + 2;
  
  if (send_command(command, 2000, ">", "ERROR"))
    if (send_command(to_send + "\r\n", 2000, "OK", "ERROR"))
    {
      lcd.clear();
      lcd.print(to_send);
      counter++;
      return true;
    }
  
  return false;
}
//-----------------------------------------------------------------------------------------------------------------------------------
void setup()
{
  pinMode(13, OUTPUT);
  Serial.begin(115200);
  lcd.begin(16, 2);
  lcd.print("Init WI07C...");
  
  // Remove any garbage from the RX buffer
  delay(3000);
  while(Serial.available() > 0) Serial.read();
  
  ok = init_commands();
}
//-----------------------------------------------------------------------------------------------------------------------------------
void loop()
{
  if(ok)
  {
    digitalWrite(13, HIGH);
    ok = test();
    if(ok && look_for("reboot", 5000))
    {
      if(boot_commands())
      {
        pinMode(12, OUTPUT);
        digitalWrite(12, LOW);
        for(;;);
      }
      else
      {
        ok = false;
      }
    }
  }  
  else
  {
    digitalWrite(13, LOW);
    lcd.clear();
    lcd.print("Error sending");
    lcd.setCursor(0, 1);
    lcd.print("AT commands");
    for(;;);
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program. If not, see <http://www.gnu.org/licenses/>.

#include <LiquidCrystal.h>

#define SEARCH_AFTER_RESET "ready"

#define INTRO "\r\n"

#define AP_NORMAL "SISTEMASORP"

#define PWD_NORMAL "mypassword"

#define HOST_NORMAL "192.168.1.33"

#define PORT_NORMAL "49000"

#define AP_BOOTLOADER "SISTEMASORP"

#define PWD_BOOTLOADER "mypassword"

#define HOST_BOOTLOADER "192.168.1.33"

#define PORT_BOOTLOADER "50000"

boolean ok = false;

int counter = 0;

LiquidCrystal lcd(2, 3, 4, 5, 6, 7);

//-----------------------------------------------------------------------------------------------------------------------------------

Parameters:

show: The string to be printed.

Returns:

Nothing.

Description:

It clears the LCD and print the string.

void print_lcd(String show)

{

lcd.clear();

lcd.print(show);

}

//-----------------------------------------------------------------------------------------------------------------------------------

Parameters:

command: The string to send.

timeout: The maximum time in milliseconds the function can be running before a time out.

wait_for1: The search string when the command succeeded.

wait_for1: The search string when the command failed.

Returns:

The string contained in wait_for1, wait_for2 or the string TIMEOUT.

Description:

It sends the command trough the serial port and waits for one of the expected strings or exit with timeout

String send(String command, int timeout, String wait_for1, String wait_for2)

{

unsigned long time = millis();

String received = "";

Serial.print(command);

Serial.print(INTRO);

while(millis() < (time + timeout))

{

if(Serial.available() > 0)

{

received.concat(char(Serial.read()));

if(received.indexOf(wait_for1) > -1)

{

return wait_for1;

}

else if(received.indexOf(wait_for2) > -1)

{

return wait_for2;

}

return "TIMEOUT";

}

//-----------------------------------------------------------------------------------------------------------------------------------

Parameters:

wait_for: The search string.

timeout: The maximum time in milliseconds the function can be running before a time out.

Returns:

True if the string was found, otherwise False.

Description:

It waits for the expected string.

boolean look_for(String wait_for, int timeout)

{

unsigned long time = millis();

String received = "";

while(millis() < (time + timeout))

{

if(Serial.available() > 0)

{

received.concat(Serial.readString());

if(received.indexOf(wait_for) > -1)

{

return true;

}

return false;

}

//-----------------------------------------------------------------------------------------------------------------------------------

Parameters:

command: The string to send.

timeout: The maximum time in milliseconds the function can be running before a timeout.

wait_for1: The search string when the command succeeded.

wait_for1: The search string when the command failed.

Returns:

True if the wait_for1 string was found, otherwise False.

Description:

It sends the command trough the serial port and waits for one of the expected strings or exit with timeout.

boolean send_command(String command, int timeout, String wait_for1, String wait_for2)

{

String state;

state = send(command, timeout, wait_for1, wait_for2);

if(state == wait_for1)

{

return true;

}

else if(state == wait_for2)

{

// do something on error

}

else

{

// do something on timeout

}

return false;

}

//-----------------------------------------------------------------------------------------------------------------------------------

Parameters:

Nothing

Returns:

True if all commands were successfully, otherwise False.

Description:

It initializes the module, joins to the access point and connects to the server.

boolean init_commands()

{

print_lcd("Changing mode");

if(send_command("AT+CWMODE=1", 5000, "OK", "ERROR"))

{

print_lcd("Resetting module");

if (send_command("AT+RST", 5000, SEARCH_AFTER_RESET, "ERROR"))

{

print_lcd("Joining AP");

String cwjap = "AT+CWJAP=\"";

cwjap += AP_NORMAL;

cwjap += "\",\"";

cwjap += PWD_NORMAL;

cwjap += "\"";

if (send_command(cwjap, 20000, "OK", "FAIL"))

if (send_command("AT+CIPMUX=0", 2000, "OK", "ERROR"))

if (send_command("AT+CIPMODE=0", 2000, "OK", "ERROR"))

{

print_lcd("Connecting host");

String cipstart = "AT+CIPSTART=\"TCP\",\"";

cipstart += HOST_NORMAL;

cipstart += "\",";

cipstart += PORT_NORMAL;

if (send_command(cipstart, 5000, "OK", "ERROR"))

return true;

}

return false;

}

//-----------------------------------------------------------------------------------------------------------------------------------

Parameters:

Nothing

Returns:

True if all commands were successfully, otherwise False.

Description:

It initializes the module, joins to the access point, connects to the server and starts the protocol.

boolean boot_commands()

{

print_lcd("Joining AP");

String cwjap = "AT+CWJAP=\"";

cwjap += AP_BOOTLOADER;

cwjap += "\",\"";

cwjap += PWD_BOOTLOADER;

cwjap += "\"";

if (send_command(cwjap, 20000, "OK", "FAIL"))

if (send_command("AT+CIPMUX=0", 2000, "OK", "ERROR"))

if (send_command("AT+CIPMODE=1", 2000, "OK", "ERROR"))

{

print_lcd("Connecting host");

String cipstart = "AT+CIPSTART=\"TCP\",\"";

cipstart += HOST_BOOTLOADER;

cipstart += "\",";

cipstart += PORT_BOOTLOADER;

if (send_command(cipstart, 5000, "OK", "ERROR"))

if (send_command("AT+CIPSEND", 2000, ">", "ERROR"))

{

print_lcd("Init protocol");

if (send_command("hello", 2000, "welcome", "error"))

if (send_command("Arduino_remote_example.cpp.hex", 2000, "ok", "error"))

return true;

}

return false;

}

//-----------------------------------------------------------------------------------------------------------------------------------

Parameters:

Nothing

Returns:

True if all commands were successfully, otherwise False.

Description:

It sends a string to the remote host and show it in the display.

boolean test()

{

String command = "AT+CIPSEND=";

String to_send = "hello guys! ";

to_send += counter;

command += to_send.length() + 2;

if (send_command(command, 2000, ">", "ERROR"))

if (send_command(to_send + "\r\n", 2000, "OK", "ERROR"))

{

lcd.clear();

lcd.print(to_send);

counter++;

return true;

}

return false;

}

//-----------------------------------------------------------------------------------------------------------------------------------

void setup()

{

pinMode(13, OUTPUT);

Serial.begin(115200);

lcd.begin(16, 2);

lcd.print("Init WI07C...");

// Remove any garbage from the RX buffer

delay(3000);

while(Serial.available() > 0) Serial.read();

ok = init_commands();

}

//-----------------------------------------------------------------------------------------------------------------------------------

void loop()

{

if(ok)

{

digitalWrite(13, HIGH);

ok = test();

if(ok && look_for("reboot", 5000))

{

if(boot_commands())

{

pinMode(12, OUTPUT);

digitalWrite(12, LOW);

for(;;);

}

else

{

ok = false;

}

else

{

digitalWrite(13, LOW);

lcd.clear();

lcd.print("Error sending");

lcd.setCursor(0, 1);

lcd.print("AT commands");

for(;;);

}

Lo que hace el skecth de Arduino es:

Inicializa el puerto serie a 115200 bps.
Elimina los caracteres que hubiera en el buffer de entrada del puerto serie.
Inicializa el módulo wifi en modo estación, lo resetea, se conecta al punto de acceso normal, configura las conexiones como simples en modo normal y se conecta al servidor normal por el puerto 49000. Si hubiese algún fallo en algún punto pararía la ejecución y lo indicaría en el display.
Envia una cadena de texto y un número consecutivo tanto al servidor como al display. Si hubiese algún fallo en algún punto pararía la ejecución y lo indicaría en el display.
Si entre el envío de las cadenas de texto se recibe una cadena reboot entonces resetea el módulo, se conecta al punto de acceso bootloader, configura las conexiones como simples en modo normal y se conecta al servidor de programación por el puerto 50000. Acto seguido envía una cadena hello y espera a recibir una cadena welcome, si ha sido así, entonces envía el nombre del fichero .hex con el que quiere ser programado el Arduino y espera a recibir una cadena ok, momento en el cual configura el pin 12 como salida y lo pone a nivel bajo, conectándolo a masa y provocando un reset en el Arduino. Si hubiese algún fallo en algún punto pararía la ejecución y lo indicaría en el display.

Aquí cabe destacar cómo funciona el sistema de reseteo: Justo después del reseteo, el pin de TX de Arduino está a nivel bajo durante un tiempo, lo que provoca que el módulo wifi vea eso como un byte 0, que enviará a través de la conexión TCP/IP. El servidor de programación aprovechará esta circunstancia para saber cuando ha empezado el reseteo e iniciar el protocolo STK500. El bootloader de Arduino entra en acción después del reseteo y espera a recibir ordenes del protocolo STK500, si las recibe actúa en consecuencia, si no, ejecuta el programa principal.

Servidor de programación

#!/usr/bin/env python

# Copyright (C) 2014 SISTEMAS O.R.P.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import sys
import binascii
import struct
import select
import socket
import errno

MAX_TIMEOUT = 500
SUCCESS = "success"
FAILED = "failed"
PORT = 50000
#-------------------------------------------------------------------------------------------------
'''
Class containing the data from non-contiguous memory allocations
'''
class Data:
	def __init__(self, begin, data):
		self.begin = begin
		self.data = data
		self.count = len(data)
#-------------------------------------------------------------------------------------------------
'''
Parameters:
	line: The line to parse
Returns: 
	The size of data. The address of data. The type of data. The line checksum. True if the checksum is correct, otherwise False.
Description: 
	It parses a line from the .hex file.
'''
def parse_line(line):
		ok = False
		size = int(line[1:3], 16)
		address = int(line[3:7], 16)
		type = int(line[7:9], 16)
		next_index = (9 + size * 2)
		data = binascii.a2b_hex(line[9:next_index])
		checksum = int(line[next_index:], 16)
		
		#checking if checksum is correct
		sum = size + (address >> 8) + (address & 0xFF) + type
		for byte in data:
			sum += ord(byte)

		if (~(sum & 0xFF) + 1) & 0xFF == checksum:
			ok = True

		return (size, address, type, data, checksum, ok)
#-------------------------------------------------------------------------------------------------
'''
Parameters:
	chunks: An array with different chunks of data.
	path: The path to the .hex file to read
Returns: 
	True if the reading was successfully, otherwise False.
Description: 
	It reads a .hex file and stores the data in memory.
'''
def read_hex_file(chunks, path):
	try:
		file = open(path, 'r')
	except IOError:
		print "Hex file not loaded"
		return False
	line = file.readline()
	if line[0] != ':':
		print "The file seems to be a not valid .hex file"
		file.close()
		return False
		
	size, address, type, data, checksum, ok = parse_line(line.strip())
	if not ok:
		print "The checksum in line 1 is wrong"
		file.close()
		return False

	chunks.append(Data(address, data))

	# Read the other lines
	index = 0
	count = 2
	for line in file:
		size, address, type, data, checksum, ok = parse_line(line.strip())
		if not ok:
			print "The checksum in line", count, "is wrong"
			file.close()
			return False

		if chunks[index].begin + chunks[index].count == address:
			chunks[index].count += size
			for code in data:
				chunks[index].data += code
		else:
			chunks.append(Data(address, data))
			index += 1
		count += 1
	
	return True
#-------------------------------------------------------------------------------------------------	
'''
Parameters:
	None
Returns: 
	The server socket
Description: 
	It opens a server socket at the specified port and listens to connections.
'''
def init_server():
	server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	server.bind(('', PORT))
	server.listen(1)
	return server
#-------------------------------------------------------------------------------------------------	
'''
Parameters:
	cli: The client socket
	response: The search string
	timeout: The maximum time in milliseconds the function can be running before a time out.
Returns: 
	True if the string was found, otherwise False. The received string.
Description: 
	It waits for the expected string.
'''
def wait_for(cli, response, timeout):
	inputs = [cli]
	received = ""
	milliseconds = 0
	while milliseconds < timeout:
		rlist, wlist, xlist = select.select(inputs,[],[], 0.001)
		if len(rlist) > 0:
			received += cli.recv(1)
			if response in received:
				return True, received
		milliseconds += 1
		
	return False, received
#-------------------------------------------------------------------------------------------------	
'''
Parameters:
	cli: The client socket
	timeout: The maximum time in milliseconds the function can be running before a time out.
	length: The number of bytes to receive.
Returns: 
	True if the string has the required length, otherwise False. The received string.
Description: 
	It waits for the required length of bytes.
'''
def return_data(cli, timeout, length = 1):
	inputs = [cli]
	received = ""
	milliseconds = 0
	while milliseconds < timeout:
		rlist, wlist, xlist = select.select(inputs,[],[], 0.001)
		if len(rlist) > 0:
			received = cli.recv(length)
			return True, received
		milliseconds += 1
		
	return False, received
#-------------------------------------------------------------------------------------------------
'''
Parameters:
	cli: The client socket
Returns: 
	True if the string was found, otherwise False
Description: 
	It waits for the acknowledge string.
'''
def acknowledge(cli):
	if wait_for(cli, "\x14\x10", MAX_TIMEOUT)[0]: #STK_INSYNC, STK_OK
		print SUCCESS
		return True
	else:
		print FAILED
		return False
#-------------------------------------------------------------------------------------------------		
'''
Parameters:
	chunks: An array with different chunks of data.
	cli: The client socket
Returns: 
	Nothing
Description: 
	It starts the STK500 protocol to program the data at their respective memory address.
'''
def program_process(chunks, cli):
	print "Connection to Arduino bootloader:",
	
	counter = 0
	cli.send("\x30\x20") #STK_GET_SYNCH, SYNC_CRC_EOP
	if not acknowledge(cli):
		return

	print "Enter in programming mode:",
	cli.send("\x50\x20") #STK_ENTER_PROGMODE, SYNC_CRC_EOP
	if not acknowledge(cli):
		return
		
	print "Read device signature:",
	cli.send("\x75\x20") #STK_READ_SIGN, SYNC_CRC_EOP
	if wait_for(cli, "\x14", MAX_TIMEOUT)[0]: #STK_INSYNC
		ok,received = return_data(cli, MAX_TIMEOUT, 3)
		print binascii.b2a_hex(received)
		if not wait_for(cli, "\x10", MAX_TIMEOUT)[0]: #STK_INSYNC
			print FAILED
			return
	else:
		print FAILED
		return

	for chunk in chunks:
		total = chunk.count
		if total > 0: #avoid the last block (the last line of .hex file)
			current_page = chunk.begin
			pages = total / 0x80
			index = 0
			
			for page in range(pages):
				print "Load memory address",current_page,":",
				cli.send(struct.pack("<BHB", 0x55, current_page, 0x20)) #STK_LOAD_ADDRESS, address, SYNC_CRC_EOP
				if not acknowledge(cli):
					return
				
				print "Program memory address:",
				cli.send("\x64\x00\x80\x46" + chunk.data[index:index + 0x80] + "\x20") #STK_PROGRAM_PAGE, page size, flash memory, data, SYNC_CRC_EOP
				if not acknowledge(cli):
					return
				current_page += 0x40
				total -= 0x80
				index += 0x80
			
			if total > 0:
				print "Load memory address",current_page,":",
				cli.send(struct.pack("<BHB", 0x55, current_page, 0x20)) #STK_LOAD_ADDRESS, address, SYNC_CRC_EOP
				if not acknowledge(cli):
					return
				
				print "Program memory address:",
				cli.send(struct.pack(">BHB", 0x64, total, 0x20) + chunk.data[index:index + total] + "\x20") #STK_PROGRAM_PAGE, page size, flash memory, data, SYNC_CRC_EOP
				if not acknowledge(cli):
					return

	print "Leave programming mode:",
	cli.send("\x51\x20") #STK_LEAVE_PROGMODE, SYNC_CRC_EOP
	acknowledge(cli)
#-------------------------------------------------------------------------------------------------		
def main():
	print "Arduino remote programmer 2014 (c) SISTEMAS O.R.P"
	
	print "Listen to connections"
	ser = init_server()
	inputs = [ser]
	
	while True:
		rlist, wlist, xlist = select.select(inputs,[],[])
		for s in rlist:
			if s == ser:
				cli, addr = s.accept()
				print addr[0], "connected"
				# It assures the connection is for programming an Arduino and not other service.
				if wait_for(cli, "hello", 5000)[0]:
					cli.send("welcome")
					ok, received = wait_for(cli, "hex", 5000)
					if ok:
						chunks = []
						print "Read hex file", received.strip()
						if read_hex_file(chunks, received.strip()):
							cli.send("ok")
							# Wait for the byte '0' sent by Arduino after resetting
							if wait_for(cli, "\x00", MAX_TIMEOUT)[0]:
								program_process(chunks, cli)
						else:
							cli.send("error")
				cli.close()
				print "Listen to connections"
#-------------------------------------------------------------------------------------------------
if __name__ == "__main__":
	main()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

#!/usr/bin/env python

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

import sys

import binascii

import struct

import select

import socket

import errno

MAX_TIMEOUT = 500

SUCCESS = "success"

FAILED = "failed"

PORT = 50000

#-------------------------------------------------------------------------------------------------

'''

Class containing the data from non-contiguous memory allocations

'''

class Data:

def __init__(self, begin, data):

self.begin = begin

self.data = data

self.count = len(data)

#-------------------------------------------------------------------------------------------------

'''

Parameters:

line: The line to parse

Returns:

The size of data. The address of data. The type of data. The line checksum. True if the checksum is correct, otherwise False.

Description:

It parses a line from the .hex file.

'''

def parse_line(line):

ok = False

size = int(line[1:3], 16)

address = int(line[3:7], 16)

type = int(line[7:9], 16)

next_index = (9 + size * 2)

data = binascii.a2b_hex(line[9:next_index])

checksum = int(line[next_index:], 16)

#checking if checksum is correct

sum = size + (address >> 8) + (address & 0xFF) + type

for byte in data:

sum += ord(byte)

if (~(sum & 0xFF) + 1) & 0xFF == checksum:

ok = True

return (size, address, type, data, checksum, ok)

#-------------------------------------------------------------------------------------------------

'''

Parameters:

chunks: An array with different chunks of data.

path: The path to the .hex file to read

Returns:

True if the reading was successfully, otherwise False.

Description:

It reads a .hex file and stores the data in memory.

'''

def read_hex_file(chunks, path):

try:

file = open(path, 'r')

except IOError:

print "Hex file not loaded"

return False

line = file.readline()

if line[0] != ':':

print "The file seems to be a not valid .hex file"

file.close()

return False

size, address, type, data, checksum, ok = parse_line(line.strip())

if not ok:

print "The checksum in line 1 is wrong"

file.close()

return False

chunks.append(Data(address, data))

# Read the other lines

index = 0

count = 2

for line in file:

size, address, type, data, checksum, ok = parse_line(line.strip())

if not ok:

print "The checksum in line", count, "is wrong"

file.close()

return False

if chunks[index].begin + chunks[index].count == address:

chunks[index].count += size

for code in data:

chunks[index].data += code

else:

chunks.append(Data(address, data))

index += 1

count += 1

return True

#-------------------------------------------------------------------------------------------------

'''

Parameters:

None

Returns:

The server socket

Description:

It opens a server socket at the specified port and listens to connections.

'''

def init_server():

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

server.bind(('', PORT))

server.listen(1)

return server

#-------------------------------------------------------------------------------------------------

'''

Parameters:

cli: The client socket

response: The search string

timeout: The maximum time in milliseconds the function can be running before a time out.

Returns:

True if the string was found, otherwise False. The received string.

Description:

It waits for the expected string.

'''

def wait_for(cli, response, timeout):

inputs = [cli]

received = ""

milliseconds = 0

while milliseconds < timeout:

rlist, wlist, xlist = select.select(inputs,[],[], 0.001)

if len(rlist) > 0:

received += cli.recv(1)

if response in received:

return True, received

milliseconds += 1

return False, received

#-------------------------------------------------------------------------------------------------

'''

Parameters:

cli: The client socket

timeout: The maximum time in milliseconds the function can be running before a time out.

length: The number of bytes to receive.

Returns:

True if the string has the required length, otherwise False. The received string.

Description:

It waits for the required length of bytes.

'''

def return_data(cli, timeout, length = 1):

inputs = [cli]

received = ""

milliseconds = 0

while milliseconds < timeout:

rlist, wlist, xlist = select.select(inputs,[],[], 0.001)

if len(rlist) > 0:

received = cli.recv(length)

return True, received

milliseconds += 1

return False, received

#-------------------------------------------------------------------------------------------------

'''

Parameters:

cli: The client socket

Returns:

True if the string was found, otherwise False

Description:

It waits for the acknowledge string.

'''

def acknowledge(cli):

if wait_for(cli, "\x14\x10", MAX_TIMEOUT)[0]: #STK_INSYNC, STK_OK

print SUCCESS

return True

else:

print FAILED

return False

#-------------------------------------------------------------------------------------------------

'''

Parameters:

chunks: An array with different chunks of data.

cli: The client socket

Returns:

Nothing

Description:

It starts the STK500 protocol to program the data at their respective memory address.

'''

def program_process(chunks, cli):

print "Connection to Arduino bootloader:",

counter = 0

cli.send("\x30\x20") #STK_GET_SYNCH, SYNC_CRC_EOP

if not acknowledge(cli):

return

print "Enter in programming mode:",

cli.send("\x50\x20") #STK_ENTER_PROGMODE, SYNC_CRC_EOP

if not acknowledge(cli):

return

print "Read device signature:",

cli.send("\x75\x20") #STK_READ_SIGN, SYNC_CRC_EOP

if wait_for(cli, "\x14", MAX_TIMEOUT)[0]: #STK_INSYNC

ok,received = return_data(cli, MAX_TIMEOUT, 3)

print binascii.b2a_hex(received)

if not wait_for(cli, "\x10", MAX_TIMEOUT)[0]: #STK_INSYNC

print FAILED

return

else:

print FAILED

return

for chunk in chunks:

total = chunk.count

if total > 0: #avoid the last block (the last line of .hex file)

current_page = chunk.begin

pages = total / 0x80

index = 0

for page in range(pages):

print "Load memory address",current_page,":",

cli.send(struct.pack("<BHB", 0x55, current_page, 0x20)) #STK_LOAD_ADDRESS, address, SYNC_CRC_EOP

if not acknowledge(cli):

return

print "Program memory address:",

cli.send("\x64\x00\x80\x46" + chunk.data[index:index + 0x80] + "\x20") #STK_PROGRAM_PAGE, page size, flash memory, data, SYNC_CRC_EOP

if not acknowledge(cli):

return

current_page += 0x40

total -= 0x80

index += 0x80

if total > 0:

print "Load memory address",current_page,":",

cli.send(struct.pack("<BHB", 0x55, current_page, 0x20)) #STK_LOAD_ADDRESS, address, SYNC_CRC_EOP

if not acknowledge(cli):

return

print "Program memory address:",

cli.send(struct.pack(">BHB", 0x64, total, 0x20) + chunk.data[index:index + total] + "\x20") #STK_PROGRAM_PAGE, page size, flash memory, data, SYNC_CRC_EOP

if not acknowledge(cli):

return

print "Leave programming mode:",

cli.send("\x51\x20") #STK_LEAVE_PROGMODE, SYNC_CRC_EOP

acknowledge(cli)

#-------------------------------------------------------------------------------------------------

def main():

print "Arduino remote programmer 2014 (c) SISTEMAS O.R.P"

print "Listen to connections"

ser = init_server()

inputs = [ser]

while True:

rlist, wlist, xlist = select.select(inputs,[],[])

for s in rlist:

if s == ser:

cli, addr = s.accept()

print addr[0], "connected"

# It assures the connection is for programming an Arduino and not other service.

if wait_for(cli, "hello", 5000)[0]:

cli.send("welcome")

ok, received = wait_for(cli, "hex", 5000)

if ok:

chunks = []

print "Read hex file", received.strip()

if read_hex_file(chunks, received.strip()):

cli.send("ok")

# Wait for the byte '0' sent by Arduino after resetting

if wait_for(cli, "\x00", MAX_TIMEOUT)[0]:

program_process(chunks, cli)

else:

cli.send("error")

cli.close()

print "Listen to connections"

#-------------------------------------------------------------------------------------------------

if __name__ == "__main__":

main()

Lo que hace el servidor de programación es:

Crea un socket que escuche por el puerto 50000
Cuando un cliente de conecta espera a la cadena hello, si la recibe reponde con una cadena welcome.
Espera a que el cliente le envíe un nombre de fichero .hex. Trata de abrir el fichero en el mismo directorio y lo lee interpretando todas las líneas para guardar los datos del programa en memoria. Si todo va bien envía una cadena ok.
Espera a recibir el byte 0, y cuando lo recibe empieza el protocolo STK500 para comunicarse con el bootloader de Arduino y programarlo. Básicamente lo que hace es entrar en modo de programación, indicarle a que páginas quiere acceder y enviar los datos de cada página, así hasta que ha enviado todos los datos del programa, después sale del modo de programación cerrando la conexión

Aquí cabe destacar que cuando se cierra la conexión TCP/IP con el cliente (ya sea por un error o porque el proceso de programación ya ha terminado), el módulo ESP8266 sale del modo de datos automáticamente y no es necesario que el nuevo sketch tenga que enviarle la cadena de escape +++ para poder entrar otra vez en modo de comandos.

Conclusiones

Espero que esto os sirva para que en vuestros proyectos podais programar remotamente vuestros Arduinos a través de una red local o Internet.

Habría que tener en cuenta que el proceso de actualización puede quedarse a medias si la conexión a la red wifi es lenta y provocaría que el programa no se ejecutara correctamente. Así que que una mejora sería acoplar un chip aparte que reprogramase el Arduino por ICSP con un programa preestablecido en caso de que detectase que la programación no fue finalizada correctamente.

Comentar que la versión de firmware del módulo ESP8266 que he usado es la 0019000902 y el Arduino es un UNO. Ambos funcionan a 115200 bps, pero si quisierais utilizar otras velocidades (en otros Arduinos el bootloader configura el puerto serie a 19200 o 57600 bps) habría que cargar un firmware que lo permitiese, como por ejemplo la versión 0.922 de electrodragon y su comando AT+CIOBAUD.

Probando el módulo wifi ESP8266

63 respuestas

Últimamente en el mundo DIY se está hablando de un módulo wifi barato y potente que está basado en el chip ESP8266.

El precio de cada unidad está en alrededor de 5$ y es capaz de comunicarse más allá de los 300 metros usando la antena que viene incorporada en la placa.

Yo he comprado una pareja por menos de 10$ en aliexpress, y en este artículo voy a comentar cómo hacerlo funcionar.

Lo primero que hay que indicar es que funciona a 3,3V. y lo segundo es que se comunica mediante el puerto serie que tiene el módulo. Por ello no se puede conectar directamente a un Arduino que funciona a 5 voltios, así que necesitareis convertir las líneas TX, RX y la alimentción a 3,3V.

El módulo tiene 8 pines repartidos en 2 filas. El esquema de conexiones es este:

Hay varias versiones del módulo. En las más recientes será necesario que el pin activar esté puesto a VCC (o una salida digital a 1) para hacerlo funcionar.

Para probar el módulo he usado un conversor usb a serie que funciona a 3,3V. Sin embargo el módulo puede llegar de consumir unos 200mA en algunos momentos por lo que lo he alimentado aparte con un regulador, eso si, uniendo siempre las masas.

Me he conectado por putty a 115200 bps al puerto serie de conversor y acto seguido he dado alimentación al módulo, con lo que sale el primer mensaje indicándonos que está preparado:

Todo el comportamiento del módulo se basa en comandos AT, por lo que vamos a inicializarlo con:

AT+RST

AT+RST

El siguiente paso es configurar el tipo de wifi. Para este ejemplo lo configuraré como estación (que es como está por defecto):

AT+CWMODE=1

1	AT+CWMODE=1

Lo siguiente será mostrar una lista de las wifis disponibles:

AT+CWLAP

AT+CWLAP

Me conectaré a SISTEMASORP con la clave que tengo:

AT+CWJAP="SISTEMASORP","miclave"

1	AT+CWJAP="SISTEMASORP","miclave"

Ahora comprobamos qué IP me ha dado el router:

AT+CIFSR

AT+CIFSR

Eso significa que hemos conectado con éxito y que ya tenemos una IP.

Mi siguiente paso ha sido crear un script php muy simple en mi servidor web que muestra la cadena Hola seguida de la fecha actual. El objetivo es hacer una llamada al servidor web, hacerle una petición http y que este nos devuelva la cadena mencionada.

Para ello debemos configurar el módulo para que haga una sola conexión (aunque se pueden hacer hasta 5 simultáneas):

AT+CIPMUX=0

1	AT+CIPMUX=0

Conectamos al servidor web mediante un socket TCP por el puerto 80:

AT+CIPSTART="TCP","66.147.244.243",80

1	AT+CIPSTART="TCP","66.147.244.243",80

Le indicamos cuántos caracteres le vamos a enviar:

AT+CIPSEND=50

1	AT+CIPSEND=50

Esto nos mostrará un símbolo >, donde le meteremos la cadena a enviar. Para el ejemplo seguiremos los siguientes pasos en el putty:

Copiamos y pegamos GET /prueba.php HTTP/1.0
Pulsamos CTRL+M y CTRL+J
Copiamos y pegamos Host: sistemasorp.es
Pulsamos CTRL+M y CTRL+J y otra vez CTRL+M y CTRL+J

Si todo ha ido bien recibiremos una respuesta +IPD con el número de bytes recibidos, la cabecera http del servidor y la cadena esperada:

El protocolo http especifica que el socket debe ser cerrado después de enviar la respuesta, por eso vemos un Unlink, si en otro caso queremos cerrar nosotros la conexión, debemos usar el comando:

AT+CIPCLOSE

1	AT+CIPCLOSE

Hay más funcionalidades que se pueden usar con los comandos AT, aquí una lista de ellos.

Espero que con este ejemplo os sirva para empezar a dar uso a estos módulos wifi tan baratos y funcionales.

Actualización 09/10/2014:

Si se desea enviar y recibir datos en bruto, es decir, sin tener que mediar con la cantidad de bytes del comando AT+CIPSEND y la respuesta IPD, podemos activar el modo de datos con el siguiente comando:

AT+CIPMODE=1

1	AT+CIPMODE=1

Y cuando queramos enviar y recibir datos, lo hacemos con CIPSEND sin poner los bytes a enviar:

AT+CIPSEND

1	AT+CIPSEND

Así entramos en el modo de datos y todo lo que recibe el módulo por el pin RX lo envía por wifi y todo lo que recibe el módulo por wifi lo envía por el pin TX. Para salir de este modo hay que esperar 1 segundo sin enviar nada, enviar la secuencia de escape formada por 3 símbolos más +++ y esperar otro segundo sin enviar nada, momento en el cual volvemos a entrar en el modo de comandos. Este vídeo que he grabado muestra esa funcionalidad:

En el vídeo por un lado tengo el putty conectado al módulo y por el otro creo un servidor con netcat en el puerto 9000. Cuando entro en modo de datos escribo en la ventana putty Hello, cosa que se ve reflejada en la ventana de netcat. Acto seguido escribo Welcome to ESP8266 en la ventana de netcat y pulso enter (si no netcat no envía nada), para a continuación mostrarse en la ventana de putty. Finalmente copio y pego la secuencia de escape +++ para salir del modo datos al modo comandos (hay que hacerlo rápido, ya que escribiéndolo directamente no me ha salido).

Encender petardos y cohetes con Arduino y Android

12 respuestas

Creo que a estas alturas todos hemos visto cómo se encienden petardos y cohetes: simplemente acercando la llama de un mechero a la mecha de estos y la magia de la pólvora hace el resto.

En este artículo voy a explicar cómo hacer el mismo proceso pero de una forma más segura, y por supuesto más tecnológica.

Pero antes unas reglas básicas:

Los petardos y los cohetes son peligrosos, por eso se cauteloso cuando los manejes.
No enciendas un petardo o un cohete en la mano ni cerca de ti, de otras personas o animales.
No molestes a la gente encendiéndolos en zonas residenciales ni en horarios intempestivos.
Muchos municipios tienen prohibido el uso de material pirotécnico en toda su zona metropolitana.
El hilo de nicrom alcanza temperaturas elevadas, cerciorate que no pasa corriente por él cuando lo estés manejando.
Las baterías de litio son peligrosas, sigue las instrucciones de seguridad que las acompañan.
Usa cableado que permita un valor de corriente en amperios mucho mayor que lo que va a consumir el sistema.

Este artículo es meramente divulgativo y no me hago responsable de cualquier incidencia que pudiera ocurrir si lo pones en práctica, por tanto si lo llevas a cabo será bajo tu propia responsabilidad.

La idea es encender la mecha de petardos o cohetes desde un móvil Android, tal y como se puede ver en el siguiente vídeo que grabé para la demostración:

El esquema de los componentes es el siguiente:

Empezamos por una batería LiPo de 3 celdas (11,1 V.) que será la encargada de la alimentación del conjunto. Todo el cableado está pensado para corrientes de 10 A, pero puede diferir según tus necesidades.

Seguimos con un fusible de 10A, que será el que corte la corriente si se produce un cortocircuito (por ejemplo en el caso de que debido a la explosión de un petardo se unieran directamente los terminales VCC y GND que sujetan el hilo de nicrom).

A continuación está el hilo de nicrom. Este cable, que tiene muy poca resistencia (2,2 Ω en mi caso), se pone al rojo vivo cuando pasa una corriente a través de el. La velocidad a la que se calienta depende del voltaje que se aplique, lo normal suele ser alrededor de los 12 voltios. Este hará las veces de encendedor de la mecha, ya que puede llegar a los 300º C. Se puede adquirir en cualquier tienda de electrónica o reciclarse de un secador de pelo o de una tostadora.

Después viene un transistor mosfet de canal N, que será el interruptor que hará que el hilo de nicrom se encienda o se apague. Hay muchos tipos de mosfet de canal N, por lo que nos interesa uno que pueda ser usado con microcontroladores con lógica TTL (como el de la placa Arduino). Yo he usado el STP55NF06L con encapsulamiento TO-220 ¿por qué?, pues en la hoja de características podemos verlo:

El Vds es de 60 V. Como voy a usar 12 V. Tengo más que de sobra.

El Id es de 55 A. Según la ley de Ohm, La fuente de alimentación de 12 V. partido por la resistencia del hilo de nicrom con 2,2 Ω nos dá que se consumen unos 5 A. Igualmente tengo mucho margen.

El Vgs(th) minima es de 1V. Eso significa que cuando el voltaje es menor que 1V el circuito está abierto y que por encima de esto cerrará el circuito dejando pasar la corriente. Ideal para el Arduino que trabaja con 5 V.

La Rds(on) máxima es muy baja: 0,020 Ω. Esto significa que prácticamente el mosfet no se calentará con la corriente con la que le hagamos trabajar (5 A. * 5 A. * 0,020 Ω = 0,5 Watios)

La gráfica Id/Vds indica que con 5 V en el pin Gate del mosfet, podemos conducir una tensión de 12 V. con una carga de mucho más de 120 A. Como sólo tenemos unos 5 A. tenemos más que suficiente.

Como se trata de un mosfet de canal N, el pin Source (3) tiene que ir a masa y el pin Drain (2) tiene que estar conectado a la carga. El pin Gate (1) tiene que estar conectado a Arduino, que será quien le dirá si tiene que estar abierto o no. Además entre la conexión del Arduino y Gate hay una resistencia de 10K que va a masa directamente, esto es para que:

La puerta lógica no quede flotante y su estado esté indeterminado (pudiendo activar el nicrom antes de tiempo), por lo que si el pin de Arduino esta puesto configurado como entrada (al arrancar siempre está asi) el Gate esté conectado a masa (0 V. o LOW).
Debido al caso anterior, cuando el pin de Arduino está configurado como salida y pone la entrada a 5 V. (o HIGH), la resistencia de 10K hace que no haya cortocircuito con masa.

Proseguimos con la placa Arduino, cuyo programa se puede descargar de aquí. La placa está alimentada también desde la batería LiPo, ya sea directamente a los pines Vin y GND o a través del conector de alimentación. Unido a Arduino está un módulo Bluetooth HC-06 que será el encargado de comunicarse con el móvil.

Finalmente en el móvil, que tiene que tener el sistema operativo Android, hay que instalar la aplicación ArduDroid desde la Play Store, que con su interfaz sencilla podemos manejar los pines de Arduino directamente.

Humanoids 2014

Deja un comentario

BannerRobots

Del martes 18 al jueves 20 de Noviembre se celebrará en el hotel Melía Castilla de Madrid la conferencia Humanoids 2014. Este evento, organizado por la Universidad Carlos III y el IEEE Robotics & Automation Society, estará enfocado este año en la iteración entre máquinas antropomorfas y humanos.

También se dará esos días la competición HUMABOT, donde robots humanoides competirán por ser el perfecto asistente en el hogar.

Como visitas técnicas, se podra ver la sede AIRBUS en Getafe, la fábrica de PSA (Peugeot – Citröen) en Madrid, el Robotics Lab de la Universidad de Carlos III y el Centro de Automática y Robótica del CSIC-UPM.

Bilbot

Deja un comentario

bilbot

Un nuevo evento sobre robótica se celebrará probablemente en Junio de este año. En esta ocasión será en Bilbao y estará centrado en lucha de robots, o como más se conoce Robot Wars.

El evento se llama Bilbot y la empresa encargada de organizarlo es BlowOut Events. Aún no se conocen fechas ni el lugar exacto, pero se puede hacer la pre-reserva (no obliga a nada a los interesados, no es vinculante, ni requiere aportación económica de reserva) para competir en este evento enviando los siguientes datos a blowoutbilbao@gmail.com:

Nombre “artístico” del equipo de creadores
Nombre del robot concursante
Universidad, Escuela, o Asociación a la que pertenezcan
Datos de los componentes del equipo, correo electrónico y otras formas de contacto.

Los premios son los siguientes:

1º Clasificado: 4.000 Euros, trofeo y regalo promocional
2º Clasificado: 2.000 Euros, trofeo y regalo promocional
3º Clasificado: 1.000 Euros, trofeo y regalo promocional
4º Clasificado: 500 Euros, diploma y regalo promocional
5º Clasificado: 400 Euros, diploma y regalo promocional
6º Clasificado: 300 Euros, diploma y regalo promocional
7º Clasificado: 200 Euros, diplpoma y regalo promocional
8º Clasificado: 100 Euros, diploma y regalo promocional
Resto de participantes: Diploma y regalo promocional

Las reglas de participación son estas:

Los robots podrán fabricarse con cualquier material no peligroso, y su masa máxima no podrá superar los 10 kg.
Como sistemas de propulsión, movimiento y motorización, se podrán usar mecanismos y acumuladores eléctricos, cinéticos, hidráulicos o neumáticos, así como cualquier dispositivo electrónico digital o analógico, palancas, engranajes, correas y demás sistemas mecánicos.No se pueden emplear motorizaciones de explosión ni nucleares.
No se permite el uso de elementos basados en explosivos, gases inflamables o que contengan ácidos corrosivos, materiales radiactivos u otras sustancias peligrosas.
Se permite el uso de gases inertes o inócuos, tales como Helio, Dióxido de Carbono, aire comprimido, Nitrógeno, etc, incluso contenidos en un depósito a presión, siempre que la misma no supere los 50 bar (51 atm), teniendo que ser su masa, inferior a 90 gr.
Las eliminatorias se llevarán a cabo mediante el sistema de liguillas.
Los combates tendrán una duración máxima de 4 minutos, al final de los cuáles, si ninguno de los robots es eliminado, se decidirá el ganador mediante decisión arbitral, atendiendo al mayor dominio de alguno de los competidores, los daños causados a su adversario y otros criterios similares.
Gana el robot que consiga inutilizar a su adversario, bien por destrucción total, por inmovilización o neutralización durante 30 segundos o por haberlo sacado del área de combate, que consistirá en un cuadrado de 8 por 8 metros, limitado por una protección transparente, rodeando una zona de confinamiento de 1 por 1 metros. Caer en dicha zona, supone la pérdida del combate.

Para ir abriendo boca, un vídeo de cómo son las robot wars:

Ejemplo de cómo hacer un robot de combate

Una tienda donde comprar componentes (no tenemos ningún contrato ni nada parecido con ella).

¿Os atreveis a competir?

Probando mOwayduino

7 respuestas

Esta semana he recibido el robot mOwayduino. Este robot se financió en una campaña de indiegogo, y aunque no alcanzó su objetivo, si se comprometieron a enviar lo pedido. La empresa española Bizintek Innova es la que está detrás del desarrollo y producción de este producto. El objetivo de este robot es el de enseñar robótica en colegios e institutos, pero también hace las delicias de cualquier aficionado.

El microcontrolador que tiene es un ATmega 32u4 (el que usa por ejemplo Arduino Leonardo) y tiene una lista de sensores y actuadores interesante:

2 motores con encoder
4 sensores infrarrojos anticolisión
1 sensor de luz direccional
2 sensores optoreflectivos infrarrojos para el suelo
LED superior RGB
LED frontal
LEDs rojos traseros
Acelerómetro de 3 ejes
Micrófono
Altavoz
Módulo de Radio Frecuencia para comunicación inalámbrica basado en nRF24L01+ (se pueden comunicar entre ellos)
Batería LIPO recargable por USB

Además tiene una ranura de expasión para ampliar funcionalidades mediante bus SPI. Se venden módulos por separado para usar esta ranura con una cámara o WiFi.

Se puede programar con el IDE de Arduino o con Scracth (y Python, aunque no he encontrado su librería para este).

La caja que envían contiene el propio robot y un cable USB para cargarlo y para enviarle los programas. El robot ya viene precargado con un programa que detecta obstáculos y los evita haciendo sonar su pequeño altavoz y encendiendo sus leds.

Para cargar nuestros programas voy a comentar qué pasos hay que seguir:

Lo primero es decargarse el IDE de Arduino (en el momento de escribir este artículo la última versión es la 1.0.5).

Después hay que irse a la página de moway-robot para descargar el software.

A continuación en la instalación de éste nos preguntará en qué carpeta está Arduino para instalar los drivers, librerías y ejemplos.

Una vez finalizada la instalación ya podemos enchufar el robot mOwayduino en el puerto USB. Nos lo detectará como USB IO board y nos pedirá los drivers. Estos están ubicados dentro de la carpeta drivers de Arduino. Si todo ha ido bien nos saldrá un dispositivo llamado Mowayduinoi bootloader. Fijarse en qué puerto COM le ha asignado Windows.

Ahora arrancamos el entorno de Arduino y abrimos cualquiera de los ejemplos que trae en el menú Archivo/Ejemplos/Mowayduino.

Para subir el programa a nuestro robot, primero hay que irse al menú Herramientas/Tarjeta y seleccionar Mowayduino, después hay que irse al menú Herramientas/Puerto Serial y elegir el puerto COM que nos ha dado antes en la instalación del driver, finalmente ir al menú Archivo y seleccionar la opción Cargar para subir el programa al robot.

Por ejemplo vamos a modificar ligeramente el programa para que el robot se mueva por un recinto cerrado y que empiece cuando oiga un chasquido de dedos. El resultado es este:

Y este es el programa:

//****************************************
//  Libraries
//****************************************
#include "MowayduinoRobot.h"
#include <SPI.h>
#include <EEPROM.h>

//****************************************
//  Objects
//****************************************
mowayduinorobot robot;
boolean empieza;
boolean sonido;
unsigned long tiempo;

//****************************************
//  RF event function (necessary for compiling)
//****************************************
void RfDataReady();
void RfDataReady()
{}


//****************************************
//
//  Main Program
//
//****************************************
void setup()
{
  robot.beginMowayduino();
  empieza = false;
  delay(2000);
}

void loop()
{
  if(empieza)
  {
    LedsStraight();  
    robot.Straight(100);
    robot.readLine();
    if(robot.Line[LINE_L] == 1 || robot.Line[LINE_R] == 1)
    {
      LedsRotate();
      
      // Rotate 140 degrees with a speed value of 100
      robot.RotateRight(100, 140);
      robot.Speakeron();
      sonido = true;
      tiempo = millis();
      delay(100);
    }
  }
  else
  {
    if(robot.readMic() > 500)
    {
      empieza = true;
    }
  }
  if(sonido && (millis() - tiempo > 500))
  {
    robot.Speakeroff();
    sonido = false;
  }
}

//****************************************
//
//  Functions
//
//****************************************
void LedsStraight()
{
  robot.Fronton();
  robot.Greenon();  
  robot.Brakeoff();
  robot.Redoff();  
}

void LedsRotate()
{
  robot.Frontoff();
  robot.Greenoff();  
  robot.Brakeon();
  robot.Redon();  
}

//****************************************

// Libraries

//****************************************

#include "MowayduinoRobot.h"

#include <SPI.h>

#include <EEPROM.h>

//****************************************

// Objects

//****************************************

mowayduinorobot robot;

boolean empieza;

boolean sonido;

unsigned long tiempo;

//****************************************

// RF event function (necessary for compiling)

//****************************************

void RfDataReady();

void RfDataReady()

{}

//****************************************

// Main Program

//****************************************

void setup()

{

robot.beginMowayduino();

empieza = false;

delay(2000);

}

void loop()

{

if(empieza)

{

LedsStraight();

robot.Straight(100);

robot.readLine();

if(robot.Line[LINE_L] == 1 || robot.Line[LINE_R] == 1)

{

LedsRotate();

// Rotate 140 degrees with a speed value of 100

robot.RotateRight(100, 140);

robot.Speakeron();

sonido = true;

tiempo = millis();

delay(100);

}

else

{

if(robot.readMic() > 500)

{

empieza = true;

}

if(sonido && (millis() - tiempo > 500))

{

robot.Speakeroff();

sonido = false;

}

//****************************************

// Functions

//****************************************

void LedsStraight()

{

robot.Fronton();

robot.Greenon();

robot.Brakeoff();

robot.Redoff();

}

void LedsRotate()

{

robot.Frontoff();

robot.Greenoff();

robot.Brakeon();

robot.Redon();

}

La documentación con todas las funcionalidades está en la carpeta mOwayduino que instala el programa en Archivos de Programa.

123D de Circuits.io

Deja un comentario

Si quieres hacer diseños de pcb sin tener que instalarte ningún software en tu máquina, en la empresa belga Circuits.io puedes hacerlo a través de tu navegador. Los circuitos que hagas serán públicos para que otras personas puedan usarlo como hardware libre (pagando puedes tener tus circuitos privados para ti). Incluso puedes importar tu diseños de Eagle. También puedes adquirir las placas hechas de tus circuitos o los de otras personas.

Pero quizá la parte más interesante es que se han aliado con Autodesk para traer 123D. (a continuación…)

Se trata de una nueva forma de diseñar circuitos con una protoboard y poder simular su funcionamiento, de hecho también puedes incluir en esos diseños un arduino y programarla online para ver qué resultado obtienes cuando simules el circuito. Los circuitos pueden ser diseñados en colaboración con otras personas a la vez. En el propio diseño también puedes acceder a la lista de materiales que has usado para poder comprarlos en digikey, mouser, newark o element14.

Sólo tienes que darte de alta en su web y empezar a crear tus circuitos, simularlos y si todo va bien hacer que los fabriquen.

Creo que es un método interesante para probar y crear tus propias PCB sin tener que tener nada de hardware al alcance de tu mano.

Sindormir.net

Deja un comentario

En una serie de artículos voy a ir dando a conocer los distintos lugares que hay en Madrid relacionados con la tecnología hecha por uno mismo (DIY).

En este primer artículo voy a comentar una academia 2.0 llamada Sindormir.net. En esta podemos acudir a multitud de cursos relacionados con las nuevas tecnologías.

Ubicado en el espacio Miscela (Av. Padre Piquer 45, Local A 28024 Madrid), sus instalaciones están orientadas a dar formación de distinta índole. En el caso que nos ocupa se trata de cursos y charlas para personas y empresas.

En los cursos podemos encontrar los siguientes:

Introducción a los microcontroladores con Arduino.
Arduino Avanzado.
Técnico en Sistemas Microinformático (Título de Formación Ocupacional).
Técnico Instalador de Redes de Comunicaciones (Tïtulo de Formación Ocupacional).
Sistema DNS con BIND9.
GNU/Linux Ubuntu y Debian
Programación de microcontroladores PIC en C bajo GNU/Linux.
Técnicas de bajo consumo con microcontroladores PIC 18.
Técnicas de Seguridad y Alta disponibilidad bajo GNU/Linux.
Administración de sistemas Red Hat Enterprise.
Introducción a la programación con Scratch.
Redes TCP/IP: Routing y Switching.
Programación en C.
Electrónica digital y analógica.
KICAD

Y tiene otros en preparación como

Diseño de circuitos electrónicos
Sistemas Operativos
Redes
Bases de datos
Programación
Servidores
Seguridad en redes
Telefonía analógica y digital
Montaje y calibración de Impresoras 3D
Desarrollo de shields de Arduino
Creación de interfaces gráficas para dispositivos electrónicos
Introducción a la robótica para niños

Además hay charlas (23 seats) donde expertos de cualquier campo pueden intercambiar ideas. Habrá dos charlas y/o ponencias el primer y tercer martes de cada mes. La asistencia es gratuita hasta cubrir las plazas.

El centro es manejado por Jorge Gómez (@gsyvic), que para quien no lo conozcáis, es uno de los organizadores del evento OSHWCon.

Si te interesa dar un curso sobre Arduino, PIC, diseño de circuitos, GNU/Linux, etc con un experto, este es sin duda tu lugar.