Mostrando entradas con la etiqueta salidas. Mostrar todas las entradas
Mostrando entradas con la etiqueta salidas. Mostrar todas las entradas

martes, 14 de abril de 2020

Arduino. Control salidas realizado con JAVA y NetBeans


Arduino

Control salidas

JAVA - NetBeans


En el montaje anterior javled.html había realizado un controlador de salidas mediante una placa Arduino.
Estaba realizado en JAVA, había salido bastante frustrado en su realización.
Me había prometido no tocar durante bastante tiempo el JAVA, pero no pude resistir el probar el IDE netBeans para mitigar mi frustración.
Después de unos cuanto vídeos sobre este IDE, decidí hacer un video propio demostrando como portar mi anterior montaje a netBeans.
Lo difícil ya estaba realizado, la programación serie, solo me faltaba copiar y pegar parte del código de un proyecto a otro.
Le resultado ha sido bastante satisfactorio, además de útil para próximas aplicaciones.


Interface del programa.


Programa funcionando.

El programa esta realizado a base de botones, y no como en el anterior proyecto que eran JRadioButton.
Quizás los JRadioButton son en este caso mas intuitivos, pero mi intención era hacerlo de otro modo.








VIDEOTUTORIAL

PROGRAMA-JAVA-ARDUINO


Espero que les sirva este video tutorial para vuestros proyectos.

Saludos.
Juan Galaz

Bibliografía:

http://josedeveloper.com/2012/01/28/comunicacion-serial-java-y-arduino/

miércoles, 18 de marzo de 2020

Arduino Control salidas. wxwidgets - Portable - Linux _ Windows

Página principal
Arduino
Control salidas

wxwidgets
Portable - Linux _ Windows


En un montaje anterior arseta.html había realizado un controlador de salidas mediante una placa Arduino.
Estaba realizado en Gambas (VB Linux), en esta ocasión lo realizo en wxwidgets, tanto en Linux como en Windows.
Además aprovechando la oportunidad he realizado una nueva versión de Linux,  versión portable.
Esta versión funciona tanto en 32bits como en la versión 64bits.

Circuito.


Funcionando en Windows 10


Funcionando en Linux ,versión portable.

En algunos Windows, el puerto virtual Serie lo coloca muy alto, me encontrado en algunas ocasiones que estaba en Com23, el programa solo mira si existe entre el Com1 y Com5. Si es vuestro caso deberéis cambiar el lugar  para que este en el rango buscado. Se hace como administrador y en configuración de los puertos serie.
En la versión Windows la detección de los puertos se hace un poco lenta, debéis esperar algo (3-4 segundos).


PROGRAMA LINUX -WINDOWS

Saludos.
Juan Galaz



Bibliografía:

Arduino_Uno 1.0.1  programado por Rolfdahl-skogstade

viernes, 19 de julio de 2019

Arduino - Gambas - Control entradas salidas - Navegador.

Página principal

Arduino
Gambas
Control entradas salidas.
Control mediante navegador.


En el anterior montaje solo se podía ver los estados de pin a través del navegador.
Ahora ya se puede cambiar los estados desde el navegador del PC o Móvil.

Circuito montado.


Programa gambas. 5 entradas analógicas, 12 salidas digitales.


Versión con textos. Arsetav3.


Versión con botones. Arsetav3b.

El mayor problema de controlar mediante navegador, es que en algún caso se ven diminutos los botones.
Que cada uno elija la versión que le resulte mas útil a su proyecto.

Como podéis observar en el montaje he utilizado un arduino nano, y para la representación el arduino uno.
Las pruebas las he realizado en las dos placa de arduino, funcionando perfectamente en ambas.
Aunque el arduino nano tiene A6 y A7 no las he empleado por compatibilidad con el arduino uno

La actualización de los datos desde que se cambia un valor hasta que se ve reflejado es de 1 segundo.
Se puede mejorar aumentando la velocidad en Baudios y el tiempo de retardo, para este montaje no hace falta mucha velocidad, por lo que lo he dejado así.
En el navegador web si queremos ver los datos actualizados, debemos actualizar la página web, aunque se actualiza automáticamente cada 120 segundos.


PROGRAMA

Saludos.
Juan Galaz



Bibliografía:

Arduino_Uno 1.0.1  programado por Rolfdahl-skogstade

miércoles, 17 de julio de 2019

Arduino - Gambas - Control entradas salidas

Página principal

Arduino
Gambas
Control entradas salidas


 Hace unos 5 años había realizado una serie de montajes donde controlaba una placa de arduino mediante un programa ejecutado en un PC o RaspberryPi.
