IoT Arduino-Raspberry Pi Hackeando una TSRB430 BLE Relay Board P1

Hacking Electronics Arduino Santiapps
Raspberry Pi 2 Bluetooth Serial Uart HM10 HM12 Relay Board AI by Santiapps Marcio Valenzuela
Raspberry Pi 2 Bluetooth Serial Uart HM10 HM12 Relay Board AI

 

En realidad vamos a usar los comandos especificados por el fabricante, asi que t茅cnicamente no es hacking, pero suficiente cerca 馃檪

Requisitos

  1. Arduino MCU
  2. Modulo Serial HM10 BLE
  3. TSRB430 Relay Board

Arduino Code

[code]
#include <SoftwareSerial.h>
int bluetoothTx = 10; // TX-O pin of bluetooth
int bluetoothRx = 11; // RX-I pin of bluetooth
SoftwareSerial bluetooth(bluetoothTx, bluetoothRx);
void setup(){
Serial.begin(9600); // Begin the serial monitor at 9600bps
delay(200); // Short delay, wait for the Mate to send back CMD
bluetooth.begin(9600); // Start bluetooth serial at 9600
Serial.print(“send…”);
// bluetooth.print(“AT”);
//bluetooth.print(“e”); //open relay 1
//delay(2000);
//bluetooth.print(“o”); //close relay 1
}
void loop(){
if(bluetooth.available()){
Serial.print((char)bluetooth.read());
}
if(Serial.available()){
bluetooth.print((char)Serial.read());
}
}
void activateTSRB430() {
Serial.print(“commanding…”);
bluetooth.print(“110”);
delay(3000);
bluetooth.print(“100”);
delay(2000);
}
[/code]

Con este codigo conectamos un Arduino MCU con un modulo serial bluetooth y enviamos comandos una relay board TSRB430 HM-10 BLE.

Ahora hagamos lo mismo pero desde una RPi!

Requisitos

  1. RPi2
  2. Modulo Serial HM10 BLE
  3. TSRB430 Relay Board

Raspberry Pi2 Code

[code]</pre>
#!/usr/bin/env python
import serial
ser = serial.Serial(
port=’/dev/serial0′,
baudrate=9600,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS,
timeout=1
)
print “Serial is open: ” + str(ser.isOpen())
print “Now Writing”
ser.write(“e”)
#ser.write(“AT+CONNL”)
print “Did write, now read”
x = ser.readline()
print “got ‘” + x + “‘”
ser.close()
[/code]

Aqui enviamos el codigo e al relay board y podemos ver que el relay se cierra.

En el proximo tutorial veremos que podemos hacer con esta conexi贸n.

IoT: Intro a Raspberry Pi 2 – Bt Serial Uart HM10-HM12 Relay Board for AI

Neural Networks Artificial Intelligence Arduino Santiapps
Raspberry Pi 2 Bluetooth Serial Uart HM10 HM12 Relay Board AI by Santiapps Marcio Valenzuela
Raspberry Pi 2 Bluetooth Serial Uart HM10 HM12 Relay Board AI

Para trabajar con RPi es necesario instalar todo primero y hacer las conexiones.  Para nuestros proyectos de RPi con BLE Serial por ejemplo, seguimos las siguientes instrucciones y conexiones:

Conexion de BLE Serial al RPi:

Rx-Tx-3.3V-GND

Configuracion de Linux en RPi:

Linux

sudo shutdown -h now

sudo ssh service start

sudo inserv

Configuracion del Rasbian Jessie

enable_uart=1 in /etc/inittab

remove console in /boot/cmdline.txt

set IMME to 1 on hmsoft

 

 

Raspberry Pi 2 Bluetooth Serial Uart HM10 HM12 Relay Board AI by Santiapps Marcio Valenzuela
Raspberry Pi 2 Bluetooth Serial Uart HM10 HM12 Relay Board AI

 

Codigo Python para script simple:

[code]#!/usr/bin/env python
import serial
ser = serial.Serial(
port=’/dev/serial0′,
baudrate=9600,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS,
timeout=1
)
print “Serial esta abierto: ” + str(ser.isOpen())
print “Escribiendo…”
ser.write(“AT”)
print “Escrito! Ahora leamos”
x = ser.readline()
print “got ‘” + x + “‘”
ser.close()[/code]

Internet Of Things (IoT): Inteligencia Artificial via Neural Networks Parte 1

Neural Networks Artificial Intelligence Arduino Santiapps
Internet Of Things: Artificial Intelligence Neural Networks by Santiapps Marcio Valenzuela
Internet Of Things: Artificial Intelligence Neural Networks

Para que se usa?

Para modelar el comportamiento complejo en el pasado y usar el modelo para pronosticar el futuro comportamiento.

Ejemplo: Un cliente con ciertas caracter铆sticas (compras mensuales, compras por categor铆a hist贸rica) cuanto nos comprara en los siguientes meses?

Ejemplo: Una imagen le铆da por una computadora con ciertas caracter铆sticas (lineas horizontales, diagonales, colores, etc) es una persona o un objeto?

Como funciona?

Todo sistema bajo estudio (imagen, comportamiento de compra) tiene una capa de ingreso de informaci贸n en la izquierda llamados inputs, capas ocultas y una capa final de resultados:

