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.