Lo había realizado en C y con la librería SDL, funcionaba tanto en Linux como en Windows.
    25/06/2012 - ARDUINO - Control de 12 salidas y 6 entradas analógicas mediante rs232-Librería SDL. aseriea
    19/06/2012 -
ARDUINO - Control de entradas mediante rs232 - Librería SDL. aseriee
    10/06/2012 - ARDUINO - Control de salidas mediante rs232 -Librería SDL. aserie

El otro día probando el nuevo Debian 10, se me ocurrió instalar gambas y probar un programa que se encontraba en la granja de programas.
Era Arduino_Uno 1.0.1  programado por Rolfdahl-skogstade, además de controlar el arduino a través del PC, tenía la posibilidad de ver el estado de las entradas o salidas en un navegador web. Nunca se me ocurrió el hacer un servidor web con Gambas.
También se posibilitaba el poder cambiar las salidas a través de un navegador, desde el PC o teléfono.

En este montaje realizo algo parecido, pero en 3 montajes diferentes.
-17 salidas.
-17 entradas.
-12 salidas y 5 entradas analógicas.


También se puede visualizar en un navegador el estado de los pins del arduino, o los valores de la señales analógicas.
Para otro proyecto se podrá cambiar el estado de los pins a través del navegador.

En el programa realizado en gambas, he utilizado partes de código realizado por Rolfdahl-skogstade , sobre todo en la parte del servidor web, he interface gráfico. En cuanto al resto del código se ha rehecho totalmente, los cambios en la comunicación con el arduino son completamente nuevos, basados en mis viejos montajes.

En cuanto al programa realizado para el arduino, los códigos se basan en anteriores montajes míos, son del tipo: petición de dato a través del interface serie, y respuesta por parte del arduino a través del mismo interface serie.
Por ejemplo:
     SET 8,0          Apagar pin 8
   

    SET 8,1          Encender pin 8

    ANA 0            Se solicita el valor de pin ANALOG 0
    El arduino devolverá el valor de ANAGOL-A0:     VAL 0,350


Desde cualquier terminal serie, cutecom, o del propio terminal de arduino se pueden ejecutar las ordenes.
Podemos entender que el programa en gambas hace el control mucho mas fácil, a través de su interface gráfica.
Además busca automáticamente el puerto donde está conectado el arduino.

Circuito montado. Modelo 17 salidas.
Para no tener que colocar una resistencia para cada LED, simplifico el montaje colocando una resistencia común a GND para todos los LEDS. Esto implica que dependiendo de los LEDS que estén encendidos, lucirán mas o menos.

Programa gambas. 17 salidas.


Programa gambas. 17 entradas.


Programa gambas. 5 entradas analógicas, 12 salidas digitales.

Visualización en navegador. 5 entradas analógicas, 12 salidas digitales.

Como podéis observar en el montaje he utilizado un arduino nano, y para la representación el arduino uno.
Las pruebas las he realizado en las dos placa de arduino, funcionando perfectamente en ambas.
Aunque el arduino nano tiene A6 y A7 no las he empleado por compatibilidad con el arduino uno

La actualización de los datos desde que se cambia un valor hasta que se ve reflejado es de 1 segundo.
Se puede mejorar aumentando la velocidad en Baudios y el tiempo de retardo, para este montaje no hace falta mucha velocidad, por lo que lo he dejado así.
En el navegador web si queremos ver los datos actualizados, debemos actualizar la página web, aunque se actualiza automáticamente cada 120 segundos.


PROGRAMA

Saludos.
Juan Galaz



Bibliografía:

Arduino_Uno 1.0.1  programado por Rolfdahl-skogstade

viernes, 30 de agosto de 2013

Control de 3 salidas - Raspberry Pi

Página principal

Control de 3 salidas

Raspberry Pi

xsetaseta@gmail.com

 El primer montaje con un microcontrolador sueles ser el parpadeo de un led. Para mi primer montaje con la Raspberry Pi he elegido el control de 3 leds mediante el teclado, o mediante un interface gráfico.
Navegando por internet encontre la siguiente página:
    http://www.diverteka.com/?p=1792#comment-3529


Explica como controlar un rele mediante Raspberry Pi, es un buen tutorial  realizado en lenguaje Python y las librerías ncurses. Yo lo único que he hecho es ampliarlo para que funcione con 3 leds.

Esquema eléctrico


Simulación de montaje


Montaje eléctrico.


Control mediante el teclado en consola.

