memoria ctrl-dali - facultad de ingeniería
TRANSCRIPT
Memoria
CTRL-DALI
Sistemas Embebidos Para Tiempo Real
2015
Controlador de luminarias por protocolo DALI (Digital Addressable Lightng
Interface) para salón de actos de Facultad de Ingeniería
Integrantes: Bruno Inuggi, Rodrigo Pérez, Federico Pugliese.
Tutores: Mauricio González y Javier Schandy
1
Resumen
Con la idea de mejorar la iluminación del salón de actos surgió la necesidad de realizar unsistema inteligente de control de luminarias. El protocolo DALI (Digital Lightng AddressableInterface), el cual permite una comunicación con cada luminaria para cambiar su intensidad deluz, es la opción elegida. Cada luminaria es un grupo de luces LED de alto brillo manejadas porun driver DALI, el cual interpreta comandos y actúa sobre ellas. De aquí en más llamaremos adicho driver, balasto.
CTRL-DALI es un controlador de luminarias basado en dicho protocolo DALI y estáimplementado en un microcontrolador MSP430g2553 de Texas Instruments. Para comandarlas luces se incluyen cuatro botones y una llave bipolar (dimmer digital).
El funcionamiento se basa en “escenas”. Cada escena indica cuales luces se deben modifcar ycon qué intensidad. Cuando se oprime un botón determinado, el microcontrolador crea laescena asociada a dicho botón mandando comandos DALI a los balastos. Inmediatamente seenciende un LED encima de dicho botón para indicar la escena actual.Por otro lado, la llave bipolar es encargada de incrementar o disminuir el nivel de luminosidadde las luminarias afectadas por la escena actual.
2
Palabras clave:
DALI: El protocolo DALI (Digital Addresable Lightng Interface) es un nuevo estándar diseñado
para el control de los niveles de iluminación.
Balasto: Driver de cada luminaria encargado de reconocer los comandos y establecer la
luminosidad de la luminaria
Escenas: Cada una de las confguraciones previamente establecida de luminosidad de cada
luminaria o grupo de luminarias.
Dirección corta: Dirección de 6 bits, la cual corresponde a una única luminaria.
Dirección de grupo: Dirección de 4 bits, correspondiente a un grupo de luminarias.
Comandos directos: Comandos dirigidos a una dirección corta o dirección de grupo los cuales
establecen un determinado nivel de luminosidad.
Comandos indirectos: Comandos dirigidos a una dirección corta o dirección de grupo los
cuales implican un aumento o disminución de la luminosidad a partr de su estado anterior.
3
Contenido1. Introducción.........................................................................................................................5
1.1 Descripción del problema...................................................................................................5
1.2 Antecedentes.....................................................................................................................5
2. Objetvos..............................................................................................................................5
3. Alcance.................................................................................................................................6
3.1 Requerimientos funcionales...............................................................................................6
3.2 Modulos Desarrollados......................................................................................................7
4. Diseño..................................................................................................................................8
4.1 Softare.............................................................................................................................8
4.2 Hardtare............................................................................................................................9
4.2.1 Requerimientos y restricciones del sistema.............................................................9
5. Implementación.................................................................................................................11
5.1 Estándar DALI y comandos seleccionados........................................................................11
5.2 Desarrollo de Softare.....................................................................................................13
5.3 Montaje y conexionado de Hardtare..............................................................................13
6. Pruebas..............................................................................................................................13
7. Conclusiones......................................................................................................................28
8. Referencias.........................................................................................................................29
9. Anexo:................................................................................................................................29
4
1. Introducción
En el presente trabajo se describe la solución al problema de mejorar la iluminación del salón
de actos mediante un sistema de control que cumpla con el protocolo DALI (Digital
Addressable Lightng Interface).
1.1 Descripción del problema
Se busca mejorar la iluminación del salón de actos y facilitar el cambio de iluminación entre las
diferentes modalidades de uso.
1.2 Antecedentes
Protocolo DALI detallado en el estándar IEC 62386.
Controlador DALI en FPGA Cyclone III EP3C16 (kit de desarrollo DEO)1.
Placa conversora de capa fsica TTL a capa fsica DALI2.
1 Proyecto de la asignatura Diseño Lógico II, Facultad de Ingeniería.
2 Proyecto referido por Sebastán Fernández.
5
2. Objetivos 1) Diseñar una aplicación en C para el microcontrolador MSP430g2553, el cual realice
funciones de comunicación con luminarias independientes (o grupos de luminarias) y
así cambiar su intensidad de luz.
2) Diseñar la interfaz de usuario con botones, LEDs y llave bipolar. Realizar las conexiones
con el microcontrolador.
3) Conectar adecuadamente la placa conversora de niveles (detallada en el punto
anterior), de forma de permitr la traducción de niveles de señal entre el
microcontrolador y los balastos.
3. Alcance
El alcance del proyecto está determinado por los requerimientos establecidos por Sebastán
Fernández, docente que planteó los objetvos y lidera el proyecto de iluminación del salón de
actos de la Facultad de Ingeniería de UdelaR.
3.1 Requerimientos funcionalesLa funcionalidad al inicio del proyecto era la siguiente:
El usuario debe ser capaz de, mediante botones y llaves, establecer el nivel de luminosidad
deseado. Deben existr cuatro escenas precargadas (APAGADO, PROYECCIÓN, CLASE e
ILUMINACIÓN GENERAL) que se seleccionan a través de un botón dedicado para cada una.
En la parte superior de cada botón, un LED indica la escena actual.
Por otro lado, será posible modifcar el estado de iluminación actual a través de llaves
bipolares. Dichas llaves permiten aumentar o disminuír la intensidad de luz de un grupo
específco de luminarias. Se cuenta con tres grupos de luminarias: butacas, escenario
central y escenario lateral.
Luego de varias reuniones con Sebastán Fernández, se cambiaron los requerimientos a los
siguientes:
El usuario debe ser capaz de, mediante cuatro botones y una llave bipolar, establecer el
nivel de luminosidad deseado. Deben existr cuatro escenas precargadas que se
seleccionan a través de un botón dedicado para cada una. En la parte superior de cada
botón, un LED indica la escena actual. La llave bipolar debe modifcar la luminosidad de las
luminarias asociadas a la escena actual.
Las escenas y los grupos de luminarias no se defnen explícitamente, pero con fnes de
demostración se programó de la siguiente forma:
Grupo Nombre degrupo
Luminarias
1 EscenarioEscenario centroEscenario lateral
2 ButacasButacas adelante
Butacas atrásTabla 1: Grupos de luminarias
6
EscenaBotón
asociadoIntensidad por
luminarias
Clase 1Escenario: 70%Butacas: 100%
Proyección
2Escenario centro: 0%
Escenario lateral: 40%
Escenario 3 Escenario: 80%
Apagado 4Escenario: 0%Butacas: 0%
Tabla 2: Escenas
3.2 Módulos DesarrolladosAl inicio del proyecto se habían defnido los siguientes tres módulos a desarrollar:
Módulo Driver
Módulo Lógica
Módulo Escenas
A medida que se fue realizando la implementación del frmtare, se vio la necesidad de incluir
más módulos: tmer y escenas.
Finalmente, se desarrollaron 5 módulos de softare y se incluyó como parte de la solución una
placa con los botones y la llave bipolar descripta anteriormente. Además, para completar la
solución se utlizó la placa conversora referida en la sección 1.2.
Software:
Módulo Driver
Módulo Lógica
Módulo Escenas.
Módulo Controlador de Periféricos
Módulo Tiempo
Hardware:
Se diseñó y se soldó una placa con 4 botones, 4 leds y una llave bipolar.
Se utlizó placa conversora del proyecto mencionado en 1.2 (Gatetay PC-DALI).
Fuera del alcance
A contnuación describimos qué no incluye nuestro proyecto, mayormente debido a la falta de
tempo para realizar más tareas:
Recepción de comando Manchester en codifcación DALI.
Totalidad de comandos DALI. Sólo se incluyen los necesarios para el funcionamiento.
A futuro se puede implementar dichos puntos, así como una interfaz UART con un PC para la
reprogramación de escenas sin necesidad de reprogramar el microcontrolador.
7
4. Diseño
4.1 SoftwareA partr de los requerimientos funcionales de 3.1 se determinó cual serían los módulos
necesarios para cumplir con los objetvos, vemos a contnuación un diagrama de bloques
conceptual:
Imagen 1: Diagrama de bloques
Bloques:
Controlador Periféricos:
Este bloque tene como funcionalidades básicas las de capturar el botón presionado o el
accionamiento de la llave. También es el encargado del manejo de los LEDs. Se comunica
con el bloque lógica, pasando como parámetro el botón presionado o la posición de la
llave.
Lógica del sistema:
Es el bloque encargado de decidir qué acción tomar en función del parámetro pasado por
el bloque controlador de periféricos. Comunica al bloque de escenas la escena que se debe
seleccionar y al controlador de periféricos el LED a encender.
Escenas:
En función del parámetro pasado por la lógica, conformará la escena y enviará los datos de
la misma al bloque del driver DALI. La escena contará con información de las luminarias a
8
encender, intensidad, si son comandos de grupo o individuales y si los balastos de la
escena son dimerizables o no.
Driver DALI:
Conformará los mensajes a transmitr de acuerdo al protocolo DALI incluyendo los bits de
datos correspondientes a la escena y bit de parada. También enviará los bits conformados
previamente con codifcación Manchester.
4.2 HardwareVeremos como a partr del diseño de 4.1 defnimos requerimientos a nivel hardtare. Hubo
pequeñas modifcaciones con respecto a la especifcación fnal del proyecto.
4.2.1 Requerimientos y restricciones del sistema
Procesamiento y memoria:
Tomamos como propuesta inicial el microcontrolador MSP430g25533 y analizamos las
siguientes característcas:
RAM: Estmamos un consumo mínimo de memoria RAM (variables) ya que sólo
existrían variables relacionadas a las escenas, identfcadores de cada grupo de
balastos (3 grupos) y variables auxiliares y balastos individuales.
FLASH: dado el alcance del proyecto y haciendo comparación con otros
proyectos similares, los 16 KB de MSP430g2553 fueron más que sufcientes.
RELOJ: Las tramas DALI se deben generar a 1200 bps. Como es necesario
codifcar en Manchester, el microcontrolador debe poder conmutar salidas
digitales a 2400 bps o 2,4 kHz. El reloj de 32 kHz integrado en el “Launchpad”
(plataforma de desarrollo para MSP430g2553) es sufciente.
GPIO (Entradas y salidas):
En la especifcación fnal hablamos de que la solución iba a contar con 4 botones, 4 leds, 3
llaves (6 pines), un pin para enviar datos y otro para recibirlos, en total serían necesarios 16
pines. A medida que fue avanzando el proyecto y cuando fnalmente quedaron defnidos los
requerimientos funcionales se determinó que 2 de las llaves no serían necesarias, por lo tanto
quedaron libres 4 pines.
En conclusión, fueron necesarios 12 pines digitales para comandar todos los periféricos. El
microcontrolador MSP430g2553 posee 2 puertos de 8 pines digitales cada uno, lo cual fue
sufciente.
3 Hoja de datos del microcontrolador MSP430g2553:
http://ttt.t.com/lit/ds/symlink/msp430g2553.pdf
9
Con respecto el reloj, nos encontramos con el problema que los pines usador por el cristal de
32 kHz externo no era posible utlizarlos. Como al principio era necesario utlizar todos los
pines, se tuvo que desoldar el cristal para dejar libre los pines y usar el DCO a 1 MHz como
reloj principal. Finalmente, el clock del sistema quedó con el DCO y no se volvió a usar el cristal
de 32 kHz.
Los 4 pines sobrantes se pueden usar en un futuro para implementar la comunicación UART
con un PC.
Plataforma de hardware: la plataforma cuenta con los componentes que se ven en la
siguiente fgura:
Imagen 2: Esquema de hardware
Microcontrolador MSP430g2553: master DALI donde se implementará el código C de los
diferentes bloques descriptos en la sección 4.1.
Conversor: Se reutlizó el del otro proyecto mencionado en 1.2, este conversor modifca la
capa fsica TTL Manchester (microcontrolador) a la forma de capa fsica de DALI.
Botones: fueron necesarios 4 botones digitales para cambiar las escenas, no se contaba con
dichos botones, fueron adquiridos.
10
Llave bipolar – “dimmer digital”: para modifcar la intensidad de los balastos asociados a la
escena seleccionada. Se utlizó solo uno y ya contábamos con el previamente.
Leds: fueron necesarios cuatro leds para indicar la escena seleccionada.
Balastos DALI: Se usaron cuatro para la demostración. Cada una con una dirección única
asociada.
Arquitectura de software: la Arquitectura de softare para el manejo de interrupciones y
procesos será Round Robin con interrupciones. Se llegó a dicha conclusión de forma de
simplifcar el diseño.
5. Implementación
El entorno de desarrollo utlizado es el IAR Embedded Workbench IDE, el cual es el
recomendado para trabajar con los microcontroladores MSP de Texas Instruments.
5.1 Estándar DALI y comandos seleccionadosPrevio a entrar en los detalles de la implementación de softare y el montaje y conexionado
del hardtare hacemos una breve introducción al estándar DALI.
Digital Adressable Lightng Interface (DALI) es un protocolo de comunicación en luminarias que
permite el envío de comandos para confguración de la luminosidad de la luminaria y al mismo
tempo poder consultar estados de las mismas.
DALI funciona con una libre topología de conexión, limitado a un número máximo de 64
dispositvos. La señal digital de DALI viaja por dos cables que conectan el control con el balasto.
Un controlador DALI puede enviar diferentes comandos al balastro, que podríamos resumir
como: Direccionamiento (Quién); Comando (Qué); y Datos (Cuánto).
o Ventajas frente a otros protocolos semejantes:
• Un cableado simple (costo reducido)
• Control centralizado e individual de cada balastro, con la posibilidad de
creación de grupos
• Información del estado y confguración de la luminaria.
• Capacidad de añadir sensores o cualquier otro dispositvo que complemente el
funcionamiento de la instalación.
El protocolo tene una velocidad de 1200 bps, en codifcación Mánchester.
Debido a que únicamente se utlizarán el envío de comando se obviará la explicación de los
comandos de recepción.
11
Comandos de transmisión DALI
Los comandos de transmisión DALI están compuestos por un bit de arranque en 1, un byte de
direccionamiento, un byte de comando y dos bits de parada.
El byte de direccionamiento es conformado según la siguiente tabla
Tipo de dirección Byte
Dirección corta o de grupo YAAA AAAS
Dirección Corta 0AAA AAAS
Dirección de grupo 100A AAAS
Broadcast 1111 111S
Comando especial 101C CC1
110C CC1
Y: Indica si es dirigido a una dirección corta o a dirección de grupo/broadcast (0 o 1
respectvamente)
S: implica si el siguiente byte corresponde a un nivel de luminosidad o un comando (0 o 1
respectvamente)
A: Bits de dirección
C: Bits de comando especial
Los distntos bytes de comando se puedan agrupar en:
o Comandos directos o indirectos: Establecen el nivel de iluminación de los
balasto. Los utlizados en este proyecto serán:
• DIRECT_ARC_POWER: Comando de establecimiento de nivel luminoso
directamente.
Sintaxis: YAAA AAA0 XXXXXXXX , siendo XXXXXXXX el nivel de
luminosidad.
• STEP_DOWN_AND_OFF/ON_AND_STEP UP: Comandos para subir o
bajar el nivel de luminosidad de una luminaria o grupo.
Sintaxis UP: YAAAAAA1 00001000
DOWN: YAAAAAA1 00000111
o Comandos de confguración de balasto.
o Query comands: Consultas de estado del balasto.
12
o Comandos especiales: Utlizados para iniciar y setear balastos.
5.2 Desarrollo de SoftwareA contnuación se detallan las funciones correspondientes a los módulos desarrollados:
1. Periféricos (entradas.h y leds.h):
a. void initLed();
Confgura los puertos de salida para los LEDs.
b. void ledEncender(int led);
Enciende el LED pasado cómo parámetro. Si se pasa “0” se apagan todos los
LEDs
c. void initEntradas();
Confgura los puertos de entrada para los botones y la llave.
d. Int botonPresionado();
Devuelve el ID del botón (o la posición de la llave) previamente presionado. Si
no se presionó ninguno, se devuelve “0”.
e. void liberarBoton();
Resetea la variable “boton” (módulo entradas.c) para que la función
botonPresionado() devuelva “0”.
f. char getPortState(unsigned char puerto);
Devulve el registro PxIN del puerto “puerto” (“1” o “2”).
2. DALI (dali.h):
a. char TX_manchester(uint16_t comando);
Envía en codifcación Manchester los bits defnidos en “comando”. Devuelve
“1” si fue posible transmitr, “0” de lo contrario.
b. void TX_enable();
Habilita la transmisión Manchester.
c. void TX_disable();
Deshabilita la transmisión Manchester.
d. void enviarComGrupoDALI(uint8_t address, uint8_t comando, uint8_t valor);
Envía el comando “comando” (DIRECT_POWER_ARC o INDIRECT_POWER_ARC)
al grupo de balastos con address “address” con el valor “valor” (sólo se utliza
si es comando directo).
e. void enviarComLumDALI(uint8_t address, uint8_t comando, uint8_t valor);
Envía el comando “comando” (DIRECT_POWER_ARC o INDIRECT_POWER_ARC)
al balasto con address “address” con el valor “valor” (sólo se utliza si es
comando directo).
f. char TX_OK();
Devuelve “1” si es posible transmitr, “0” de lo contrario.
Timers (tempo.h):
g. void init_tmer_clock();
Confgura los tmers.
13
h. void init_BCS();
Inicializa el Basic Clock System. DCO a 1MHz como MCLK y SMCLK.
i. void rebotesStart();
Inicia el delay para evitar rebotes de los botones. Se debe llamar en las rutnas
de interrupciones de los botones.
j. unsigned char rebotesEnd();
Indica si ya terminaron los rebotes (20 ms). Devuelve “1” en caso afrmatvo,
“0” en el otro caso.
k. void startTimer1(unsigned long tme);
Actva las interrupciones del tmer 1 y lo detene luego de transcurrido el
tempo “tme”.
l. void stopTimer1();
Desactva las interrupciones del tmer 1.
m. char tmer_1_on();
Devuelve “1” si el tmer 1 está con interrupciones actvadas, “0” de lo
contrario.
n. void DelayUS(unsigned long delay);
Genera un retardo de “delay” microsegundos.
3. Lógica (logica.h):
a. void logica();
Función principal del sistema. Toma acciones dependiendo de los botones
presionados.
4. Escenas (escenas.h):
a. void setEscena(int tpoComando, char numEscena);
Lanza una escena hacia los balastos. Se pasa cómo parámetros “tpoComando”
(DIM_UP, DIM_DOWN o SET_ESCENA) y “numEscena” (número de la escena
precargada).
b. char getEscenaActual();
Devuelve el número de la escena actual.
14
Confguración de escenas
Para modifcar los parámetros de las escenas precargadas se debe modifcar el archivo
“escenas.c”. A contnuación se muestra la parte del código de “escenas.c” destnado a éste fn:
/************************************************************************/
/* DEFINICIÓN DE ESCENAS
Se dispone de 4 escenas con parámetros modifcables:
escenaX = {cantdad de direcciones, son dir de grupo?, grupos o direcciones, son dimerizables?, niveles}
******NO ES POSIBLE DIRECCIONAR MÁS DE 24 ADDRESSES (DE GRUPO O INDIVIDUAL)*****/
/* Clase, grupo 1 al 75% y grupo 2 al 100% */
escena1 = {4, {0, 0, 0, 0}, {Escenario_Centro, Escenario_Lateral, Butacas_Front, Butacas_Rear}, {1, 1, 1, 1},
{SETENTAYCINCO, SETENTAYCINCO, MAX_LEVEL, MAX_LEVEL}},
/* Proyector, luminaria 1 apagada (no dimerizable) y luminaria 2 al 40% */
escena2 = {2, {0, 0}, {Escenario_Centro, Escenario_Lateral}, {0, 1}, {OFF, CUARENTAYCINCO}},
/* Escenario, grupo 1 al 75% */
escena3 = {2, {0, 0}, {Escenario_Centro, Escenario_Lateral}, {1, 1}, {SETENTAYCINCO, SETENTAYCINCO}},
/* Apagado, todas las luces apagadas */
escena4 = {4, {0, 0, 0, 0}, {Escenario_Centro, Escenario_Lateral, Butacas_Front, Butacas_Rear}, {1, 1, 1, 1}, {OFF,
OFF, OFF, OFF}};
/******************************************************************************/
Cada escena tene 5 parámetros:
1. Largo – Cantdad de balastos afectados en la escena
2. ¿Es dirección de grupo? – Si la dirección a contnuación es de grupo
3. Address – La dirección del balasto (grupo o individual)
4. ¿Es dimerizable? – Si se permite dimerizar el balasto en la escena
5. Valor – Valor de luminosidad para el balasto
15
Exceptuando el valor de “Largo”, todos los demás parámetros tenen un valor por balasto
afectado a la escena.
Si queremos modifcar la escena “escenaX”, debemos escribir (luego del signo de igual y entre
corchetes) los parámetros en orden y separados por comas. Para escribir más de un valor de
parámetro (para varios balastos en la misma escena), se deben escribir dentro de corchetes y
separados por comas.
Los parámetros 2 y 4 deben ser unos o ceros, siguiendo la lógica binaria.
Debido a la forma de implementación de las escenas y la limitada memoria de datos del
MSP430g2553, no es posible direccionar más de 24 direcciones (ya sea de grupo o
individuales) en cada una de las 4 escenas.
5.3 Montaje y conexionado de HardwareEn el montaje de la botonera se tuvo en cuenta que fue confgurado un pullup en las entradas
de manera que en caso de no ser apretado un botón (o una llave) la misma se mantenga en
nivel alto. Por lo tanto los mismos fueron conectados entre terra y su correspondiente pin.
Para el montaje fnal de las 3 placas (botonera, microcontrolador y placa conversora)
procedimos a desarrollar un prototpo de espuma plast para que las consolidara en una sola
estructura.
Una vez montado lo anterior procedimos a conectar los leds y botones a los pines
correspondientes del micro según la siguiente tabla:
Puerto y pin del micro Componente en botonera
P1.4 LED 1
P1.5 LED 2
P2.2 LED 3
P1.6 LED 4
P1.0 Boton 1
P1.1 Boton 2
P1.2 Boton 3
P1.3 Boton 4
P2.0 Llave 1 up
P2.1 Llave 1 dotn
Gnd Gnd
16
Luego pasamos a conectar los pines correspondientes a la placa conversora, los cuales estaban
especifcados en el proyecto donde se desarrollo la placa. Los mismos son 4: uno a Vcc, otro a
terra y luego TX al P2.6 y Rx al P2.7.
Puerto y pin del micro Pin de placa conversora
P2.6 Tx
P2.7 Rx*
Vcc Vcc
Gnd Gnd*No se utlizó la recepción pero de todas maneras conectamos el pin
Por últmo, se conectó los pines de salida de la placa conversora a la red de balastos. Al ser la
misma de tpología libre se opto para la prueba conectarlos en serie.
6. Pruebas
Prueba 1: Correcto control de interrupciones y manejo de leds
Luego de armado el control central de botones, leds y el esquema de lógica se procedió a
verifcar el correcto funcionamiento de las interrupciones, verifcando que al presionar cada
botón se entraba a la rutna de interrupción saliendo del estado de reposo y conmutando al
led correspondiente.
Prueba 2: Trama y medición del tempo de bit
Antes del envío del comando directamente a los balastos se midió mediante osciloscopio el
correcto armado de la trama, verifcando que el tempo de bit era el correcto.
Conectamos el pin 2.6 del microcontrolador (Pin de transmisión) a una de las puntas del
osciloscopio, luego mediante el programa desarrollado enviamos mensajes conocidos y
observamos el resultado en pantalla del osciloscopio.
Transmisión del numero binario: 00000000 01100111
17
Comprobamos el resultado y el mismo es correcto, 1 bit de inicio (sb), 16 bits de datos y dos
bits de parada (stop)
Comprobamos el tempo de bit, recordando que la conmutación debía realizarse a 2400 Hz por
ser codifcación Manchester lo que da un ancho de pulso de 416us:
18
Se puede ver, en la imagen anterior, que el ancho del pulso es de 510us lo que es mayor que el
ancho correcto, investgando nuestro desarrollo detectamos que el problema está en los ciclos
de reloj necesarios para procesar las diferentes funciones involucradas, estmamos que dichos
ciclos introducían un retardo de 100us. Por lo que procedimos a restar este retardo en la
confguración del tmer A1, por lo tanto este interrumpe cada (416 – 100)us cuando está
actvado.
19
En la siguiente fgura vemos nuevamente la captura en el osciloscopio luego de modifcar el
código y el ancho del pulso es el correcto:
20
Previo a las siguientes pruebas fueron confguramos conjunto con el docente Sebastán
Fernández las direcciones de los balastos mediante un Gatetay PC-Driver. Y fueron
conectadas las 4 luminarias a utlizar en la prueba fnal del proyecto.
Prueba 3: Pruebas de montaje y recepción
En esta prueba luego de que ya teníamos el código implementado y la botonera soldada en
una placa procedimos a interconectar los diferentes componentes de la solución, estos son:
Botonera
Microcontrolador
Placa conversora
Con esta parte del hardtare conectado procedimos a visualizar con el osciloscopio una trama
enviada a la placa conversora y corroborar si esta es correcta. Conectamos una de las puntas
del osciloscopio a la entrada de datos de la placa conversora:
La trama enviada es correcta y si vemos con atención se ve claramente que la trama esta
invertda y esto se debe a detalles constructvos de la placa conversora ya que esta espera los
bits de esta forma debido a que cuando la línea esta inactva se mantene en un voltaje alto y
esto causa recalentamiento a la placa. En el momento de diseño de la placa conversora
21
quienes la realizaron optaron por esta opción para tener la línea baja cuando esta está
inactva. En lo que respecta a nuestra solución tuvimos que tener en cuesta este dato y
simplemente invertr o negar cada bit antes de ser enviado. La trama tene su bit de comienzo
sus 16 bits de datos y los dos bits de parada lo cual es correcto
Prueba 4: Envío de un comando broadcast.
Se envió un comando broadcast a las luminarias estableciendo todas las luminarias a su
máximo nivel y luego a su mínimo nivel verifcando su correcto funcionamiento. Nos
aseguramos así la correcta comunicación entre luminarias y control central.
Prueba 5: Enviar escenas
Se enviaron escenas pre confguradas y notamos que las luminarias respondían correctamente
en los casos en donde se comunicaba con una luminaria en partcular no así para cuando se
comunicaba a los grupos.
Se procedió entonces a verifcar el correcto funcionamiento de estos comandos dejando ajeno
nuestro controlador comunicándonos mediante el Gatetay PC-Driver. No se pudo hacer
funcionar correctamente el establecimiento de escenas por este medio tampoco, por lo que se
confguraron en cada una de las escenas con luminarias independientes.
De todas maneras, pasamos a verifcar el correcto entramado de los comandos de grupo
mediante osciloscopio. Obteniendo los resultados esperados.
Por más que fnalmente no utlizamos los grupos para la comunicación en este proyecto, se
dejó formada la función necesaria para ello.
Conexionado de balastos y lámparas
22
Confguración las direcciones con Gateway PC-DALI
23
Direcciones confguradas
Las escenas previamente programadas fueron
EscenaBotón
asociadoIntensidad por
luminarias
Clase 1Escenario: 70%Butacas: 100%
Proyección
2Escenario centro: 0%
Escenario lateral: 40%
Escenario 3 Escenario: 80%
Apagado 4Escenario: 0%Butacas: 0%
Escena “Clase”: Botón 1
En esta escena las luces del escenario deben ir al 70% de su valor máximo y las luces de
butacas al 100%.
24
Botón 1: Escena Clase
25
Escena Clase
Escena “Proyección”: Botón 2
En esta escena las lámparas de escenario central deben ir 0% y las lámparas de escenario
lateral al 40%.
Botón 2: Escena Proyectar
26
Escena Proyectar
27
Escena “Escenario”: Botón 3
En esta escena las lámparas del escenario (centro y lateral) deben ir al 80% de su valor máximo
de intensidad. En DALI está previsto que los balastos manejen diferentes rangos de valores
dentro de valores mínimos y máximos, estos mínimos y máximos son confgurables para cada
balasto por lo que cuando enviamos la orden de que deben ir al 80% de su valor máximo la
intensidad obtenida en cada balasto no necesariamente es la misma como se puede ver en la
fgura:
28
Botón 3: Escena Escenario
Escena Escenario
29
Escena “Apagar”: Botón 4
En esta escena todas las luces se deben ir al 0%:
Escena Apagar
30
Botón 4: Escena Apagar
7. Conclusiones
Se logró cumplir con los objetvos planteados de acuerdo al alcance del proyecto y los
conocimientos adquiridos durante el curso. Si bien no es una implementación total de
estándar DALI resuelve el principal problema que sería la codifcación en Manchester,
luego debimos lograr cierta abstracción para que grupos futuros de trabajo puedan
seguir mejorando esta primera aproximación. En partcular se logró abstracción para
defnir escenas y además quedo previsto que se pueda usar otro tpo de placa
conversora que se pueda adquirir en el mercado o fabricar que sea compatble con
DALI ya que se puede seleccionar mediante softare si se va a usar una placa que
espera los datos invertdos o no.
Como trabajo a futuro por este grupo u otro restaría implementar dentro del módulo
DALI la recepción de datos enviados por los balastos y contnuar investgando lo
referido a las direcciones de grupo además de implementar los comandos DALI que se
requieran.
Si bien es una solución acotada, utlizando este mismo microcontrolador hay pines
disponibles para futuras ampliaciones o mejoras.
31
8. Referencias
Hoja de datos del microcontrolador MSP430g2553:
http://ttt.t.com/lit/ds/symlink/msp430g2553.pdf
Manuales protocolo DALI:
http://ttt.lightng.philips.com/main/subsites/dynalite/library_support/
technical_support/useful_informaton/dali_introducton.tpd
Draf DALI de IEC: DALI Spec 01-2000.pdf
https://goo.gl/AtUJoc
USB - DALI master using the LPC2141:
http://www.nxp.com/documents/applicaton_note/AN10660.pdf
9. Anexo:
Conceptos del curso aplicados al proyecto
Como se comentó previamente se eligió como arquitectura del proyecto Round Robin con
interrupciones atendiendo a la solicitud de que sea un código sencillo y fácil de entender.
Por más que no era requerimiento el disminuir la potencia consumida, entendimos que era
necesario que cuando no se estaba cambiando ninguna confguración el micro debería entrar
en modo de bajo consumo lot_poter_mode_0.
La aplicaron conceptos de programación modular y se logró la mayor abstracción en cada uno
de ellos en partcular en el módulo de escenas con el fn de confgurar las mismas fácilmente.
GPIO y Timers: de acuerdo a lo estudiado en clase y la hoja de datos del MSP430g2553 se
confguraron las entradas y salidas de propósito general y los Timers A0 y A1 para las bases de
tempos necesarias.
Además se debió desoldar el reloj externo por las razones mencionadas a lo largo de este
trabajo.
32
Especifcación fnal
Proyecto
Sistemas Embebidos Para Tiempo Real
Entrega fnal
CTRL-DALI
Controlador de luminarias por protocolo DALI (Digital Addressable
Lighting Interface) para salnn de actos de Facultad de Ingenieraa
1. Integrantes: Bruno Inuggi, Rodrigo Pérez, Federico Pugliese.
2. Tutores: Mauricio González y Javier Schandy.
3. Descripción del problema a resolver:
Se busca mejorar la iluminación del salón de actos y facilitar el cambio de iluminación entre las
diferentes modalidades de uso.
4. Antecedentes: Protocolo DALI detallado en el estándar IEC 62386.
Controlador DALI en FPGA Cyclone III EP3C16 (kit de desarrollo DEO)4.
Placa conversora de capa fsica TTL a capa fsica DALI5.
5. Objetvos del proyecto:
Diseñar una aplicación en C para un microcontrolador, el cual realice funciones de
comunicación con luminarias independientes (o grupos de luminarias) y así cambiar su
intensidad de luz.
4 Proyecto de la asignatura Diseño Lógico II, Facultad de Ingeniería.
5 Proyecto referido por Sebastán Fernández.
33
El microcontrolador se comunica con codifcación Manchester hacia una placa conversora, la
cual convierte los niveles de tensión que manejan los balastos a niveles que maneja el
microcontrolador (3.3V). La placa conversora se conecta a los balastos DALI y permite al
microcontrolador manejar los balastos. Esto permite funciones básicas como, por ejemplo,
variar la intensidad de iluminación.
A su vez, la interfaz humana consta con un sistema de botones, dimmers y LEDs para el manejo
de las diferentes funciones.
6. Alcance del proyecto:
Se deberá realizar:
i. “Driver” de comunicación: módulo que convierte, a lenguaje DALI, la
información a mandar hacia las luminarias. ii. Lógica del sistema: inteligencia que permite la correcta interacción
entre las luminarias y el usuario. Dicha lógica establece escenas y toma
decisiones en función de los botones presionados o si se modifcan los
dimmers.
iii. Controlador de periféricos: módulo interfaz entre el usuario y el
sistema. Controla los LEDs y el pulsado de botones e informa de esto a
la lógica.
iv. Test general con hardtare a instalar.
Opcionalmente, según el avance logrado, se podrá construir una placa
conversora de TTL Manchester a DALI a medida para el proyecto.
6. Descripción de sistema:
Descripción funcional:
El usuario debe ser capaz de, mediante botones y llaves, establecer el nivel de luminosidad
deseado. Deben existr 4 escenas precargadas (APAGADO, PROYECCIÓN, CLASE e
ILUMINACIÓN GENERAL) que se seleccionan a través de un botón dedicado para cada una. En
la parte superior de cada botón, un LED indica la escena actual.
Por otro lado, será posible modifcar el estado de iluminación actual a través de llaves
bipolares. Dichas llaves permiten aumentar o disminuir la intensidad de luz de un grupo
específco de luminarias. Se cuenta con tres grupos de luminarias: butacas, escenario central y
escenario lateral.
34
Diagrama de Bloques:
En la siguiente fgura se ve un diagrama de bloques conceptual:
Bloques:
o Controlador Periféricos:
Este bloque tene como funcionalidades básicas las de capturar el botón
seleccionado y prender el led correspondiente, así como controlar al dimmer.
Además se comunica con el bloque Lógica del sistema, pasando como
parámetro el botón presionado o la posición de las llaves y ésta le devuelve el
LED a encender y procesará los datos.
o Lógica del sistema:
Será el bloque encargado de decidir qué acción tomar en función de si se
presionó un botón o se varió de posición las llaves. Además comunicará al
bloque control de periféricos qué led debe encender.
En función del botón presionado conformará la escena y enviará los datos de
la misma al bloque del driver DALI. La escena contará con información de las
35
luminarias a encender e intensidad. También tendrá funciones de consulta a
los diferentes balastos para conocer su estado y nivel actual de intensidad, y
recibirá del bloque DALI las respuestas de los balastos.
o Driver DALI
Conformará los mensajes a transmitr de acuerdo al protocolo DALI incluyendo
los bits de datos correspondientes a la escena y bit de parada. Además recibirá
la respuesta por parte de los balastos y extraerá los datos como dirección y
Byte de datos para pasarlos al bloque Lógica del Sistema.
8. Requerimientos y restricciones del sistemaa. Procesamiento y memoria:
Si tomamos como propuesta inicial el microcontrolador MSP430g25536, podemos
analizar lo siguiente:
RAM: Estmamos un consumo mínimo de memoria RAM (variables) ya que
sólo existrían variables relacionadas a las escenas, identfcadores de cada
grupo de balastos (3 grupos) y variables auxiliares.
FLASH: dado el alcance del proyecto y haciendo comparación con otros
proyectos similares, los 16 KB de MSP430g2553 son más que sufcientes.
RELOJ: Las tramas DALI se deben generar a 1200 bps. Como es necesario
codifcar en Manchester, el microcontrolador debe poder conmutar salidas
digitales y leer entradas digitales a 2400 bps o 2,4 kHz. Con el reloj de 32
kHz integrado en el “Launchpad” (plataforma de desarrollo para
MSP430g2553) es sufciente.
b. GPIO:
Se cuentan con 3 llaves bipolares, 4 botones, 4 leds y TX/RX para comunicación
DALI. En conclusión, se necesitan 16 pines digitales para comandar todos los
periféricos. El microcontrolador MSP430g2553 posee 2 puertos de 8 pines digitales
cada uno, por lo cual es sufciente.
6 Hoja de datos del microcontrolador MSP430g2553:
http://ttt.t.com/lit/ds/symlink/msp430g2553.pdf
36
9. Diseño preliminar: Plataforma de hardware: la plataforma contara con los componentes que se
ven en la siguiente fgura:
Microcontrolador MSP430g2553: master DALI donde se implementara el código C de
los diferentes bloques descriptos en el punto 7.
Conversor: ya se cuenta con el de otro proyecto de Fing, el conversor modifca la capa
fsica TTL Manchester (microcontrolador) a la forma de capa fsica de DALI.
37
Botones: serán necesarios 4 botones digitales para cambiar las escenas, no se cuenta
con dichos botones, serán adquiridos.
Llave bipolar – “dimmer”: se usarán para modifcar individualmente la intensidad de
cada grupo de luminarias.
Leds: serán necesarios 4 leds para indicar la escena seleccionada.
Balastos DALI: se cuenta con ellos. Las luminarias LED están adjuntas a los balastos.
Arquitectura de software: la Arquitectura de softare para el manejo de
interrupciones y procesos será Round Robin con interrupciones. Se llegó a dicha
conclusión de forma de simplifcar el diseño.
10. Planifcación:a. Estudio de protocolo DALI y defnición de comandos a utlizar (1 día).
b. Confeccionar la comunicación serial Manchester (10 días).
c. Implementar las funciones DALI para envío y recepción (8 días).
d. Pruebas con osciloscopio y PC (1 día).
e. Defnir las interfaces de bloque de periféricos y lógica (1 día).
f. Presentación del HITO.
g. Implementación del módulo de periféricos (7 días).
h. Implementación del módulo de lógica (6 días).
i. Conexionado de balastos, botones, leds y llaves (1 día).
j. Prueba general funcional del sistema (1 día).
Los días cuentan de corrido desde el lunes 4 de Mayo, estmando fnalizar el lunes 8 de Junio.
En caso que surjan errores y correcciones a últmo momento, hay todavía una semana restante
antes de la entrega fnal.
38
c. Planificación del proyecto
El proyecto se llevó a cabo en un mes, contado a partr de la presentación del proyecto el día 14 de mayo.
Se respetó el cronograma planteado en la especifcación fnal con algunas modifcaciones que resultaron del intercambio con Sebastán Fernández y nuestros tutores, se detallan a contnuación las horas dedicadas a cada tarea:
Tarea Horas
Estudio Protocolo DALI 6
Confguración TIMER A0 y A1 12
Módulo DALI (TX Manchester) 20
Defnición Modulo LEDS y Entradas 3
Confguración GPIO 3
Pruebas Modulo DALI con Osciloscopio 3
Modulo Lógica 4
Preparación HITO 1 4
Defnición Escenas 2
Modulo Escenas 16
Diseño y Construcción Hardtare 6
Conexionado y prueba fnal 11
Documentación 16
Preparación Defensa 6
39
Total 112
40
Código fuente
Mín.#include "io430g2553.h"#include "leds.h"#include "entradas.h"#include "tempo.h"#include "dali.h"#include "logica.h"
main(void){ // Stop tatchdog tmer to prevent tme out reset WDTCTL = WDTPW + WDTHOLD; initLed();//leds, dir initEntradas(); //Confgura puertos de entradas, lo/hi de los bottones y llaves. Limpia FIG deambos puertos init_BCS(); init_tmer_clock(); __enable_interrupt(); thile(1){ // __disable_interrupt(); logica(); //__enable_interrupt(); __lot_poter_mode_0(); } }
41
leds.h#defne LED1 0x10
#defne LED2 0x20
#defne LED3 0x04
#defne LED4 0x40
/*
initLed();
indica direcciones de los leds y con confgura como salidas
P1.4 led1
P1.5 led2
P2.2 led3
P1.6 led4
*/
void initLed();
/*
ledEncender(int e);
Recibe el led a encender.
Apaga todos los led si hubiera alguno prendido y prende el led "led".
En caso de led=0 apaga todos los leds.
*/
void ledEncender(int led);
leds.c#include "leds.h"#include "io430g2553.h"
void initLed(){ P1DIR |= LED1; P1DIR |= LED2; P2DIR |= LED3; P1DIR |= LED4; P1OUT &= ~(LED1 | LED2 | LED4); P2OUT &= ~(LED3);}void ledEncender(int led){ stitch(led){ case 0: //Apago todos los leds P1OUT &= ~(LED1 + LED2 + LED4); P2OUT &= ~(LED3);
42
break; case LED1: //Prendo unicamente led1 P1OUT &= ~(LED2 + LED4); P2OUT &= ~(LED3); P1OUT |= LED1; break; case LED2: //Prendo unicamente led2 P1OUT &= ~(LED1 + LED4); P2OUT &= ~(LED3); P1OUT |= LED2; break; case LED3: //Prendo unicamente led3 P1OUT &= ~(LED1 + LED2 + LED4); P2OUT |= LED3; break; case LED4: //Prendo unicamente led4 P1OUT &= ~(LED1 + LED2); P2OUT &= ~(LED3); P1OUT |= LED4; break;
}}
tempo.h
** * Proyecto * Proyecto Reloj * Modulo RTC * * tempo.h * El módulo realiza las funciones de controlar y ver el reloj. * * @version 1.0 * @author Rodrigo Pérez * @author Federico Pugliese * @author Bruno Inuggi * @date 31/03/2015 */
/*********************************************************** Funciones del modulo**********************************************************/ /** * Inicializa el tmer */void init_tmer_clock();
/** * Indica si ya pasaron los rebotes * @return 1 si pasaron los rebotes, 0 en otro caso
43
*/unsigned char rebotesEnd();
/** * Inicia la espera de rebotes */void rebotesStart();
/** * Función que inicia el tmer 1. * Recibe el tempo en múltplos de 31 us, para el cual el tmer debe contar. */void startTimer1(unsigned long tme);
/** * Función que para el tmer 1. */void stopTimer1();
/** * Función que inicializa el BCS+. */void init_BCS();
/** * Devuelve 1 si el tmer 1 está contando, sino 0 */char tmer_1_on();
/** * Delay de "delay" us, "delay" debe ser múltplo de 16 us para que sea exacto. Bloqueante. */void delayUS(unsigned long delay);
44
tempo.c
/*** Proyecto Reloj* Modulo RTC** Este modulo agrupa las funciones que controlan el reloj.** tempo.c* @version 1.0* @author Rodrigo Pérez* @author Federico Pugliese* @author Bruno Inuggi* @date 31/03/2015**/#include "io430g2553.h"#include "tempo.h"#include "entradas.h"#include "dali.h"
#defne TIEMPO_REBOTE 20 //En ms
statc void startTimer0();statc void stopTimer0();
statc unsigned int contMS, tempoTimer1; statc unsigned char botonValido, tmer1_on;statc unsigned long TIMER_US;
#pragma vector = TIMER0_A0_VECTOR__interrupt void isr_reloj(void){ //Entra cada 1ms contMS++; if(contMS >= TIEMPO_REBOTE){ botonValido = 1; contMS = 0; stopTimer0(); }}
#pragma vector = TIMER1_A0_VECTOR__interrupt void isr_reloj1(void){ //Entra cada 416 us TIMER_US += TIEMPO_US_INT; if(TIMER_US >= tempoTimer1){ TX_enable(); TIMER_US = 0; stopTimer1(); }}
void init_BCS(){
45
/* USER CODE START (secton: BCSplus_graceInit_prologue) */ /* User initalizaton code */ /* USER CODE END (secton: BCSplus_graceInit_prologue) */
/* * Basic Clock System Control 2 * * SELM_0 -- DCOCLK * DIVM_0 -- Divide by 1 * ~SELS -- DCOCLK * DIVS_0 -- Divide by 1 * ~DCOR -- DCO uses internal resistor * * Note: ~<BIT> indicates that <BIT> has value zero */ BCSCTL2 = SELM_0 | DIVM_0 | DIVS_0;
if (CALBC1_1MHZ != 0xFF) { /* Follot recommended fot. First, clear all DCOx and MODx bits. Then * apply net RSELx values. Finally, apply net DCOx and MODx bit values. */ DCOCTL = 0x00; BCSCTL1 = CALBC1_1MHZ; /* Set DCO to 1MHz */ DCOCTL = CALDCO_1MHZ; }
/* * Basic Clock System Control 1 * * XT2OFF -- Disable XT2CLK * ~XTS -- Lot Frequency * DIVA_0 -- Divide by 1 * * Note: ~XTS indicates that XTS has value zero */ BCSCTL1 |= XT2OFF | DIVA_0;
/* * Basic Clock System Control 3 * * XT2S_0 -- 0.4 - 1 MHz * LFXT1S_0 -- If XTS = 0, XT1 = 32768kHz Crystal ; If XTS = 1, XT1 = 0.4 - 1-MHz crystal or res-onator * XCAP_1 -- ~6 pF */ BCSCTL3 = XT2S_0 | LFXT1S_0 | XCAP_1;}
void init_tmer_clock(){ contMS = 0; botonValido = 1; TIMER_US = 0;
46
//******* TIMER A0 ****** TA0CCTL0 = CM_0 | CCIS_0 | OUTMOD_0 | CCIE; //Compare, sin divisor, sin output TA0CCR0 = 999; //Interrumpe cada 1 ms TA0CTL = TASSEL_2 | ID_0; //Apagado, sin divisor, SMCLK a 1MHz // ****** TIMER A1 ****** TA1CCTL0 = CM_0 | CCIS_0 | OUTMOD_0; //Compare, sin divisor, sin output TA1CCR0 = TIEMPO_US_INT - 1; //Interrumpe cada 416 us aprox TA1CTL = TASSEL_2 | ID_0 | MC_1;//Apagado, sin divisor, SMCLK }
statc void startTimer0(){ TA0CTL |= MC_1; //Prendemos el tmer en modo up botonValido = 0;}
statc void stopTimer0(){ TA0CTL &= ~MC_1; //Apagamos el tmer TA0R = 0; //Reset del contador contMS = 0;}
unsigned char rebotesEnd(){ return botonValido;}
void rebotesStart(){ if(botonValido){ startTimer0(); }}
void startTimer1(unsigned long tme){ if(!tmer1_on){ TIMER_US = 0; tmer1_on = 1; tempoTimer1 = tme; TA1CCTL0 = CM_0 | CCIS_0 | OUTMOD_0 | CCIE; //Prendemos el tmer en modo up }}
void stopTimer1(){ tmer1_on = 0; TA1CCTL0 &= ~CCIE; //Apagamos int del tmer 1 TIMER_US = 0; //Reset del contador de us TA1R = 0; //Reset del contador}
char tmer_1_on(){ return tmer1_on;}
47
void delayUS(unsigned long delay){ startTimer1(delay); thile(tmer_1_on()); //Bloquea hasta que se appague el tmer 1}
entradas.h
#include "io430g2553.h"
#defne BOTON1 0x0001#defne BOTON2 0x0002#defne BOTON3 0x0003#defne BOTON4 0x0004
#defne DIM_UP 0x0011#defne DIM_DOWN 0x0010#defne SET_ESCENA 0x0012
#defne BOTON1_PORT 0x0001#defne BOTON2_PORT 0x0002#defne BOTON3_PORT 0x0004#defne BOTON4_PORT 0x0008
#defne LLAVE1UP_PORT 0x0001#defne LLAVE1DOWN_PORT 0x0002
#defne TX_PIN_PORT 0x0040#defne RX_PIN_PORT 0x0080
#defne TX_PIN P2OUT_bit.P6
#defne TIPO_PCB_FISICA INVERSORA //NO_INVERSORA#defne INVERSORA 1#defne NO_INVERSORA 0
//extern char dimmer;
/*initEntradas ();Indica direcciones de los botones y las llavesLimpia IFG
P1.0 boton1P1.1 boton2P1.2 boton3P1.3 boton4
48
P2.0 llave1 upP2.1 llave1 dotn
P2.6 TxP2.7 Rx
*/void initEntradas();
/*botonPresionado();Devuelve el número de boton si hubo un botón presionado, sino devuelve 0*/int botonPresionado();
/*liberarBoton();Función que se llama luego de procesar un botón presionado*/void liberarBoton();
/*getPortState(char puerto)Función que deuelve 0 si en el "puerto" no hay ningun boton appretado. Sino != 0.*/char getPortState(unsigned char puerto);
Entradas.c
#include "entradas.h"
#include "tempo.h"
#include "io430g2553.h"
#include "logica.h"
//extern char escena;
statc int boton;
void initEntradas(){
//Confguro XIN y XOUT como GPIO
P2SEL &= ~(RX_PIN_PORT + TX_PIN_PORT);
//Confguro TX y RX
49
P2DIR |= TX_PIN_PORT;
P2DIR &= ~RX_PIN_PORT;
// Pongo los botones como entradas
P1DIR &= ~BOTON1_PORT;
P1DIR &= ~BOTON2_PORT;
P1DIR &= ~BOTON3_PORT;
P1DIR &= ~BOTON4_PORT;
P2DIR &= ~LLAVE1UP_PORT;
P2DIR &= ~LLAVE1DOWN_PORT;
//Actvo resistencia de pull-up/pull dotn en pines de botones
P1REN |= BOTON1_PORT;
P1REN |= BOTON2_PORT;
P1REN |= BOTON3_PORT;
P1REN |= BOTON4_PORT;
P2REN |= LLAVE1UP_PORT;
P2REN |= LLAVE1DOWN_PORT;
P2REN |= RX_PIN_PORT;
//Pongo pull-up en botones
P1OUT |= BOTON1_PORT;
P1OUT |= BOTON2_PORT;
P1OUT |= BOTON3_PORT;
P1OUT |= BOTON4_PORT;
P2OUT |= LLAVE1UP_PORT;
P2OUT |= LLAVE1DOWN_PORT;
P2OUT |= RX_PIN_PORT;
// Actvo interrupciones de subida de botones y reseteo fags
P1IE|= BOTON1_PORT;
P1IE|= BOTON2_PORT;
P1IE|= BOTON3_PORT;
P1IE|= BOTON4_PORT;
P1IES = 0xFF; //high to lot
P1IFG &= ~(BOTON1_PORT + BOTON2_PORT + BOTON3_PORT + BOTON4_PORT);
P2IE|= LLAVE1UP_PORT;
P2IE|= LLAVE1DOWN_PORT;
//P2IE |= RX_PIN_PORT;
if(TIPO_PCB_FISICA == INVERSORA){
P2IES = 0x7F;
}
else{
P2IES = 0xFF;
50
}
P2IFG &= ~(LLAVE1UP_PORT + LLAVE1DOWN_PORT + RX_PIN_PORT);
if(TIPO_PCB_FISICA == INVERSORA){
TX_PIN = 0; //Línea de Tx alta cuando no se transmite
}
else{
TX_PIN = 1; //Línea de Tx alta cuando no se transmite
}
}
int botonPresionado(){
return boton;
}
void liberarBoton(){
boton = 0;
}
// Rutna de interrupcion de los bottones (P1)
#pragma vector=PORT1_VECTOR
__interrupt void Port_1(){
char P1IFG_aux;
//Pongo escena en su correspondiente valor y limpio fag P1IFG correspondiente a esta
interrupcion.
if(rebotesEnd()){
P1IFG_aux = P1IFG;
P1IFG_aux &= 0x0F; //Me quedo solo con los botones
if(P1IFG_aux){
rebotesStart();
}
stitch(P1IFG_aux){
case BOTON1_PORT:
boton = BOTON1;
P1IFG &= ~BOTON1_PORT;
break;
case BOTON2_PORT:
boton = BOTON2;
P1IFG &= ~BOTON2_PORT;
break;
case BOTON3_PORT:
boton = BOTON3;
P1IFG &= ~BOTON3_PORT;
break;
case BOTON4_PORT:
boton = BOTON4;
P1IFG &= ~BOTON4_PORT;
51
break;
default:
boton = 0;
P1IFG = 0;
break;
}
}
__lot_poter_mode_of_on_exit();
}
// Rutna de interrupcion de las llaves (P2)
#pragma vector=PORT2_VECTOR
__interrupt void Port_2(void){
char P2IFG_aux;
//Pongo boton en su correspondiente valor y limpio fag P2IFG correspondiente a esta
interrupcion.
if(rebotesEnd()){
P2IFG_aux = P2IFG;
P2IFG_aux &= 0x3F;
if(P2IFG_aux){
rebotesStart();
}
stitch(P2IFG){
case LLAVE1UP_PORT:
boton = DIM_UP;
P2IFG &= ~LLAVE1UP_PORT;
break;
case LLAVE1DOWN_PORT:
boton = DIM_DOWN;
P2IFG &= ~LLAVE1DOWN_PORT;
break;
default:
boton = 0;
P2IFG = 0;
break;
}
}
__lot_poter_mode_of_on_exit();
}
char getPortState(unsigned char puerto){
if(puerto == PORT_1){
puerto = ~P1IN;
puerto &= 0x0F;
52
}
else{
puerto = ~P2IN;
puerto &= 0x03;
}
return puerto;
}
53
logica.h/*** Modulo Logica del sistema * Determina en funcion de que boton fue presionado que escena se debe seleccionar* en funcion de la escena selecciona el comando correspondiente y llama a la funciones para enviar en el modulo manchester* Tambien determina en funcion del dimmer que balasto debe modifcar su intensidad*/
#defne PORT_1 1#defne PORT_2 2
#defne RETARDO_DIMMER 200000 //200 ms de retardo entre pasos de las llaves, en us.
/* Escenas-Los balastos DALI pueden almacenar hasta 16 escenas, en nuestro proyecto solo usamos 4 Para las escenas se setea como valor de intensidad (arc poter) el valor guardado en el balasto para dicha escenausando el valor de fade actualSi el balasto no pertenece a la escena, la intensidad permanece incambiadaSi la lampara esta apagada, se enciende*/#defne ILUMINACION_GENERAL 0x10000 //escena 0 ILUMINACION GENERAL#defne CLASE 0x10001 // escena 1 DAR CLASE #defne PROYECCION 0x10002 // escena 2 PROYECCION#defne APAGADO 0x10003 // escena 3 APAGADO
/*logica()Función que ejecuta las acciones necesarias a partr de estmulos externos*/void logica();
logica.c#include "logica.h"#include "entradas.h"#include "leds.h"#include "dali.h"#include "escenas.h"#include "tempo.h"
statc int boton;
void dimmer(int boton); //Procesa el appretado de una llave
void logica(){ boton = botonPresionado(); stitch(boton){ case (BOTON1): setEscena(SET_ESCENA, 1);
54
liberarBoton(); break; case BOTON2: setEscena(SET_ESCENA, 2); liberarBoton(); break; case BOTON3: setEscena(SET_ESCENA, 3); liberarBoton(); break; case BOTON4: setEscena(SET_ESCENA, 4); liberarBoton(); break; default: dimmer(boton); }}
void dimmer(int boton){ char port2; thile(getPortState(PORT_2)){ port2 = getPortState(PORT_2); if(port2 & LLAVE1UP_PORT){ setEscena(DIM_UP, 0); } if(port2 & LLAVE1DOWN_PORT){ setEscena(DIM_DOWN, 0); } delayUS(RETARDO_DIMMER); } liberarBoton();}
escenas.h// Defnicion de comandos de direct ARC POWER CONTROL#defne DIRECT_ARC_POWER 1#defne OFF 0x00 // MIN_LEVEL#defne MAX_LEVEL 0xFE // MAX_LEVEL#defne SETENTAYCINCO 0xF4 // poter level al 75% #defne CINCUENTA 0xE5 // poter level al 50%#defne CUARENTAYCINCO 0xE1//poter level al 45%#defne TREINTA 0xD2 // enciende al 30%
// Defnicion de comandos de indirect ARC POWER CONTROL#defne INDIRECT_ARC_POWER 0#defne UP 0x01 // dim UP de 200ms usando el FADE RATE seleccionado#defne DOWN 0x02 // dim DOWN de 200ms usando el FADE RATE seleccionado#defne STEP_DOWN_AND_OFF 0x07 // baja la intensidad un paso sin fade y si el balasto esta en el minimo se apaga
55
#defne ON_AND_STEP_UP 0x08 // sube la intensidad un paso sin fade y si esta apagada la enciende al nivel minimo
// Direcciones individuales #defne Escenario_Centro 0x0A#defne Escenario_Lateral 0x02#defne Butacas_Front 0x03#defne Butacas_Rear 0x04
// Direcciones de Grupo#defne ESCENARIO 0x01 //Escenario_Centro & Escenario_Lateral#defne BUTACAS 0x02 //Butacas_Front & Butacas_Rear#defne BROADCAST 0xFF // direccion de broadcast
void setEscena(int tpoComando, char numEscena);
char getEscenaActual();
escenas.c#include "escenas.h"#include "dali.h"#include "leds.h"#include "entradas.h"#include "stdint.h"
#defne MAX_CANT_ADDRESS 24
struct escenas{ char largo; char esGrupo[MAX_CANT_ADDRESS]; uint8_t address[MAX_CANT_ADDRESS]; char dimerizable[MAX_CANT_ADDRESS]; uint8_t value[MAX_CANT_ADDRESS];}
/************************************************************************//* DEFINICIÓN DE ESCENAS Se dispone de 4 escenas con parámetros modifcables: escenaX = {cantdad de direcciones, son dir de grupo?, grupos o direcciones, son dimerizables?, niveles} ******NO ES POSIBLE DIRECCIONAR MÁS DE 24 ADDRESSES (DE GRUPO O INDIVIDUAL)*******/
/* Clase, grupo 1 al 75% y grupo 2 al 100% */ escena1 = {4, {0, 0, 0, 0}, {Escenario_Centro, Escenario_Lateral, Butacas_Front, Butacas_Rear}, {1, 1, 1, 1}, {SETENTAYCINCO, SETENTAYCINCO, MAX_LEVEL, MAX_LEVEL}}, /* Proyector, luminaria 1 apagada (no dimerizable) y luminaria 2 al 40% */ escena2 = {2, {0, 0}, {Escenario_Centro, Escenario_Lateral}, {0, 1}, {OFF, CUARENTAYCINCO}},
56
/* Escenario, grupo 1 al 75% */ escena3 = {2, {0, 0}, {Escenario_Centro, Escenario_Lateral}, {1, 1}, {SETENTAYCINCO, SETENTAYCINCO}}, /* Apagado, todas las luces apagadas */ escena4 = {4, {0, 0, 0, 0}, {Escenario_Centro, Escenario_Lateral, Butacas_Front, Butacas_Rear}, {1, 1, 1, 1}, {OFF, OFF, OFF, OFF}};
/******************************************************************************/
statc char escenaActual;
void setEscena(int tpoComando, char numEscena){ int i; char aux; if((tpoComando == DIM_UP )|| (tpoComando == DIM_DOWN)){ aux = (tpoComando == DIM_UP) ? ON_AND_STEP_UP : STEP_DOWN_AND_OFF; stitch(escenaActual){ case 1: for(i = 0; i < escena1.largo; i++){ if(escena1.dimerizable[i]){ if(escena1.esGrupo[i]){ enviarComGrupoDALI(escena1.address[i], INDIRECT_ARC_POWER, aux); } else{ enviarComLumDALI(escena1.address[i], INDIRECT_ARC_POWER, aux); } } if(i == 0){ if(escena1.dimerizable[i]){ if(escena1.esGrupo[i]){ enviarComGrupoDALI(escena1.address[i], INDIRECT_ARC_POWER, aux); } else{ enviarComLumDALI(escena1.address[i], INDIRECT_ARC_POWER, aux); } } } } break; case 2: for(i = 0; i < escena2.largo; i++){ if(escena2.dimerizable[i]){ if(escena2.esGrupo[i]){ enviarComGrupoDALI(escena2.address[i], INDIRECT_ARC_POWER, aux); } else{ enviarComLumDALI(escena2.address[i], INDIRECT_ARC_POWER, aux); }
57
} if(i == 0){ if(escena2.dimerizable[i]){ if(escena2.esGrupo[i]){ enviarComGrupoDALI(escena2.address[i], INDIRECT_ARC_POWER, aux); } else{ enviarComLumDALI(escena2.address[i], INDIRECT_ARC_POWER, aux); } } } } break; case 3: for(i = 0; i < escena3.largo; i++){ if(escena3.dimerizable[i]){ if(escena3.esGrupo[i]){ enviarComGrupoDALI(escena3.address[i], INDIRECT_ARC_POWER, aux); } else{ enviarComLumDALI(escena3.address[i], INDIRECT_ARC_POWER, aux); } } if(i == 0){ if(escena3.dimerizable[i]){ if(escena3.esGrupo[i]){ enviarComGrupoDALI(escena3.address[i], INDIRECT_ARC_POWER, aux); } else{ enviarComLumDALI(escena3.address[i], INDIRECT_ARC_POWER, aux); } } } } break; case 4: for(i = 0; i < escena4.largo; i++){ if(escena4.dimerizable[i]){ if(escena4.esGrupo[i]){ enviarComGrupoDALI(escena4.address[i], INDIRECT_ARC_POWER, aux); } else{ enviarComLumDALI(escena4.address[i], INDIRECT_ARC_POWER, aux); } } if(i == 0){ if(escena4.dimerizable[i]){ if(escena4.esGrupo[i]){ enviarComGrupoDALI(escena4.address[i], INDIRECT_ARC_POWER, aux); } else{ enviarComLumDALI(escena4.address[i], INDIRECT_ARC_POWER, aux);
58
} } } } break; } } else{ escenaActual = numEscena; stitch(escenaActual){ case 1: ledEncender(LED1); for(i = 0; i < escena1.largo; i++){ if(escena1.esGrupo[i]){ enviarComGrupoDALI(escena1.address[i], DIRECT_ARC_POWER, escena1.value[i]); } else{ enviarComLumDALI(escena1.address[i], DIRECT_ARC_POWER, escena1.value[i]); } if(i == 0){ if(escena1.esGrupo[i]){ enviarComGrupoDALI(escena1.address[i], DIRECT_ARC_POWER, escena1.value[i]); } else{ enviarComLumDALI(escena1.address[i], DIRECT_ARC_POWER, escena1.value[i]); } } } break; case 2: ledEncender(LED2); for(i = 0; i < escena2.largo; i++){ if(escena2.esGrupo[i]){ enviarComGrupoDALI(escena2.address[i], DIRECT_ARC_POWER, escena2.value[i]); } else{ enviarComLumDALI(escena2.address[i], DIRECT_ARC_POWER, escena2.value[i]); } if(i == 0){ if(escena2.esGrupo[i]){ enviarComGrupoDALI(escena2.address[i], DIRECT_ARC_POWER, escena2.value[i]); } else{ enviarComLumDALI(escena2.address[i], DIRECT_ARC_POWER, escena2.value[i]); } } } break; case 3: ledEncender(LED3); for(i = 0; i < escena3.largo; i++){ if(escena3.esGrupo[i]){
59
enviarComGrupoDALI(escena3.address[i], DIRECT_ARC_POWER, escena3.value[i]); } else{ enviarComLumDALI(escena3.address[i], DIRECT_ARC_POWER, escena3.value[i]); } if(i == 0){ if(escena3.esGrupo[i]){ enviarComGrupoDALI(escena3.address[i], DIRECT_ARC_POWER, escena3.value[i]); } else{ enviarComLumDALI(escena3.address[i], DIRECT_ARC_POWER, escena3.value[i]); } } } break; case 4: ledEncender(LED4); for(i = 0; i < escena4.largo; i++){ if(escena4.esGrupo[i]){ enviarComGrupoDALI(escena4.address[i], DIRECT_ARC_POWER, escena4.value[i]); } else{ enviarComLumDALI(escena4.address[i], DIRECT_ARC_POWER, escena4.value[i]); } if(i == 0){ if(escena4.esGrupo[i]){ enviarComGrupoDALI(escena4.address[i], DIRECT_ARC_POWER, escena4.value[i]); } else{ enviarComLumDALI(escena4.address[i], DIRECT_ARC_POWER, escena4.value[i]); } } } break; } } }
char getEscenaActual(){ return escenaActual;}
dali.h#include "stdint.h"
#defne TIEMPO_US_INT 416-100 //100 de error en tempo por procesamiento de programa
/*TX_manchester(uint16_t comando)Envia por el pin TX los datos*/char TX_manchester(uint16_t comando);
60
/*TX_enable()Habilita transmisión*/void TX_enable();
/*TX_disable()Deshabilita transmisión*/void TX_disable();
/*enviarComGrupoDALI(uint8_t address, uint8_t comando, uint8_t valor)Manda un comando DALI a un grupo de luminarias
grupo: número de grupo (0 - 15)comando: DIRECT_ARC_POWER o INDIRECT_ARC_POWERvalor: si es directo -> valor de luminosidad, si es indirecto -> comando*/void enviarComGrupoDALI(uint8_t address, uint8_t comando, uint8_t valor);
/*enviarComLumDALI(uint8_t address, uint8_t comando, uint8_t valor)Manda un comando DALI a una luminaria
address: número de luminaria (0 - 63)comando: DIRECT_ARC_POWER o INDIRECT_ARC_POWERvalor: si es directo -> valor de luminosidad, si es indirecto -> comando*/void enviarComLumDALI(uint8_t address, uint8_t comando, uint8_t valor);
/*char TX_OK()Devuelve si es posible transmitr.*/char TX_OK();
dali.c#include "io430g2553.h"#include "tempo.h"#include "dali.h"#include "entradas.h"#include "logica.h"#include "stdint.h"#include "escenas.h"
#defne DELAY_BIT_US TIEMPO_US_INT //1 ciclo equivale a 1 microsegundo para 1MHz#defne MIN_TIEMPO_TRAMA 22*DELAY_BIT_US //En us
61
#defne CERO TIPO_PCB_FISICA#defne UNO ~TIPO_PCB_FISICA
statc char puedoTransmitr = 1;
char TX_manchester(uint16_t comando){ statc uint16_t comNegado, masc; if(!puedoTransmitr){ return 0; } comNegado = ~comando; //Mando bit de start TX_PIN = CERO;
startTimer1(DELAY_BIT_US); thile(tmer_1_on()); //Bloquea hasta que se apague el tmer 1
TX_PIN = UNO;
startTimer1(DELAY_BIT_US); thile(tmer_1_on()); //Bloquea hasta que se apague el tmer 1 //Mando datos masc = 0x8000; for(int i = 0; i < 16; i++){ if((comNegado & masc) == 0){ TX_PIN = CERO; } else{ TX_PIN = UNO; }
startTimer1(DELAY_BIT_US); thile(tmer_1_on()); //Bloquea hasta que se apague el tmer 1
if((comando & masc) == 0){ TX_PIN = CERO; } else{ TX_PIN = UNO; }
startTimer1(DELAY_BIT_US); thile(tmer_1_on()); //Bloquea hasta que se appague el tmer 1
masc >>= 1; }
62
//Mando stop TX_PIN = UNO;
startTimer1(4*DELAY_BIT_US); thile(tmer_1_on()); //Bloquea hasta que se appague el tmer 1 TX_disable(); startTimer1(MIN_TIEMPO_TRAMA);
return 1; }
void TX_enable(){ puedoTransmitr = 1;}
void TX_disable(){ puedoTransmitr = 0;}
void enviarComGrupoDALI(uint8_t address, uint8_t comando, uint8_t valor){ uint8_t add; uint16_t aux; if(comando == DIRECT_ARC_POWER){ aux = 0x80; } else{ aux = 0x81; } if(address == BROADCAST){ aux |= 0xFE; } else{ add = (address & 0x0F); add <<= 1; aux |= add; // aux: 1-0-0-ADD(4bit)-S } aux <<= 8; aux |= valor; TX_manchester(aux); }
void enviarComLumDALI(uint8_t address, uint8_t comando, uint8_t valor){ uint8_t add; uint16_t aux; if(comando == DIRECT_ARC_POWER){ aux = 0x00; }
63
else{ aux = 0x01; } if(address == BROADCAST){ aux |= 0xFE; } else{ add = (address & 0x3F); add <<= 1; aux |= add; // aux: 0-ADD(6bit)-S } aux <<= 8; aux |= valor; thile(!puedoTransmitr); TX_manchester(aux); }
char TX_OK(){ return puedoTransmitr;}
64