ARDUINO IO (también conocido como: PAQUETE DE SOPORTE "tethered" MATLAB para
Arduino):
Este paquete permite el uso de un Arduino conectado al ordenador para realizar
Entrada analógica y digital y de salida, (y motores de mando) de MATLAB.
-------------------------------------------------- -------------------------
DETALLES DE ARDUINO:
Arduino es una placa electronica de código abierto de gran alcance y bajo costo,
con un entorno de desarrollo asociado: http://arduino.cc/
Una amplia base de conocimiento se puede encontrar aquí: http://www.freeduino.org/
La compra de un placa Arduino:
Una extensa lista de sitios donde se puede comprar un Arduino está aquí:
http://www.arduino.cc/en/Main/Buy
En los EE.UU., las industrias Adafruit (http://www.adafruit.com/)
proporciona un paquete inicial que incluye casi todo lo que usted
necesita para empezar con la tabla.
Mientras que la versión anterior de este paquete se dirige a tablas más pequeñas, como
La ONU y Nano, desde agosto de 2012 (ver 3.3) el paquete también trabaja a la derecha
fuera de la caja en los tablones de Mega, sin que sea necesario ningún ajuste relacionados con
Mega.
Las guías de introducción:
El funcionario guía de introducción está aquí: http://arduino.cc/en/Guide/HomePage
y un muy buen tutorial está aquí: http://www.ladyada.net/learn/arduino/
Sin embargo en cuenta que para el propósito de utilizar este paquete sólo se necesita tener
el entorno IDE instalado pero no será necesario utilizarlo, porque se puede
hacer toda la programación en MATLAB.
KIT CHIP 32 TABLAS:
Tenga en cuenta que el paquete funciona bien con las placas de ChipKit32 (Uno32, Max32):
http://www.digilentinc.com/Products/Catalog.cfm?NavPath=2,892&Cat=18
Toda la producción funcionan bien funcionalidad analógica y digital de entrada y,
pero desafortunadamente no todas las funcionalidades interrupciones funcionan de la misma
Así, por lo servos y los codificadores no podría funcionar exactamente como en las placas
Arduino.
Desde sep 2012, cuando la biblioteca AFMotor se ha actualizado para apoyar PIC32,
Adafruit el motor Sield también trabaja con estas placas.
El Cerebot MX7ck también funciona bien con el paquete. Tenga en cuenta que con el fin de
se accede a la MPIDE que necesita para tiro corto JP11, ajuste el interruptor en ON,
y conectarlo al PC a través de la UART (no el DEBUG) puerto USB.
Si usted no tiene alimentación externa a continuación, asegúrese de establecer también el
poder
puente para UART (como opuesta a la posición por defecto DBG).
TI LAUNCHPAD (MSP430) TABLAS:
Usando el IDE Energia (http://energia.nu/Guide_MSP430LaunchPad.html)
la adio.pde y adioe.pde pueden ser compilados para el MSP430G2553 y
MSP430G2452 (el G2231 no tiene suficiente memoria). El boceto adioes.pde
puede ser compilado para la FR5739. Tenga en cuenta sin embargo que ninguna prueba real ha
sido
realizado en estas plataformas sin embargo.
-------------------------------------------------- -------------------------
Descargar e instalar el IDE (por hacer sólo una vez):
Un paso a paso la instalación del controlador se puede encontrar en:
http://arduino.cc/en/Guide/HomePage y no hay necesidad de duplicar aquí.
Es una buena idea para ir trought todos los 9 pasos, aunque después de que haya
instalado los controladores, tal vez la biblioteca escudo, y verificado que el IDE
puede comunicarse con el Arduino, ya se puede empezar a utilizar este paquete.
INSTALACIÓN DEL MOTOR SHIELD adafruit BIBLIOTECA (hay que hacer sólo una vez):
Si desea utilizar este paquete con el protector del motor adafruit, (ya sea
versión 1: http://learn.adafruit.com/adafruit-motor-shield o la versión 2:
http://learn.adafruit.com/adafruit-motor-shield-v2-for-arduino), es necesario
para descargar e instalar la biblioteca escudo respectivo motor adafruit
(Siga las instrucciones dadas en los sitios anteriores, que ascienden a descargar
un archivo zip y descomprimir en la carpeta arduino-1.x / bibliotecas.
Como se explica mejor en el siguiente paso, esto también tendrá que cargar
eiter la motor_v1.pde o el boceto motor_v2.pde en el tablero.
Tenga en cuenta que si usted no tiene el protector del motor adafruit y no planificar
para usarlo, es posible que también omitir este paso.
También tenga en cuenta que el Arduino "oficial" (no Adafruit) protector del motor:
(Http://arduino.cc/it/Main/ArduinoMotorShieldR3)
no requiere ninguna librería adicional, que funciona bien con el chipkit32
tableros, y se pueden utilizar con este paquete de inmediato. Por lo tanto si
va a utilizar el escudo oficial de motor a continuación, puede saltarse este paso.
-------------------------------------------------- -------------------------
SUBIR A ADIOES.PDE la placa Arduino (hay que hacer sólo una vez):
El boceto adioes.pde es el programa "servidor" que se ejecutará de forma continua
en la placa de desarrollo. Se escucha los comandos de MATLAB que llegan desde
el puerto serie, ejecuta los comandos y, si es necesario, devuelve un resultado.
Se necesitan las siguientes instrucciones para cargar el archivo en adioes.pde
la memoria flash del controlador. Mientras ningún otro archivo se carga después,
este paso no es necesario repetir nunca más, y el paquete puede ser
utilizado tan pronto como la placa está conectada al ordenador.
Tenga en cuenta que si desea utilizar la biblioteca escudo adafruit entonces necesita
tanto instalar la biblioteca adecuada (ver paso anterior) y cargar el
el boceto apropiado (ya sea motor_v1.pde o motor_v2.pde) en lugar de
el boceto adioes.pde.
Desde el IDE de Arduino, vaya a Archivo> Abrir, busque el archivo de adioes.pde,
(En la carpeta / PDE / adioes ArduinoIO) y abrirlo. Si aparece un cuadro de diálogo
pidiendo permiso para crear una carpeta de dibujo y mover el archivo,
pulse OK (esto creará una carpeta adioes y mover el adioes.pde
presentar en su interior).
Conectar el Arduino, asegúrese de que el panel a la derecha y el puerto serie son
seleccionada en el IDE, (Herramientas / Herramienta Junta y / Puerto serie) a continuación,
seleccione
Archivo -> Cargar en módulo E / S y esperar a que el mensaje "Done Carga".
En este punto se carga el archivo adioes.pde y se puede cerrar el IDE,
lo que ya no es necesaria para los fines de este paquete. Actualmente
Se sugiere cerrando el IDE, por lo que puede estar seguro de que la conexión serial
a la placa Arduino no es tomada por el IDE cuando MATLAB tiene que usarlo.
-------------------------------------------------- -------------------------
La instalación de paquetes (que se realiza una sola vez):
Al instalar el paquete de Arduino IO en su sistema operativo es
importante que los usuarios tienen derecho a acceder al puerto serie y modificar
el archivo pathdef.m.
En Linux:
---------
Para asegurarse de que el archivo se puede escribir pathdef.m, emitir un comando como este:
sudo chmod 777 usr / local / MATLAB / R2012a / caja de herramientas / local / pathdef.m
(Modificar la ruta anterior de acuerdo con el que está instalado MATLAB).
Además, aún en Linux, cree un enlace simbólico de la siguiente manera:
sudo ln -s / dev / ttyACM0 / dev / ttyS101
y asegúrese de que es accesible por cualquier usuario:
sudo chmod 777 / dev / ttyS101
El olvido de este último paso podría conducir a un puerto en serie que se
unaccessible por un usuario normal (por lo tanto, ser en gris en el IDE).
Luego de MATLAB, lanzar el comando "install_arduino", esto simplemente se
agregar las carpetas correspondientes a la ruta ArduinoIO MATLAB y guardar la ruta.
En Windows:
-----------
MATLAB ejecutar como administrador (solo una vez con el propósito de instalar
el paquete) haciendo clic derecho en el icono y seleccionando MATLAB
"Ejecutar como administrador". Esto permitirá que la ruta actualizada para ser salvado.
Luego de MATLAB, lanzar el comando "install_arduino", esto simplemente se
agregar las carpetas correspondientes a la ruta ArduinoIO MATLAB y guardar la ruta.
-------------------------------------------------- -------------------------
El uso típico:
Asegúrese de que la placa está conectada al ordenador a través del puerto USB, asegúrese
usted sabe qué puerto serie del Arduino está conectado a (este es el mismo
puerto que se encuentra al final de la etapa de instalación de los controladores), y finalmente,
asegúrese de que el puerto no es utilizado por el IDE (en otras palabras, el IDE debe
ser cerrado o desconectado), de manera que MATLAB puede utilizar la conexión en serie.
Desde MATLAB, lanzar el comando a = Arduino ( 'puerto'), donde 'puerto' es la
puerto COM al que el Arduino está conectado a, por ejemplo, 'COM5' o 'COM8' en Windows,
o '/ dev / ttyS101' en Unix (uso '/ dev / ttyUSB0' para las versiones de Arduino antes de Uno)
o 'Demo' (ver más abajo para el modo DEMO) y asegúrese de que caduque la función
exitosamente.
A continuación, utilice el a.pinMode comandos, a.digitalRead, a.digitalWrite, a.analogRead,
y a.analogWrite, para cambiar respectivamente el modo (entrada / salida) de cada pasador,
realizar entrada digital, salida digital, entrada analógica, y la salida analógica.
Consulte la ayuda de los archivos para obtener más información acerca de su uso.
Si también tiene un servomotor, a continuación, puede utilizar comandos como
a.servoAttach, a.servoStatus, a.servoWrite, a.servoRead y a.servoDetach
para fijar respectivamente un servo a un pin PWM, obtener su estado (conectado / individual)
moverlo a un cierto ángulo, y leer su posición.
NOTA que desde agosto de 2012 (ver 3.8) los servos ya no se hace referencia a
por los números 1 y 2, pero no por el número pin PWM al que están
adjunto (egaservoRead (9) lee el servo conectado al pin # 9).
Para los codificadores se puede utilizar el a.encoderAttach comandos, a.encoderStatus,
a.encoderRead, a.encoderReset y a.encoderDetach para sujetar, respectivamente, una
codificador para 2 pines de interrupción (2,3 en el Uno, 2,3,21,20,19,18 en el Mega)
obtener su estado (conectado / individual), leer y restablecer su posición, y
separarlo cuando haya terminado. Las direcciones de giro positivos para codificadores
se supone que es hacia la derecha, y la gama va -32.768-32.767,
si necesita una gama más grande todo lo que tiene que hacer es ir en el codificador
estructura de la línea typedef del archivo de dibujo y reemplazar el tercer campo,
"Int pos;" con "largos pos int;".
Hay un par de otras funciones como a.serial (volviendo el nombre
del puerto serie), a.flush (el lavado del lado de entrada de serie del PC
puerto) y a.roundTrip, que envía un valor a la Arduino y la espalda.
Por último, utilice a.delete para eliminar el objeto Arduino, (y liberar el
puerto serie) cuando la sesión ha terminado.
Echar un vistazo a continuación un ejemplo.
-------------------------------------------------- -------------------------
EJEMPLO:
% Conectar la placa
a = Arduino ( 'COM5')
% Especificar el modo de pasador para los pines 4, 13 y 5
pinMode (a, 4, 'entrada');
pinMode (a, 13, 'output');
pinMode (a, 5, 'output');
% Lee la entrada digital desde el pin 4
dv = digitalRead (a, 4);
% De salida el valor digital (0 o 1) a la clavija 13
digitalWrite (a, 13, dv);
% Leer la entrada analógica del pin analógico 5 (físicamente! = Pin digital de 5)
av = analogRead (a, 5);
% Normalizar av desde 0 1023 a 0: 254
av = (av / 1,023) * 254;
valor% ouptput en digital (pwm) pin 5 (de nuevo, diferente de pin digital 5)
analogWrite (a, 5, redondo (av))
tensión de referencia% cambio para pines analógicos a externa
analogReference (a, 'externo');
% Cambiarlo de nuevo a los valores predeterminados
analogReference (a, 'default');
% Obtiene el nombre del puerto serie al que el Arduino está conectado a
de serie (a)
% Vacía el almacenamiento intermedio de entrada de serie del PC (si acaso)
flush (a);
% Envía el número 42 a la Arduino y la espalda (para ver si todavía está allí)
ida y vuelta (a, 42)
% Conectar servo en el pin # 9
servoAttach (a, 9);
% Devolver el estado de todos los servos
servoStatus (a);
% Servo gira en el pin # 9 de 100 grados
servoWrite (a, 9100);
% Lee el ángulo del servo en el pin # 9
val = servoRead (a, 9)
servo% Separar del pin # 9
servoDetach (a, 9);
% Adjuntar codificador # 0 en las clavijas 3 (pin A) y 2 (pin B)
encoderAttach (a, 0,3,2)
% Leer la posición del codificador
encoderRead (a, 0)
% Adjuntar codificador # 2 en las patillas 18 (pin A) y 21 (pin B)
encoderAttach (a, 2,18,21)
% conjuntos de supresión de rebotes de retardo a 17 (~ 1,7 ms) para codificador # 2
encoderDebounce (a, 2,17)
leer% de posición o codificador # 2
encoderRead (a, 2)
posición de reposición% de codificador # 2
encoderReset (a, 2)
% Obtener el estado de los tres codificadores
encoderStatus (a);
% De separación codificador # 0
encoderDetach (a, 0);
% Cerrar la sesión
borrar (a)
NOTA: En caso de que por alguna razón el puerto serie no se relaesed después de borrar
el objeto Arduino, puede utilizar los siguientes comandos para forzar la liberación
ot la conexión en serie:
% Eliminar la conexión en serie de MATLAB en COM3
eliminar (instrfind ({ 'Puerto'}, { 'COM3'}));
% Eliminar todas las conexiones en serie de MATLAB
eliminar (instrfind ( 'Tipo', 'serie'));
También tenga en cuenta que debido a MATLAB OO convenciones de nomenclatura, el primer
argumento
se puede pasar también antes de cualquier nombre de la función (método), por lo tanto, un
típico
funciones tales como: la función (a, arg2, arg3, ...) también se puede llamar así:
a.function (arg2, arg3, ...)
-------------------------------------------------- -------------------------
SKETCHES prestados:
Los siguientes dibujos se proporcionan con el paquete:
-) adio.pde: comandos serie analógicas y digitales IO, además básicas solamente
-) adioe.pde: el apoyo adio.pde + codificadores
-) adioes.pde: el apoyo adioe.pde + servo
-) motor_v1.pde: escudo adioes.pde + v1 afmotor
-) motor_v2.pde: escudo adioes.pde + v2 afmotor
En la mayoría de los casos el adioes.pde cubrirá todo lo que necesita. Los dos últimos bocetos
son necesarios para la Adafruit Motor Shield (versión 1 y 2 respectivamente).
Los 2 primeros bocetos se proporcionan sobre todo en caso de que su plataforma específica
no soporta servos o codificadores y como punto de partida mejor (más simple)
punto para las personas que desean personalizar un boceto para sus propios fines.
En este último caso, la función de "ida y vuelta" es probablemente el más fácil
lugar para empezar a introducir el código personalizado.
-------------------------------------------------- -------------------------
MODO DE DEMOSTRACIÓN:
Siempre 'Demo' se especifica como argumento de la función Arduino, es decir,
a = Arduino ( 'DEMO'), entonces una conexión virtual se abre que no implique
cualquier hardware. Esto permite tratar el paquete sin necesidad de tener una
placa Arduino. En este modo, todos los "leen" las funciones devuelven valores aleatorios
en función de su rango de salida. Asimismo, los retrasos se utilizan internamente de modo que
el tiempo de ejecución de cualquier función coincide aproximadamente con el promedio
tiempo de ejecución que se puede observar cuando se conecta la placa real.
Tenga en cuenta que el mismo comportamiento (valores de salida al azar) se produce cuando
el boceto
que se ejecuta en el tablero no es compatible con la operación específica (por ejemplo, un
servo
leer, pero se emite el boceto que se ejecuta en el tablero, por ejemplo adio.pde) no
servos de apoyo.
-------------------------------------------------- -------------------------
RETO BLINK:
El "blink_challenge" es un ejemplo de aplicación que cambia los LEDs en y
con frecuencia variable y con el modo de cambiar pulsando un botón interruptor
Echar un vistazo al archivo m para obtener más información, (tipo de ayuda de la
blink_challenge
línea de comandos) y blink_challenge lanzamiento para ejecutar la demo.
Cuenta que la ejecución de este applicaton sólo tiene sentido si es la placa Arduino
conectado a un circuito apropiado donde los pines digitales 9 a 13 están configurados
como salidas y conectado a leds, pin digital # 2 está configurado como entrada y
conectado a un botón que tira de la tensión hacia abajo cuando se presiona, y analógico
pin # 2 está conectado a un potenciómetro. Echar un vistazo a los esquemas de la
blink_challenge_sch.mdl archivo, en la carpeta de ejemplos.
-------------------------------------------------- -------------------------
USO DEL MOTOR SHIELD adafruit:
El protector del motor de adafruit es un escudo (con una biblioteca asociada)
para el control de motores de corriente continua y paso a paso. El paquete Arduino IO permite
el uso de la
Adafruit primitivas biblioteca protector del motor (además de los otros básica
IO y funciones servo descritos anteriormente) directamente desde MATLAB.
Los detalles sobre el escudo están aquí, la versión 1:
http://learn.adafruit.com/adafruit-motor-shield
y la versión 2:
http://learn.adafruit.com/adafruit-motor-shield-v2-for-arduino
Asegúrese de seguir las instrucciones sobre cómo instalar la biblioteca necesaria
(Ver también la sección "Instalación de la biblioteca protector del motor de" arriba).
Si estaba utilizando el boceto adioes.pde entonces usted necesita para cargar cualquiera
la motor_v1.pde (para las versiones 1.x del escudo) o motor_v2.pde (por
la versión 2 del escudo) boceto en el tablero, con el fin de utilizar el motor
proteger a las instrucciones relacionadas. Ambos bocetos necesario que el motor adafruit
relacionados
BIBLIOTECA escudo (véase el paso por encima de la instalación relacionada) para trabajar, sin
tener en cuenta
de si el protector del motor se monta en la parte superior de la Arduino o no.
Ambos bocetos de motor son los más completos, es decir que puede utilizar
ellos también para E / S básicas, servos, codificadores y así sucesivamente, incluso cuando el
motor
escudo no está montado en el Arduino. Sin embargo, tenga en cuenta que el adafruit
V1 protector del motor utiliza una gran cantidad de los pasadores, (ver el manual) así que si
usa tanto
IO digitales analógicas y las instrucciones de motor y es probable que interfieren
Unos con otros, (especialmente para la Versión 1 de la biblioteca y el escudo).
Por lo tanto, el mejor enfoque está usando ya sea las instrucciones IO o las
instrucciones escudo de motor y eliminar y reinstantiate el objeto Arduino
cada uno tiene que cambiar de un conjunto de instrucciones para el otro.
HACER ESCUDOS SWAP no caliente. Antes de montar el protector del motor de eliminar la
Arduino objeto del espacio de trabajo, desconectar, a continuación, montar el protector del
motor
en la parte superior de la Arduino, vuelva a conectar, cargar motor.pde a la junta, y
Por último, desde MATLAB, cree un nuevo objeto Arduino.
Adafruit MOTOR SHIELD Ejemplo:
% Conectar la placa
a = Arduino ( 'COM5')
velocidad conjuntos% de motor 4 como 200/255
MotorSpeed (a, 4200)
% Imprime la velocidad de todos los motores
MotorSpeed (a);
% Corre motor 1 hacia adelante
motorRun (a, 4, 'hacia adelante');
% El motor funciona hacia atrás 3
motorRun (a, 4, 'hacia atrás');
% Motor de liberación 1
motorRun (a, 4, 'liberación');
% ajusta la velocidad de paso a paso 1 como 10 rpm
stepperSpeed (a, 1,10)
% Imprime la velocidad de paso a paso 1
stepperSpeed (a, 1);
% Gira paso a paso 1 hacia delante de 100 pasos en el modo de intercalación
stepperStep (a, 1, 'hacia delante', 'doble', 100);
% Gira paso a paso 1 hacia atrás de 50 pasos en el modo de solo
stepperStep (a, 1, 'hacia atrás', 'single', 50);
% Emisiones paso a paso 1
stepperStep (a, 1, 'liberación');
% Cerrar la sesión
borrar (a)
Tenga en cuenta que todas las demás funciones relacionadas con clavijas analógicas y digitales
IO
así como para servos, todavía se puede utilizar como se describe en la anterior
ejemplo anterior.
También tenga en cuenta que las instrucciones paso a paso están bloqueando, que es la junta
no puede comenzar a ejecutar una nueva instrucción hasta la ejecución de la
comando previo paso a paso ha llegado hasta su finalización (que puede tardar varios
segundos si el número de pasos necesarios es alta).
-------------------------------------------------- -------------------------
USO DE LA ARDUINO MOTOR DE PASOS biblioteca (Stepper.h)
Puede modificar el boceto adafruit para trabajar con el Arduino oficial
stepper Stepper.h biblioteca, (+ info esta biblioteca se puede encontrar aquí:
http://arduino.cc/en/Reference/Stepper?from=Tutorial.Stepper).
A partir de AFMotor_v1.pde, resulta necesario modificar las siguientes líneas:
línea 61: reemplazar "# include <AFMotor.h>" con "# include <Stepper.h>"
líneas 77: Sustituir "AF_Stepper stm1 (200, 1);" con
"Stm1 paso a paso (200, 8,9,10,11);" suponiendo que desea conectar el primer
paso a paso a los pines 8,9,10,11 (por supuesto, usted puede elegir los pasadores que desee).
líneas 78: Sustituir "AF_Stepper STM2 (200, 1);" con
"STM2 paso a paso (200, 3,4,5,6);" asumiendo que desea conectar el segundo
paso a paso a los pines 8,9,10,11 (de nuevo, puede elegir los pasadores que desee).
Si usted no tiene un segundo paso a paso, puede utilizar números de los pines no utilizados
o usar los mismos pines como los utilizados en la línea 77.
borrar el código de las líneas 79 a 82 (que define los objetos de motor de corriente continua)
borrar el código de las líneas 374 (caso 170 a 440 :) (romper; / * s = 181 ... * /)
líneas 489 y 494: sustituir adelante con 1 y hacia atrás con -1
eliminar código de las líneas 499 y 500 (que llaman stm1.release y stm2.release)
eliminar código de las líneas 518, 523, 528, y 533 (ajuste de estilo en SINGLE,
DOBLE, INTERLEAVE DE, y MicroStep)
la línea 547: sustituir stm1.step (val, dir, pocilga); con stm1.step (val * dir);
la línea 548: sustituir stm2.step (val, dir, pocilga); con stm2.step (val * dir);
Ahora puede guardar el archivo (necesita estar en una carpeta separada que tiene el mismo
nombre que el archivo), abrirlo con el IDE, y cargarlo en el Arduino.
Esta será reconocido por MATLAB como el boceto afmotor_v1, y que será
capaz de utilizar las principales instrucciones paso a paso (tenga en cuenta sin embargo que el
estilo
parámetro, mientras que se requiere, es ignorada por el dibujo).
Gracias a Gianmarco Errico para sus entradas iniciales y a Luca para Dalbosco
probar el boceto final resultante.
-------------------------------------------------- -------------------------
SIMULINK BIBLIOTECA
Desde la versión 3.0 de este paquete también viene con una biblioteca que Simulink
tiene bloques de analógico y digital IO, así como servo de lectura y escritura,
Motor y control paso a paso. Tipo "arduino_io_lib" para abrir la biblioteca.
El bloque de configuración puede utilizar un objeto Arduino preexistente en el
espacio de trabajo, o se puede crear una instancia de un objeto de forma automática Arduino
temporal
antes de la simulación. En este último caso, el objeto se pone automáticamente
borrada después de la simulación ha terminado. Usted tiene que utilizar este bloque (el
bloque de configuración) con el fin de utilizar los otros, y hay que utilizar una
bloque diferente configuración para cada variable Arduino diferente que utilice
en la simulación.
Los ejemplos que ilustran cómo utilizar analógicas IO bloques son los archivos
"Blink_challenge_sim.mdl" y "blink_challenge_sf.mdl", que son la
Simulink y Stateflow aplicación de la demostración desafío abrir y cerrar
descrito anteriormente en este archivo Léame. El archivo de muestra "servo_sim.mdl"
cómo usar el Servo leer y escribir bloques.
Tenga en cuenta que estos bloques, que se basan en objetos de MATLAB (y confiar en el
OS pila de comunicación en serie), no apoyan la generación de código.
El paquete de compatibilidad con Simulink para Arduino:
http://www.mathworks.com/academia/arduino-software/arduino-simulink.html
y el Paquete Coder Soporte de Respaldo para Arduino:
http://www.mathworks.com/matlabcentral/fileexchange/30277
puede tanto ser utilizado para generar automáticamente, a partir de Simulink, Arduino
ejecutables que se cargan y ejecutan en el tablero de forma automática.
-------------------------------------------------- -------------------------
SOLUCIÓN DE PROBLEMAS
Este software fue desarrollado principalmente en R2011a, y no ha sido probado totalmente
para
versiones anteriores a R2010a, por lo que sugieren para obtener al menos R2011a (o posterior)
si puedes.
La biblioteca Simulink no funcionará en versiones anteriores a R2010a, (porque
el objeto Arduino se comparte entre los bloques de las características modelo utilizando
introducido desde R2010a). En cualquier caso, este software utiliza el nuevo MATLAB
sistema de objetos, y que sin duda no puede trabajar en las versiones anteriores a R2008a.
Me he encontrado en el pasado para los casos (usando el tablero Duemilanove) en
MATLAB, que tenía problemas en la conexión a la placa Arduino al crear una
objeto (específicamente, esto se tradujo en el mensaje de error: "Conexión
sin éxito, por favor asegúrese de que el Arduino se enciende ... "),
Aunque podía conectar muy bien con el IDE o Hyperterminal.
Creo que esto se resuelve ahora, ya que era probable que se deba a una combinación de
factores, incluyendo la biblioteca servotimer mayor, demasiado tiempo consumidos en el
configuración para inicializar alfileres, y demasiado bajo un retraso entre un intento de
conexión
y la primera operación. De todos modos, si le sucede que tiene un problema similar
la primera sugerencia es entrar en el archivo arduino.m, encontrar estas líneas:
fprintf (1, 'El intento de conexión.');
para i = 1: 12,
pausa (1);
fprintf (1, '');
fin
y aumentar ese 12 hasta 15 o más hasta que funcione. otra sugerencia
está utilizando el adio.pde más simple o adioe.pde bocetos en lugar de la
más adioes.pde complejo o motor_vX.pde.
Tenía algunos casos en los que el error anterior se presentó cuando el motor_v2
esbozo se ejecuta en el Arduino Uno y una placa de prototipos con el
circuito de abrir y cerrar desafío estaba enchufado en la parte superior de la Arduino Uno.
Extracción
que el consejo específico (y / o conectar el protector del motor de uno), parecido a resolver
ese problema (no he sido capaz de reproducir esto con la junta Mega).
Además, si se produce un error como los siguientes:
??? Error al utilizar ==> serial.fwrite en ...
o:
??? Error al utilizar ==> serial.get en ...
instrumento objeto OBJ es un objeto no válido.
o, durante una creación de objetos, como este:
??? Error al utilizar ==> Arduino> arduino.arduino a 77
No se pudo abrir el puerto: COM9
o:
??? Error al utilizar ==> Arduino> arduino.arduino a los 48
Puerto COM 9 ya utilizado por MATLAB
entonces es probable que significa que algo salió mal con su conexión en serie,
(Esto puede suceder a veces, por ejemplo, si la junta se reinicia, el cual
sucede mucho cuando se utilizan los servos sin una buena fuente de energía) y su
mejor oportunidad está haciendo lo siguiente:
1) asegurarse de que ningún otro programa (por ejemplo, el IDE se utiliza el mismo puerto
COM)
2) eliminar el objeto Arduino, ignorar las advertencias de posibles
3) borrar (instrfind ({ 'Puerto'}, { 'COM9'}))%, por supuesto, utilizar el puerto COM correcto
4) Desconectar el cable Arduino, vuelva a conectarlo
5) crear un nuevo objeto Arduino
-------------------------------------------------- -------------------------
Utilizando el paquete SIN MATLAB (EG IDE o HYPETERMINAL)
Tenga en cuenta que si bien este paquete fue diseñado para ser utilizado con MATLAB, puede
puede utilizar con cualquier programa que le permite comunicarse a través del puerto serie.
Esto es realmente una buena estrategia de solución de problemas, ya que le permite a
descubrir si algún problema o comportamiento inesperado se origina en el
hardware o sistema operativo de nivel, o si se origina en MATLAB.
La manera más fácil de hacer esto es usar el Monitor de serie IDE (en la parte superior
esquina derecha de la IDE) para enviar y recibir mensajes de resultados. Una vez tú
iniciar el monitor de serie y seleccione 115200 como velocidad de transmisión, que se puede
escribir
mensajes en la fila superior y los envían a través del puerto serie haciendo clic en "Enviar"
botón.
Un mensaje de serie a adioes.pde se hace típicamente por no más de 3 partes:
1) un número o una letra mayúscula que indica la acción
2) una letra minúscula que indica el número de pin
3) un número o una letra que indica un valor que han de transmitirse
Por ejemplo el comando "1c" lee pin digital # 2, como "1" representa
digitalRead y "c" significa pin # 2 (ascii (c) -ascii (a) = 2)
Del mismo modo (reportado de motor.pde):
0E0: asigna pin digital # 4 (e) como entrada
0f1: asigna pin digital # 5 (f) como salida
0n1: asigna pin digital # 13 (n) como salida
1c: lee pin digital # 2 (c)
1e: lee pin digital # 4 (e)
2N0: establece pin digital # 13 (n) baja
2n1: establece pin digital # 13 (n) de alto
2F1: establece pin digital # 5 (f) de alto
2f0: establece pin digital # 5 (f) baja
4J2: establece pin digital # 9 (j) a 50 = ascii (2) sobre 255
4JZ: establece pin digital # 9 (j) a 122 = ascii (z) sobre 255
3a: lee pin analógico # 0 (a)
3f: lee pin analógico # 5 (f)
5j: lee el estado (conectado / extraíble) de servo en el pin # 9
5k: lee el estado (conectado / independiente) del servo en el pin # 10
6J1: concede servo en el pin # 9
8JZ: mueve servo en el pin # 9 de 122 grados (122 = ascii (z))
7j: lee ángulo del servo en el pin # 9
6j0: se separa del servo en el pin # 9
A1z: establece la velocidad de motor # 1 para 122 sobre 255 (122 = ascii (z))
A4A: establece la velocidad de motor # 4 a 65 sobre 255 (65 = ascii (A))
B1F: El motor funciona # 1 hacia delante (f = hacia adelante)
B4b: El motor funciona # 4 hacia atrás (b = hacia atrás)
B1R: comunicados de motor # 1 (r = liberación)
C12: conjuntos de velocidad de motor paso a paso # 1 a 50 rpm (50 = ascii (2))
C2Z: establece la velocidad de motor paso a paso # 2 a 90 rpm (90 = ascii (Z))
D1fsz: hacer 122 pasos en el motor # 1 hacia adelante en el modo simple (s)
D1biA: hace 65 pasos en motor # 1 hacia atrás en el interleave (i) Modo
D2fdz: hace 122 pasos en motor # 1 hacia adelante en el modo doble (d)
D2bmA: hace 65 pasos en motor # 2 hacia atrás en microstep modo (m)
D1R: comunicados de motor # 1 (r = liberación)
D2R: comunicados de motor # 2 (r = liberación)
E0cd: concede codificador # 0 (0) en las patillas 2 (c) y 3 (d)
E1st: concede codificador # 1 en las patillas 18 (S) y 19 (t)
E2vu: concede codificador # 2 en los pines 21 (v) y 20 (u)
G0: consigue 0 posición del codificador # 0
I0u: establece retardo de entrada para 20 (2 ms) para el codificador # 0
H1: restablece la posición del codificador # 1
F2: separa codificador # 2
R0: establece la referencia analógica a DEFAULT
R1: establece referencia analógica a INTERNAL
R2: establece referencia analógica a EXTERNAL
X3: caso de ejemplo de ida y vuelta de regresar la entrada (ascii (3))
99: vuelve script type (0 adio.pde ... 3 motor.pde)
En general, se espera que si cualquiera de los 4 bocetos servidor estaba
compilado y cargado en el tablero con éxito, entonces uno debe ser capaz de
para comunicarse con la junta a través del puerto de serie como se describe anteriormente.
En plataformas Windows anteriores a Vista, puede abrir el hyperterminal,
(Inicio -> Programas -> Accesorios -> Comunicaciones -> HyperTerminal)
Seleccione el puerto COM correcto en el inicial "conectarse a" de diálogo, a continuación,
seleccione
115.200 como "bits por segundo", y también seleccionar "None" como control de flujo.
No se puede ver lo que escribe, sino que debe ver los resultados, por lo que escribir
"99" deben devolver el tipo sript (1,2 o 3) de inmediato. Esto le da una forma
para probar el paquete de una manera independiente de IDE, que también podría ser
importante
en la solución de un problema.
-------------------------------------------------- -------------------------
Personalización:
Para las personas que desean personalizar el paquete o simplemente añadir su propio código
para hacer cosas, se sugiere a partir de la función de ida y vuelta mencionado
anteriormente, que está provisto específicamente como un ejemplo para este propósito.
El manejo de esta función maniquí en el fichero pde sección se encuentra partida
del "caso 400:", uno puede tomar el parámetro, realizar alguna potencialmente
operación útil y, a continuación, enviar cualquier resultado de nuevo a través de la conexión en
serie.
-------------------------------------------------- -------------------------
ARCHIVOS E HISTORIA:
Ver contents.m para obtener información sobre los archivos y el historial de versiones.
-------------------------------------------------- -------------------------
Giampiero Campa, junio de 2014, Derechos de autor 2014, The MathWorks, Inc.