# ==========================================
# -  Programa para manejo RELE de control  -
# ------------------------------------------
# -  J.C.G.P. - (c) Webtronika 2013 -
#
# Modificado el 22/08/2013 por SETA43
# ==========================================
#!/usr/bin/python
import sys
import curses
import time
import RPi.GPIO as GPIO
# ---------------------------------------------------------------
# - Rutina de configuracion de puertos en GPIO ------------------
# ---------------------------------------------------------------
def confiGPIO(param1):
        GPIO.setmode(GPIO.BCM)
        GPIO.setwarnings(False)
        GPIO.setup(23, GPIO.OUT)
        GPIO.setup(24, GPIO.OUT)
        GPIO.setup(25, GPIO.OUT)
        return 0
# ---------------------------------------------------------------
# ###############################################################
# - PROGRAMA PRINCIPAL ------------------------------------------
#
#   Utiliza curses para visualizar salida a pantalla
#
# ###############################################################
# ---------------------------------------------------------------
stdscr = curses.initscr()
curses.cbreak()
curses.start_color()
curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_GREEN)
hsize = curses.COLS
vsize = curses.LINES
curses.curs_set(0)
curses.noecho
stdscr.border(0)
stdscr.keypad(1)
stdscr.nodelay(1)
confiGPIO(0)
try:
        stdscr.bkgd(curses.color_pair(1))       
        while True:  # Rutina principal del programa
                char = stdscr.getch()
                time.sleep(.1)                                  ### Hace que el sistema no se sature
                if (char == 81 or char == 113): # Tecla Q/q
                        break  
                if (char == 49): # Tecla 1
                        GPIO.output(23, True)
                if (char == 50): # Tecla 2
                        GPIO.output(23, False)
                if (char == 51): # Tecla 3
                        GPIO.output(24, True)
                if (char == 52): # Tecla 4
                        GPIO.output(24, False)
                if (char == 53): # Tecla 5
                        GPIO.output(25, True)
                if (char == 54): # Tecla 6
                        GPIO.output(25, False)
                else:
                        stdscr.addstr(vsize/6, (hsize/2)-18,"Control de RELE via GPIO")
                        stdscr.addstr((vsize/5)+2, (hsize/2)- 22,"[1] - Activa el RELE1")
                        stdscr.addstr((vsize/5)+3, (hsize/2)- 22,"[2] - Desactiva el RELE1")
                        stdscr.addstr((vsize/5)+5, (hsize/2)- 22,"[3] - Activa el RELE2")
                        stdscr.addstr((vsize/5)+6, (hsize/2)- 22,"[4] - Desactiva el RELE2")
                        stdscr.addstr((vsize/5)+8, (hsize/2)- 22,"[5] - Activa el RELE3")
                        stdscr.addstr((vsize/5)+9, (hsize/2)- 22,"[6] - Desactiva el RELE3")
                        stdscr.addstr(vsize-8, (hsize/2)- 18," Pulsa [Q] para salir")                 
                        stdscr.refresh()

finally:
    curses.nocbreak()
    stdscr.keypad(0)
    curses.echo()
    curses.endwin()




Utilizando la librería Tcl/Tk he creado un interface gráfico.

Control gráfico.

#!/usr/bin/python

import Tkinter
import RPi.GPIO as GPIO

def confiGPIO(param1):
    GPIO.setmode(GPIO.BCM)
    GPIO.setwarnings(False)
    GPIO.setup(23, GPIO.OUT)
    GPIO.setup(24, GPIO.OUT)
    GPIO.setup(25, GPIO.OUT)
    return 0


def on1():
    print "on1"
    GPIO.output(23, True)
    return
def off1():
    print "off1"
    GPIO.output(23, False)
    return   
def on2():
    print "on2"
    GPIO.output(24, True)
    return
def off2():
    print "off2"
    GPIO.output(24, False)
    return   
def on3():
    print "on3"
    GPIO.output(25, True)
    return
def off3():
    print "off3"
    GPIO.output(25, False)
    return   

confiGPIO(0)


top = Tkinter.Tk()
top.geometry("200x250")
top.title("RELE_TK")
#top.config(bg="blue")


A = Tkinter.Button(top, text ="ON1 ", command = on1)
B = Tkinter.Button(top, text ="OFF1", command = off1)

C = Tkinter.Button(top, text ="ON2 ", command = on2)
D = Tkinter.Button(top, text ="OFF2", command = off2)

E = Tkinter.Button(top, text ="ON3 ", command = on3)
F = Tkinter.Button(top, text ="OFF3", command = off3)

Q = Tkinter.Button(top, text ="QUIT",fg="red", command = quit)

A.pack()
B.pack()
C.pack()
D.pack()
E.pack()
F.pack()
Q.pack()
top.mainloop()


Saludos
Juan Galaz


Bibliografía:

http://www.diverteka.com/?p=1792#comment-3529
http://docs.python.org/2/library/tkinter.html
http://www.tcl.tk/