Internet Of Things: Artificial Intelligence Neural Networks by Santiapps Marcio Valenzuela
Internet Of Things: Artificial Intelligence Neural Networks

Una neural network o red neural tiene 3 capas:

  1. Capa Input (ingreso o variables conocidas)
  2. Capa Oculta (interacciones entre variables o factores)
  3. Capa Output (resultado final buscado)

Cada variable o factor tiene un peso e interactua para crear un nodo en la capa oculta.  Pueden haber varias capas ocultas pero en nuestro ejemplo sencillo solo hay una capa oculta.

Neural Networks toman en cuenta la interacci贸n entre todos los inputs entre ellos mismos, no solo la interaccion de los inputs sobre el output final.

Veamos un ejemplo sencillo:

Internet Of Things: Artificial Intelligence Neural Networks by Santiapps Marcio Valenzuela
Internet Of Things: Artificial Intelligence Neural Networks

Tenemos:

Capa Input:  2 variables, digamos que el cliente ha hecho 2 compras mensuales con valores de 3mil cada una.  Una variable es el numero de compras mensuales y la otra es el valor de cada compra.

Capa Oculta: Cada variable o factor interactua entre si y genera un nodo.  Por ende tenemos 2 nodos; uno con valor 5 y otro con valor 1.  Como se calculan esos nodos?

Cada factor o variable tiene un peso que significa la magnitud con la cual esa variable afecta el proximo resultado.  Esos resultados se conocen como nodos de la capa oculta.  En nuestro ejemplo, el nodo superior de la capa oculta es afectado con pesos de 1 y 1 por el input 2 y 3, respectivamente.  Por otro lado, el nodo inferior de la capa oculta es afectado con pesos de -1 y 1 por el input 2 y 3, respectivamente.  Usamos reglas de vector para multiplicar.sumar y obtener el resultado del nodo superior:

2×1 = 2

3×1 = 3

2+3=5

De igual forma ahora para el nodo inferior:

2x-1 = -2

3×1 = 3

-2+3=1

Finalmente cada nodo de la capa oculta tiene su peso, 2 y -1.  Esto nos genera:

5×2 = 10

1x-1 = -1

10 + -1 = 9

Lo que vamos a hacer ahora es un ejemplo mas complejo pero ayudados por la tecnolog铆a.  En python existe la siguiente library (https://www.scipy.org/install.html) que podemos instalar usando:

python -m pip install --upgrade pip

y

pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose

Luego creamos un archivo:

sudo nano neural1.py

y agregamos el c贸digo para nuestra red neural.  Veamos el ejemplo que es ligeramente mas complejo:

Como pueden ver tenemos 2 variables y 2 capas ocultas:

Internet Of Things: Artificial Intelligence Neural Networks by Santiapps Marcio Valenzuela
Internet Of Things: Artificial Intelligence Neural Networks

Los pasos ser谩n:

  1. Importar numpy, la library descargada
  2. Crear el array de inputs [3,5]
  3. Crear el diccionario de arrays de pesos
  4. Crear una funci贸n de activaci贸n llamada relu que toma el input y retorna el valor m谩ximo o 0.
  5. Finalmente creamos la funci贸n predecir_con_red().  Este paso esta desglosado al final del c贸digo.

Codigo

import numpy as np
input_data=np.array([3,5])
weights={'node_0_0': np.array([2,4]),
'node_0_1': np.array([4,-5]),
'node_1_0': np.array([-1,1]),
'node_1_1': np.array([2,2]),
'output': np.array([-3,7])}
def relu(input):
'''Define your relu activation function here'''
# Calculate the value for the output of the relu function: output
output = max(0, input)
# Return the value just calculated
return(output)
def predecir_con_red(input_data):
# Calculate node 0 in the first hidden layer
node_0_0_input = (input_data * weights['node_0_0']).sum()
node_0_0_output = relu(node_0_0_input)
# Calculate node 1 in the first hidden layer
node_0_1_input = (input_data * weights['node_0_1']).sum()
node_0_1_output =relu(node_0_1_input)
# Put node values into array: hidden_0_outputs
hidden_0_outputs = np.array([node_0_0_output, node_0_1_output])
# Calculate node 0 in the second hidden layer
node_1_0_input = (hidden_0_outputs * weights['node_1_0']).sum()
node_1_0_output = relu(node_1_0_input)
# Calculate node 1 in the second hidden layer
node_1_1_input = (hidden_0_outputs * weights['node_1_1']).sum()
node_1_1_output = relu(node_1_1_input)
# Put node values into array: hidden_1_outputs
hidden_1_outputs = np.array([node_1_0_output, node_1_1_output])
# Calculate model output: model_output
model_output = (hidden_1_outputs * weights['output']).sum()
# Return model_output
return(model_output)
output = predecir_con_red(input_data)
print(output)
  • Primero calculamos el nodo 0 de la capa 0, node_0_0_input.
  • Segundo aplicamos la relu para obtener node_0_0_output.
  • Tercero, repetimos para el segundo nodo, node_0_1_input y node_0_1_output.
  • Almacenamos el resultado de ambos nodos en el array hidden_0_outputs.
  • Ahora repetimos para los nodos de la siguiente capa oculta, node_1_0_output y node_1_1_output, su relu y almacenamos los resultados de ambos nodos en el array hidden_1_outputs.
  • Repetimos para el modelo final y listo.

Nos deber铆a dar los mismos 364!