implementación de un sistema de comunicaciones inalámbrico

PROYECTO FINAL DE CARRERA

Y MÁSTER TESIS

IMPLEMENTACIÓN DE UN SISTEMA

DE COMUNICACIONES INALÁMBRICO

CON LÓGICA RECONFIGURABLE

(IMPLEMENTATION OF A WIRELESS

COMMUNICATIONS SYSTEM

WITH RECONFIGURABLE LOGIC)

Estudios:

Ingeniería Electrónica y

Máster Universitario en Ingeniería Electrónica

Autor: Quinto Recio, Francisco José

Director: Moreno Aróstegui, Juan Manuel

Año: 2013

3Implementación de un sistema de comunicaciones inalámbrico con lógica reconfigurable

Francisco José Quinto Recio

Índice de contenido

1 Agradecimientos............................................................................................5

2 Resum del projecte........................................................................................6

3 Resumen del proyecto.....................................................................................7

4 Abstract......................................................................................................8

5 Lista de ilustraciones......................................................................................9

6 Lista de tablas.............................................................................................12

7 Glosario de términos.....................................................................................13

8 Introducción...............................................................................................14

9 Organización de la memoria............................................................................15

10 Objetivo del proyecto..................................................................................17

10.1 Componentes del sistema........................................................................17

10.2 Arquitectura del sistema.........................................................................19

11 Requisitos técnicos......................................................................................21

11.1 Hardware de instrumentación..................................................................21

11.2 Software de desarrollo...........................................................................24

12 Diseño e implementación..............................................................................27

12.1 Kit Avnet: Xilinx Spartan-3A Evaluation Kit...................................................28

12.1.1 Hardware Avnet..............................................................................28

12.1.2 Avnet programming utility (AvProg)......................................................33

12.2 Xilinx Platform Studio............................................................................44

12.2.1 Configuración de hardware................................................................46

12.2.2 Desarrollo del software....................................................................50

12.3 Kit Texas Instruments: eZ430-RF2500..........................................................53

12.3.1 Hardware Texas Instruments..............................................................54

12.3.2 Software MSP430............................................................................61

12.4 Configuración, control y monitorización del sistema.......................................69

12.4.1 Desarrollo, instalación y configuración del entorno...................................69

12.4.2 Control y monitorización...................................................................74



12.4.3 Comunicaciones.............................................................................81

13 Resultados................................................................................................85

14 Conclusiones.............................................................................................86

15 Ambientalización y sostenibilidad del PFC..........................................................87

16 Líneas de trabajo futuras..............................................................................88

17 Planificación.............................................................................................89

17.1 Diagrama de Gantt................................................................................91

17.2 Presupuesto........................................................................................92

18 Tabla de autoría de las ilustraciones.................................................................93

19 Referencias: Bibliografía / Consultas................................................................96

20 Anexo A: Código fuente...............................................................................101

20.1 Avnet FPGA........................................................................................101

20.2 MSP430............................................................................................126

20.3 Web................................................................................................141

21 Anexo B: Tutorial.......................................................................................198



1 Agradecimientos

Deseo dedicar este trabajo a mi familia, a mis amigas, a mis amigos, a todos los profesores

que he tenido a lo largo de mis años de estudio y en general a todas aquellas personas que me

han apoyado y animado a seguir, nunca ha sido fácil compaginar estudios con todo lo demás.

Gracias a todos por escuchar mis charlas técnico-electrónicas, son sólo unas pocas de todas

las que os quedan por aguantar.

Gracias por enseñarme todo aquello que he aprendido.

Gracias a todos por conseguir motivarme para que nunca deje de aprender.



2 Resum del projecteL'objectiu del projecte és el d'implementar, usant el microprocessador encastat MicroBlaze de

Xilinx i un mòdul de comunicacions eZ430-RF2500T de Texas Instruments, un sistema de

comunicacions sense fils que permeti construir una xarxa de sensors distribuïts. Aquesta xarxa

de sensors es podrà supervisar mitjançant un equip basat en PC.

Per això s'ha creat un programari que modela la FPGA com softCPU (MicroBlaze), perquè

suporti un RTOS (μC/OS-II), sobre el qual s'han programat les tasques que comuniquen amb el

mòdul de comunicacions que porta el xip MSP430.

S'ha creat així mateix un programari per al xip MSP430 que en funció d'un missatge que rep

via sèrie adopta una configuració o una altra, que són els anomenats comportaments en AP

(Access Point) o ED (End Device).

Tot el sistema es configura i monitoritza usant una interfície d'usuari web programada en

l'última tecnologia (HTML5 i CSS3). La missatgeria de tot el sistema és pròpia i s'ha creat per

aquest propòsit específic.

El sistema en conjunt s'ha desenvolupat i provat amb resultats satisfactoris no només en el

sistema operatiu requerit inicialment (Microsoft Windows) sinó que a més s'ha validat el seu

funcionament en GNU/Linux.



3 Resumen del proyectoEl objetivo del proyecto es el de implementar, usando el microprocesador encastado

MicroBlaze de Xilinx y un módulo de comunicaciones eZ430-RF2500T de Texas Instruments, un

sistema de comunicaciones inalámbrico que permita construir una red de sensores

distribuidos. Esta red de sensores se podrá supervisar mediante un host basado en PC.

Para ello se ha creado un software que modela la FPGA cómo softCPU (MicroBlaze), para que

soporte un RTOS (μC/OS-II), sobre el cuál se han programado las tareas que comunican con el

módulo de comunicaciones que lleva el chip MSP430.

Asimismo se ha creado un software para el chip MSP430 que en función de un mensaje que

recibe vía serie adopta una configuración u otra, que son los denominados comportamientos

en AP (Access Point) o ED (End Device).

Todo el sistema se configura y monitoriza usando una interfaz de usuario web programada en

la última tecnología (HTML5 y CSS3). La mensajería de todo el sistema es propia y se ha

creado para este propósito específico.

El sistema en su conjunto se ha desarrollado y probado con resultados satisfactorios no sólo

en el sistema operativo requerido inicialmente (Microsoft Windows) sino que además se ha

validado su funcionamiento en GNU/Linux.



4 AbstractThe goal of the project is to implement, using the Xilinx MicroBlaze microprocessor embedded

and a wireless communications module eZ430-RF2500T Texas Instruments system, that allows

building a distributed sensor network. This sensor network can be monitored with a PC-based

host.

This has been done by creating software that models the FPGA how softCPU (MicroBlaze), to

support an RTOS (μC/OS-II). On which tasks are scheduled to communicate with the

communication module which carries the chip MSP430.

I have developed software for the MSP430 chip according to a message received across serial

interface adopts one configuration or other, they are called AP (Access Point) or ED (End

Device).

The whole system is configured and monitored using a Web user interface programmed in the

latest technology (HTML5 and CSS3). The whole messaging system is special and has been

created for this specific purpose.

The whole system has been developed and successfully tested not only in the operating

system initially required (Microsoft Windows) but also its performance has been validated in

GNU/Linux.



5 Lista de ilustracionesSobre el índice de ilustraciones, la primera palabra de cada ilustración indica el tipo de la

misma basada en las siguientes opciones:

• Esquema

• Captura de pantalla

• Código

• Gráfico

• Fotografía

Índice de ilustraciones

Ilustración 1: Esquema simplificado del sistema.......................................................20

Ilustración 2: Fotografía del Xilinx Platform cable USB...............................................21

Ilustración 3: Fotografía del interior del Xilinx Platform cable USB................................22

Ilustración 4: Fotografía del analizador lógico Saleae Logic.........................................23

Ilustración 5: Fotografía de la placa de evaluación del kit de Avnet...............................28

Ilustración 6: Esquema de las características y del sistema de la placa Avnet....................29

Ilustración 7: Gráfico de bloques de la arquitectura..................................................30

Ilustración 8: Gráfico ubicación GPIOs y conector J6 escogido......................................31

Ilustración 9: Esquema señales módulos de expansión J6 y J7.......................................32

Ilustración 10: Captura de pantalla AvProg..............................................................34

Ilustración 11: Captura de pantalla del datasheet del Cypress CY8C24894-24LFXI...............35

Ilustración 12: Fotografía del kit Cypress PSoC modelo CY3217.....................................35

Ilustración 13: Captura de pantalla del momento que indica que debemos actualizar..........37

Ilustración 14: Captura de pantalla de actualización firmware del programador................38

Ilustración 15: Fotografía del PSoC MiniProg con indicación de las partes que lo integran.....39

Ilustración 16: Esquema conexiones PSoC MiniProg USB..............................................40

Ilustración 17: Esquema detallado de conexiones con indicación de versiones utilizadas......41

Ilustración 18: Captura de pantalla del ajuste del idioma del sistema.............................42



Ilustración 19: Captura de pantalla de la versión de XPS.............................................44

Ilustración 20: Captura de pantalla de la composición del hardware en la placa Avnet.........46

Ilustración 21: Captura de pantalla de la configuración de las interrupciones...................47

Ilustración 22: Captura de pantalla truncada del archivo system.ucf..............................48

Ilustración 23: Gráfico de bloques hardware...........................................................49

Ilustración 24: Gráfico de funciones del archivo application.c......................................51

Ilustración 25: Gráfico de funciones del archivo bsp.c................................................52

Ilustración 26: Fotografía que presenta el kit eZ430-RF2500........................................53

Ilustración 27: Esquema de componentes del kit eZ430-RF2500....................................53

Ilustración 28: Esquema de componentes internos del eZ430i-RF USB + eZ430-RF2500T.......54

Ilustración 29: Esquema de la arquitectura interna del MSP430F2274..............................54

Ilustración 30: Esquema de los puertos y señales de la placa eZ430-RF2500T....................56

Ilustración 31: Esquema electrónico de la placa eZ430-RF2500T....................................57

Ilustración 32: Esquema de la arquitectura interna del CC2500.....................................58

Ilustración 33: Esquema de la interconexión SPI entre el MSP430F2274 y el CC2500............59

Ilustración 34: Esquema de conexiones entre placa Avnet (FPGA) y eZ430-RF2500T............60

Ilustración 35: Fotografía de la implementación para test...........................................60

Ilustración 36: Captura de pantalla del About del Code Composer Studio.........................61

Ilustración 37: Captura de pantalla del aspecto del Code Composer...............................62

Ilustración 38: Gráfico de la estructura del programa MSP430......................................63

Ilustración 39: Gráfico de la estructura del programa MSP430 (librerías).........................64

Ilustración 40: Captura de pantalla sobre data-sheet del CC2500..................................65

Ilustración 41: Captura de pantalla sobre relación entre SimpliciTI y el CC2500.................66

Ilustración 42: Captura de pantalla de la topología y flujo de mensajes de SimpliciTI..........67

Ilustración 43: Captura de pantalla de capas SimpliciTI..............................................68

Ilustración 44: Gráfico de la arquitectura de la web..................................................69

Ilustración 45: Captura de pantalla del software WAMP..............................................70

Ilustración 46: Captura de pantalla del logo del lenguaje PHP......................................70

Ilustración 47: Captura de pantalla de código fuente HTML5 y PHP................................71

Ilustración 48: Captura de pantalla de código fuente Python........................................72

Ilustración 49: Captura de pantalla de código fuente AJAX y JSON.................................73



Ilustración 50: Gráfico del menú de la web.............................................................74

Ilustración 51: Captura de pantalla de la portada de la web........................................75

Ilustración 52: Captura de pantalla de la configuración AP..........................................76

Ilustración 53: Captura de pantalla del submenú AJAX Python......................................77

Ilustración 54: Captura de pantalla del control AJAX con imagen...................................78

Ilustración 55: Captura de pantalla del gráfico del AP................................................79

Ilustración 56: Captura de pantalla del gráfico del ED................................................79

Ilustración 57: Captura de pantalla de la parte de información de la web........................80

Ilustración 58: Gráfico de la mensajería del sistema..................................................82

Ilustración 59: Captura de pantalla del diagrama de Gantt..........................................91



6 Lista de tablas

Índice de tablas

Tabla 1: Versiones del software instalado según el sistema operativo..............................26

Tabla 2: Señales usadas del conector J6.................................................................32

Tabla 3: Versiones firmware Cypress PSoC con hash MD5.............................................36

Tabla 4: Tabla de señales del conector ISSP.............................................................41

Tabla 5: Versiones del kit Avnet, software y firmware................................................43

Tabla 6: Tabla de cabeceras de mensajería.............................................................81

Tabla 7: Tabla de mensajería del AP y del ED...........................................................83

Tabla 8: Tabla de ejemplos de mensajería desde Web y desde Putty...............................83

Tabla 9: Tabla de mensajería de la FPGA................................................................84

Tabla 10: Tabla de ejemplos de mensajes de la FPGA.................................................84

Tabla 11: Tabla estadística del código fuente...........................................................86

Tabla 12: Tabla de presupuesto del proyecto...........................................................92

Tabla 13: Autoría de las ilustraciones....................................................................95



7 Glosario de términos• UPC: Universitat Politècnica de Catalunya (Universidad Politécnica de Cataluña)

• ETSETB: Escola Tècnica Superior d'Enginyeria de Telecomunicació de Barcelona

• AP: Access Point (punto de acceso)

• ED: End Device (dispositivo final)

• LED: Light-Emitting Diode (diodo emisor de luz)

• WSN: Wireless Sensor Network (red de sensores inalámbricos)

• PHP: Personal Home Page (lenguaje de programación interpretado para creación de

webs)

• RTOS: Real Time Operating System (sistema operativo en tiempo real)

• OS: Operating System (sistema operativo)

• uCOSII: Siglas del RTOS micro C (lenguaje de programación) OS. En numeración romana

se ha indicado la versión 2 del RTOS, indicado con II. Para facilitar la escritura la letra

u se usa en lugar del símbolo µ (micro)

• C: lenguaje de programación

• SNMP: Simple Network Management Protocol (protocolo simple de gestión de red)

• FPGA: Field Programmable Gate Array

• EDK: Embedded Development Kit, kit de desarrollo integrado

• USB: Universal Serial Bus (bus serie universal)

• PC: Personal Computer (ordenador personal)

• PSoC: Programable System on Chip (sistema programable en un chip)

• RSSI: Receive Signal Strength Indication (Indicador de fuerza de señal de recepción)

• ISSP: In-System Serial Programmer (programación serie en el sistema)



8 IntroducciónEste documento es una memoria explicativa, también denominada “máster tesis”, y PFC

(Proyecto Final de Carrera) para alcanzar la doble titulación académica por parte del autor,

del segundo ciclo de Ingeniería Electrónica y el Máster Universitario en Ingeniería Electrónica,

ambas titulaciones impartidas por la UPC (Universidad Politécnica de Cataluña),

concretamente en la facultad ETSETB (Escola Tècnica Superior d'Enginyeria de

Telecomunicació de Barcelona).

La ETSETB y concretamente el “Departament d'Enginyeria Electrònica” hizo pública la síntesis

de ésta para que fuera desarrollada por algún alumno de la facultad. En este caso el alumno

elegido para este desarrollo, es el autor de este trabajo. Lo que aquí se expone tiene cómo

fin el aplicarlo en las prácticas y en la docencia en cursos próximos dentro de las asignaturas

del Máster Universitario en Ingeniería Electrónica.

El autor de este trabajo declara que es el único autor que ha realizado este trabajo en todas

y cada una de las partes de desarrollo e implementación.



9 Organización de la memoriaEl documento que ahora usted está leyendo consta de diversos capítulos. Estos capítulos

podrían agruparse en cinco partes fundamentales, más anexos aparte:

Presentación: Consiste en el capítulo de “Introducción”, “Organización de la memoria”, y el

capítulo “Objetivo del proyecto”. En ellos se explica la finalidad y lo que con el mismo se

pretende lograr.

Necesidades: “Requisitos técnicos” es el capítulo en el que se analizan con detalle todos y

cada uno de los requisitos técnicos para llevar a cabo el desarrollo del proyecto, objeto de

esta memoria. También, se relaciona todo el material necesario para el desarrollo así como el

software asociado.

Desarrollo: “Diseño e implementación” es el capítulo central. En el se contiene el núcleo de

la memoria, y en consecuencia se explica el trabajo fundamental. También se contiene en

dicho capítulo una explicación del software creado para cada uno de los componentes del

sistema.

Alcance: “Resultados” es el capítulo dónde se analizan los resultados obtenidos con el trabajo

realizado. También englobamos en este apartado las “Conclusiones” y un posible desarrollo

futuro o aplicaciones futuras en el capítulo de “Líneas de trabajo futuras”. Dentro de esta

parte hay un capítulo llamado “Planificación”, en el que se detalla el desarrollo realizado, y

otra relativa a los costes del mismo, llamado “Presupuesto”.

Material de consulta: Todas las consultas técnicas, referencias, bibliografía y tabla de autoría

se recogen en diversos capítulos en la parte final de la memoria.



Anexos: En la última parte se presenta el código fuente y el tutorial de instalación.



10 Objetivo del proyectoCómo esta “máster tesis” indica en su título, el objetivo es la implementación de un sistema

de comunicaciones inalámbrico con lógica reconfigurable, con el fin de que la

implementación sirva para el ámbito docente futuro en la universidad UPC, para la facultad

ETSETB, dentro del “Departament d'Enginyeria Electrònica”.

10.1 Componentes del sistemaComo nota previa, comentar que los componentes del sistema (hardware en inglés), vienen

impuestos inicialmente razón por la que éstos deben mantenerse. No se entrará en evaluación

o discusión del hardware más indicado o hardware más óptimo o el uso de hardware

alternativo diferente al requerido. También ocurre de forma similar lo anteriormente

expuesto en los programas o sistemas operativos usados (software en inglés).

El sistema consta de dos partes principales:

1. Kit de evaluación de la empresa Avnet, “Xilinx Spartan-3A Evaluation Kit” que

contiene:

1. Placa electrónica de evaluación: contiene una FPGA (Field Programmable Gate

Array, es decir, matriz de puertas programable) del fabricante Xilinx como pieza

principal, modelo Spartan. Contiene pulsadores capacitivos (controlados por un

chip marca Cypress), LED's indicadores, y conexión USB para PC.

2. Cypress MiniProg CY3217: Kit para programación del Cypress PSoC (Programable

System on Chip, Sistema programable en chip). Con documentación, software de

programación y cable USB incluido para el Cypress MiniProg.

3. Documentación, software y cable USB específico para la placa Avnet.

2. Kit de desarrollo de la empresa Texas Instruments, “eZ430-RF2500” que contiene:

1. Dos placas electrónicas eZ430-RF2500T: que a su vez constan de un



microcontrolador MSP430 y un chip de comunicaciones vía radio modelo CC2500,

cada una.

2. Una placa eZ430-RF USB como interfaz de depuración de código y programación.

Con puerto de conexión a la placa eZ430-RF2500T.

3. Un paquete de 2 baterías (pilas del tipo AAA) con placa de expansión conectora a

la placa eZ430-RF2500T.

4. Documentación y software.

1. Placa Avnet: es necesaria la programación de la FPGA Spartan de Xilinx mediante el

XPS (Xilinx Platform Studio), convirtiendo la FPGA en un microprocesador

encastado/integrado (embedded en inglés) que Xilinx denominado MicroBlaze. Sobre

este se sustenta el RTOS (“Real Time Operating System” en inglés y sistema operativo

en tiempo real en castellano) μC/OS-II (sistema operativo micro C versión 2) de la

empresa Micrium. Dicho sistema operativo también deberá adecuarse creando las

tareas necesarias. Lenguaje de programación en C.

En cuanto al desarrollo de software, lo podemos dividir en 3 partes:

2. Kit eZ430-RF2500: es necesario desarrollar el software para que implementen dos

comportamiento básicos cómo AP (“Access Point”, es decir punto de acceso) y cómo

ED (“End Device”, es decir dispositivo final). Lenguaje de programación en C.

3. Software para el control, la monitorización o supervisión de los nodos basado en web

para PC. Lenguaje de programación en PHP, Python, Javascript, HTML5, CSS3 y con

imágenes en SVG (vectoriales). Usando el software Notepad++ para ayudarnos a

programar todos los lenguajes anteriores indicados.



10.2 Arquitectura del sistemaUna de las placas del kit, eZ430-RF2500, la placa eZ430-RF2500T deberá comportarse como

AP y proporcionar datos o comunicarse de forma bidireccional mediante radio con otra placa

eZ430-RF2500T que estará comportándose como ED.

El software de PC configurará, controlará y supervisará los elementos del sistema desde la

placa eZ430-RF2500T en modo AP vía radio hacia la placa en modo ED. La placa en modo AP

estará conectada al PC mediante USB usando para ello la placa adaptadora eZ430-RF.

La placa en modo AP se comunicará vía radio con la placa ED. La placa en modo ED estará

conectada con la placa electrónica de Avnet físicamente a través de una conexión serie y

deberá comunicarse con ella mediante el RTOS μC/OS-II corriendo sobre microprocesador

MicroBlaze, ejecutándose sobre la FPGA Spartan de Xilinx.

La placa Avnet estará conectada, únicamente de forma opcional a un PC mediante USB para

una supervisión de la misma o para alimentarla, no como necesidad puesto que esta se puede

alimentar de forma externa.



A continuación un esquema simplificado del sistema:

Expandiendo el sistema en número de placas de Avnet conectadas al eZ430-RF2500T en modo

ED obtendríamos una red de sensores distribuida.

Ilustración 1: Esquema simplificado del sistema



11 Requisitos técnicosTenemos dos partes diferenciadas cómo requisitos técnicos para el desarrollo del sistema:

hardware de instrumentación por un lado y software de desarrollo por otro.

11.1 Hardware de instrumentación1. Xilinx Platform Cable USB, modelo DLC9G: cable USB del fabricante Xilinx, se usará

para la grabación y el debug (depuración de código) de la FPGA de Xilinx sobre la placa

de Avnet. Se escoge esta opción por ser la opción más rápida de programación y

depuración sobre la FPGA.

Este adaptador se conecta al PC usando un cable USB. El cable USB tiene en el

extremo que se conecta al PC, un conector USB tipo A macho y en el extremo que se

conectará al adaptador Xilinx tiene un conector USB tipo B macho. Es decir que el

adaptador posee un entrada USB hembra tipo B y un conector de 14 pins (agujas) que

irá hacia la placa Avnet.

Ilustración 2: Fotografía del Xilinx Platform cable USB



Indicar que existen diversos modelos de cables de programación de Xilinx y se escogió

este en función del sistema operativo (Microsoft Windows XP Professional en nuestro

caso) sobre el que se iba a usar para programar la FPGA y sobre la versión de ISE

(software de Xilinx) a usar, versión 12.3

La adquisición del producto se realizó mediante la intermediación prestada por el

portal web de Ebay (http://ebay.es). Se buscaba con ello localizar y obtener de forma

rápida, segura y económica el dispositivo mencionado. No obstante, hasta que no se

recibió la mercancía comprada no pudo observarse que el producto adquirido no era el

fabricado por Xilinx, sino que era un dispositivo fabricado en Hong Kong (China), por lo

que lo adquirido era un “clon” del Xilinx.

El dispositivo adquirido, pese a no ser el original deseado proporcionó los resultados

mínimos esperados: “programar y depurar la FPGA”. No obstante, no se recomienda en

absoluto el uso de dispositivos no originales y de dudosa calidad o hasta incluso de

dudoso origen.

Ilustración 3: Fotografía del interior del Xilinx Platform cable USB

http://ebay.es/



2. Analizador lógico de 8 canales Saleae Logic: es un analizador lógico, económico,

portátil, ligero y que funciona a través del puerto USB de un PC. Se usará para analizar

las señales lógicas programadas. No es un elemento necesario pero si muy

recomendable, útil y nos ha ayudado en determinados momentos del proyecto.

Ilustración 4: Fotografía del analizador lógico Saleae Logic



11.2 Software de desarrolloEl desarrollo se ha realizado con diversos sistemas operativos:

Sobre el sistema operativo Microsoft Windows XP Professional (SP3 de 32bits)

1. Xilinx ISE Design Suite v12.3 que contiene a su vez el EDK (Embedded Development

Kit, kit de desarrollo integrado) es un entorno de desarrollo para el diseño de sistemas

de procesamiento. Este kit incluye:

◦ Xilinx Platform Studio (XPS) Tool Suite

◦ Software Development Kit (SDK) for MicroBlaze and PowerPC

◦ Processing IP and MicroBlaze Soft Processor Core

Soportan RTOS (Real-Time Operating System, sistemas operativos en tiempo real) y

Embedded OS (Sistemas Operativos encastados). Además permiten agregar IP cores

(celdas de unidades lógicas llamadas núcleos de propiedad intelectual o IP cores en

inglés).

Principalmente el usado en este proyecto será el XPS: Xilinx Platform Studio y el SDK.

Este software junto con el Xilinx Platform cable USB nos permitirá programar, grabar y

depurar código sobre la FPGA de la placa Avnet. Existe una versión para GNU/Linux de

este paquete que, en nuestro caso, no hemos utilizado.

2. CCS: Code Composer Studio o también denominado CCStudio IDE (Integrated

Development Environment): para programar y realizar debug sobre el kit de TI, eZ430-

RF2500. El fabricante de este software es Texas Instruments. Servirá para programar

sobretodo el chip MSP430 del mismo fabricante. Está basado en Eclipse.

3. WAMP: siglas de Windows, Apache, MySQL, PHP, indica que es un paquete de software

libre que instala de forma automática un servidor web (Apache) con módulo de PHP,

junto con una base de datos MySQL, que en nuestro caso, no usaremos.



4. Python: librería de programación del lenguaje Python, más módulos o extensiones con

más funcionalidades agregadas.

5. Varios programas de desarrollo: como Tortoise, para control del repositorio de código

SVN, Subversion. Notepad++, para ajuste y desarrollo del código fuente. Mozilla

Firefox, como navegador web por defecto. Putty, para control de los dispositivos con

puerto serie. WinSCP para intercambio de ficheros entre diferentes sistemas

operativos.

Sobre el sistema operativo GNU/Linux (KUbuntu 32bits, escritorio KDE):

1. Apache: servidor web

2. PHP5: librerías instaladas junto al servidor web Apache

3. Python: librería de programación del lenguaje Python, más módulos o extensiones con

más funcionalidades agregadas.

4. Varios programas de desarrollo: GtkTerm, para control de dispositivos serie. Kate,

para ajuste y desarrollo del código fuente. Mozilla Firefox, como navegador web por

defecto.



Tabla 1: Versiones del software instalado según el sistema operativo



12 Diseño e implementaciónA continuación se explicarán en cuatro apartados las principales partes del diseño y su

implementación, dividiendo la explicación en parte hardware y en parte software.

Estas cuatro partes son:

• Kit Avnet (contiene la FPGA de Xilinx modelo Spartan-3A)

• Xilinx Platform Studio: Desarrollo hardware y software de la FPGA

• Desarrollo software del MSP430: Kit Texas Instruments (contiene el MSP430 cómo

dispositivo principal)

• Integración de los sistemas en web



12.1 Kit Avnet: Xilinx Spartan-3A Evaluation Kit

12.1.1 Hardware AvnetLa placa electrónica de evaluación está fabricada por la empresa Avnet que la suministra

dentro de un kit llamado “Avnet Spartan-3A Evaluation Kit” y bajo la referencia: AES-SP3A-

EVAL400-G.

Ilustración 5: Fotografía de la placa de evaluación del kit de Avnet



Nuestro principal objetivo en esta parte es el de conectarla con la placa del kit de la empresa

Texas Instruments, para ello observamos las características técnicas de la placa de Avnet y la

arquitectura de la misma.

En otra documentación (ilustración 7 de la siguiente página) encontramos un sistema de

bloques descriptivo de la arquitectura de la placa más detallado.

Durante diversos meses se estudió las distintas posibilidades de conexionado, visualizando las

características de la placa Avnet, que podrían hacerse entre ésta y el MSP430. Y se intentó un

conexionado usando el protocolo de comunicaciones SPI. Se consideró este tipo de

conexionado como el definitivo para conectar ambas. Este método supondría una

configuración más compleja en el lado de la placa del kit de TI eZ430-RF2500 y finalmente se

descartó.

La opción escogida finalmente fue la de realizar la comunicación mediante una UART

(Universal Asynchronous Receiver-Transmitter, en castellano Transmisor-Receptor Asíncrono

Ilustración 6: Esquema de las características y del sistema de la placa Avnet



Universal), es decir una comunicación serie. Con lo que únicamente necesitaremos usar dos

GPIOs (General Purpose Input/output, en castellano entrada/salida de propósito general). Un

GPIO configurado cómo entrada para recibir datos que llamaremos Rx (recepción) y otro

configurado cómo salida para enviar datos que llamaremos Tx (transmisión). Siendo ésta una

solución mucho más simple y ágilde implementar.

Ilustración 7: Gráfico de bloques de la arquitectura



Visualizando la placa veremos que podemos hacer uso de dos zonas de GPIOs: La primera con

un conector de 40 pins que consta de 35 GPIOs y la segunda zona de dos módulos de

expansión de 6 pins, de 4 GPIOs cada uno de los dos.

La opción escogida fue la de usar uno de los dos módulos de expansión, que son denominados

en inglés “expansion headers”. Cada módulo de expansión tiene 6 pins y han sido diseñados

para adaptar módulos de expansión que la empresa Digilent comercializa.

Ilustración 8: Gráfico ubicación GPIOs y conector J6 escogido



Según la documentación:

Se escogió esta opción porque únicamente necesitamos dos señales más, alimentación y

masa, porque además todo ello lo podemos conectar fácilmente en el conector J6, no

obstante, también hubiera podido usarse el J7.

Finalmente se usó la siguiente configuración:

Señal Valor

Vcc (alimentación) +3.3v

GND (masa) 0v

Rx (Recepción datos) DIGI2_1 (pin FPGA M1)

Tx (Transmisión datos) DIGI2_0 (pin FPGA N1)

Tabla 2: Señales usadas del conector J6

Ilustración 9: Esquema señales módulos de expansión J6 y J7



12.1.2 Avnet programming utility (AvProg)El fabricante Avnet propone, para programar la FPGA de la placa que se realice mediante el

uso del programa de grabación llamado “Avnet Board Programming Utility (AvProg)” que la

empresa proporciona en su kit.

Si deseamos que la placa arranque con un programa determinado antes será necesario grabar

el programa en la memoria de la placa usando el “Avnet Board Programming Utility (AvProg)”.

Los pasos básicos para ello son dos:

• En primer lugar, generaríamos el código de programación de la FPGA desde el XPS

(Xilinx Platform Studio) y produciríamos el archivo “download.bit”

• En segundo lugar, grabar o descargar en la placa Avnet el archivo creado

“download.bit” usando el AvProg (“Avnet Board Programming Utility”)

Todo ello mediante una conexión simple con cable USB.

Para realizar pruebas de grabación rápidas sobre la FPGA (sin tener la necesidad de grabarlo

en la memoria flash interna) es mucho más rápido usar la herramienta de Xilinx para grabar la

FPGA directamente usando el Platform Cable USB, utilizando el protocolo JTAG (Joint Test

Action Group, que una traducción literal seria “Prueba conjunta del Grupo de Acción”), que

suele ser el típico procedimiento usado para acceder a microprocesadores y

microcontroladores.



La versión final usada en el AvProg es la 4.0.5, pero en una de las actualizaciones del AvProg

hubo algún contratiempo, concretamente en la versión 3.41, que una vez actualizado, dejó

de funcionar mostrando el mensaje de error siguiente:

El mensaje indica que se ha detectado la versión 1.0.1 en el “PSoC Software”. Tuvimos que

descubrir que “PSoC Software” se refiere al firmware del Cypress PSoC y que según se indica

se necesita la versión 1.1.0.

Buscando más información sobre el dispositivo en el mismo datasheet de Avnet [1]

encontramos un pequeño error cuando normalmente se refiere al mismo cómo: CY8C24894-

QFN56 y en realidad es el modelo CY8C24894-24LFXI según se visualiza observando la placa.

Ilustración 10: Captura de pantalla AvProg



La indicación LFX se refiere a que se utiliza un formato QFN de 56 pins Pb-Free (sin plomo) y

este podría ser el origen de la confusión, ya que este seguro fue el “package” seleccionado.

Volviendo al mensaje de error anterior: necesitábamos la versión 1.1.0 que no sabíamos

dónde encontrar. Buscando por foros de la empresa Avnet en Internet, encontramos un

mensaje aclarador [2] que indicaba que el mismo firmware estaba en un directorio en la

actualización del AvProg. Con la ayuda del programador del “Cypress PSoC MiniProg CY3217”

que viene en el kit de Avnet conseguimos cargar el nuevo firmware, versión 1.1.0.

Ilustración 11: Captura de pantalla del datasheet del Cypress CY8C24894-24LFXI

Ilustración 12: Fotografía del kit Cypress PSoC modelo CY3217



Según leímos, en algunos casos, algunos clientes que se encontraron con el mismo problema,

se les agravó. No pudieron grabar el firmware hasta que no actualizaron primero el propio

firmware del kit grabador de la versión 1.73 a la versión 1.77.

En total tenemos 3 versiones diferentes del firmware del Cypress PSoC. En la siguiente tabla

indicamos, para facilitar la identificación y verificación de cada fichero, el hash en MD5.

Nombre Versión Hash MD5

Spartan3AEval_PSoC_Firmware_V101.hex 1.0.1 fffb9d4ea07d4fe7e365019ba6f33915

Spartan3AEval_PSoC_Rev102b_pd5sp45.hex 1.0.2b f11df0f1eac170e137e2ef9b0331a121

Spartan3AEval_PSoC_Rev110_pd5sp45.hex 1.1.0 acaf79e9291fce27ec519a46bebeeb58

Tabla 3: Versiones firmware Cypress PSoC con hash MD5

Sobre el software programador utilizado es el llamado “PSoC Programmer” y hemos utilizado

desde la versión 3.12.2 hasta la 3.13.4.1048. Dicho software instala un programa que

mantiene el software actualizado a las versiones que aparecen, y cabe destacar que suelen

aparecer versiones nuevas muy a menudo.



Concretamente para la versión 3.13.4.1048 el propio software indicó que debíamos actualizar

el firmware del PSoC MiniProg USB (dispositivo grabador), de la versión 1.78 a la 1.79.

Sobre estas líneas la captura de pantalla del momento justo dónde se indica que debemos

actualizar el firmware del MiniProg USB de la versión 1.78 a la 1.79.

Ilustración 13: Captura de pantalla del momento que indica que debemos actualizar



Observamos en la siguiente captura de pantalla que tardó 27 segundos en actualizar el

programador PSoC MiniProg USB. Colocamos también el detalle de la versión del software.

Podemos observar en la imagen anterior la configuración necesaria para realizar la

actualización de software sobre el Cypress PSoC, en nuestro caso es la familia de dispositivos

(“Device Family”, en inglés): 24x94 y en dispositivo (“Device”, en inglés): CY8C24894-24LFXA.

También se muestra en la imagen el detalle de la versión del software PSoC Programmer y el

proceso que indica que se ha realizado una actualización del firmware del programador (de la

1.78 a la 1.79).

Ilustración 14: Captura de pantalla de actualización firmware del programador



El código fuente del Cypress PSoC no se encuentra en el área de soporte web de la placa

Avnet. Según los comentarios en el mismo foro, por personal de Avnet, indican que si bien el

propietario de este código es la empresa Avnet y este software no está publicado en web;

Avnet puede proporcionarle el software a quien lo necesite siempre que se solicite mediante

el distribuidor Avnet autorizado. Para nuestro trabajo no fue necesario requerir el código

fuente y por lo tanto no se solicitó.

A pesar de no necesitar el código fuente para su modificación, el Cypress PSoC cuando

instalamos las utilidades de software, también instala el programa para realizar el cambio.

Este se denomina: PSoC Designer. La versión instalada fue la 5.0 (concretamente 5.0.423.0

SP4 Build 854 – April 1, 2009). Aunque no se utilizó en el desarrollo del proyecto.

Ilustración 15: Fotografía del PSoC MiniProg con indicación de las partes que lo integran



A continuación se muestra un esquema que indica cómo debe realizarse el montaje del PSoC

MiniProg USB para proceder a la programación del Cypress PSoC.

Básicamente, como se observa en el esquema anterior, únicamente se necesita un cable

estándar USB que se conecta al PC. El cable USB tiene en el extremo que se conecta al PC, un

conector USB tipo A macho y en el extremo que se conectará al programador PSoC MiniProg

USB tiene un conector USB tipo B macho.

Por la parte inferior del programador posee un conector denominado ISSP (“in-system serial

programmer” en inglés y que significa programación serie en el sistema) que se conectará

directamente con la placa Avnet, sin necesidad de ningún cable más.

Ilustración 16: Esquema conexiones PSoC MiniProg USB



El conector ISSP tiene 5 pins (5 cables / señales) según la siguiente tabla.

PIN Señal Descripción

1 Vdd Alimentación positiva de +5V

2 GND Tierra

3 XRES Reset externo

4 SCLK Reloj

5 SDAT Datos

Tabla 4: Tabla de señales del conector ISSP

Detalle del montaje del sistema con las indicaciones de las versiones utilizadas.

Ilustración 17: Esquema detallado de conexiones con indicación de versiones utilizadas



También hay que indicar en este punto que para que el “AvProg 4.0.5” funcione existe un

error conocido que sucede en los sistemas Windows cuando utilizamos caracteres unicode, la

comunicación serie se interrumpe ya que los caracteres de control son modificados por el

sistema operativo antes de la transmisión. El resultado es que el “AvProg” no puede

comunicar con el Cypress PSoC. Para solucionar este problema debemos establecer el idioma

del sistema operativo al inglés. Para ello pueden seguirse los siguientes pasos:

1. Ir a “Inicio”, “Configuración”, “Panel de control”

2. Doble click en “Configuración regional y de idioma”

3. Seleccionar pestaña de “Opciones avanzadas”, escoger el idioma “Inglés (Estados

Unidos)”

4. Pulsar el botón “Aceptar” para confirmar el cambio

Ilustración 18: Captura de pantalla del ajuste del idioma del sistema



Como resumen de este apartado, indicamos una tabla con las versiones utilizadas en los

diferentes dispositivos.

Nombre del software/firmware Versión Descripción funcional

Avnet Board Programming Utility (AvProg) 4.0.5 Software para grabar FPGA y memorias de la placa Avnet

Cypress PSoC 1 firmware CY8C24894-24LFXI

1.1.0 Firmware que está contenido dentro del chip PSoC de Cypress

PSoC Programmer 3.13.4.1048 Software que ayuda a grabar junto con el hardware PSoC MiniProg USB el chip PSoC de Cypress

PSoC MiniProg USB firmware 1.79 Firmware que está contenido dentro del grabador del chip PSoC de Cypress

PSoC Designer 5.0.423.0 Software de edición del firmware que irá dentro del PSoC de Cypress (no usado)

Tabla 5: Versiones del kit Avnet, software y firmware



12.2 Xilinx Platform StudioEl paquete que integra todo el software de Xilinx: Xilinx ISE (Integrated Software

Environment) Design Suite versión 12.3 consta de un módulo llamado “Embedded

Development Kit” (o EDK en adelante). Este Xilinx EDK consta de dos entornos (programas): el

“Xilinx Platform Studio” (o XPS en adelante) y el “Software Development Kit” (o SDK en

adelante). Cuya versión concreta mostramos a continuación.

El XPS se utiliza para el diseño de sistemas embedded (sistemas integrados) para configurar y

construir las especificaciones de hardware (núcleo del procesador, memoria del controlador,

entradas y salidas de los periféricos, etc.). El XPS convertirá las especificaciones del

diseñador en descripciones sintetizables HDL (“Hardware Description Danguage” en inglés,

lenguaje descriptivo del hardware en castellano) del tipo Verilog o VHDL y escribirá un

conjunto de scripts para automatizar la implementación del sistema embedded.

El objetivo en este punto del proyecto será configurar la FPGA estableciendo el uso de la

misma cómo MicroBlaze, para que sobre ella pueda ejecutarse el sistema operativo en tiempo

real: μC/OS-II.

MicroBlaze es una marca (trademark en inglés) que Xilinx creó para llamar a su “soft

processor core” o núcleo software de procesador (no físico) de 32 bits de arquitectura RISC

(Reduced Instruction set Computers, conjunto de instrucciones reducido) Harvard con un

amplio conjunto de instrucciones optimizadas para aplicaciones embedded. Con MicroBlaze

“soft processor” podemos tener una total flexibilidad para seleccionar combinaciones de

Ilustración 19: Captura de pantalla de la versión de XPS



características de memoria periférica así cómo la interfaz que podrá dar el sistema exacto

que se necesita en una sola FPGA. En este punto daremos por conocido y sabido toda la

literatura sobre los dispositivos FPGA's y nos limitaremos a la configuración y adaptación del

XPS.

El desarrollo e implementación de la FPGA se realiza por lo tanto, con el XPS y éste trata dos

partes diferenciadas y relacionadas: la parte del hardware y la parte de software.



12.2.1 Configuración de hardwarePara el desarrollo de esta parte partimos del ejemplo de aplicación que nos ofrece el

fabricante de la placa Avnet. Concretamente el que se basa en el sistema operativo μC/OS-II,

que se ejecutará sobre MicroBlaze.

En la siguiente imagen se muestra el hardware del diseño completo:

Ilustración 20: Captura de pantalla de la composición del hardware en la placa Avnet



Cómo elemento clave en nuestro proyecto lo constituye la denominada MSP430_UART, y como

su nombre indica es una UART construida con la IP “xps_uartlite”.

Otra parte clave del diseño hardware efectuado es la configuración de las interrupciones.

Necesitábamos para nuestro proyecto interrupciones de las dos UARTS utilizadas, interrupción

para el sensor con comunicación IIC y del “timer” (para el funcionamiento del μC/OS-II).

Mostramos a continuación la parte configurada:

Ilustración 21: Captura de pantalla de la configuración de las interrupciones



Una parte relevante del proyecto en este punto es el conexionado de esta UART en la FPGA.

Mostramos en la siguiente imagen una parte del archivo “system.ucf”, en el que puede

observarse la parte relevante del conexionado.

También, como se vio anteriormente, el pin M1 de la FPGA será el de recepción de la UART

del MSP430. El pin N1 será el de transmisión de la misma UART.

Ilustración 22: Captura de pantalla truncada del archivo system.ucf



La siguiente imagen muestra el diagrama de bloques hardware construido:

Ilustración 23: Gráfico de bloques hardware



12.2.2 Desarrollo del softwareLa parte de la programación de software de la FPGA la realizamos con la opción del XPS para

ello, es decir el SDK (Software Development Kit, Kit de desarrollo de software).

La programación de la FPGA se ha realizado usando lenguaje de programación C. Para este

apartado de software, dónde se ejecuta el sistema operativo μC/OS-II, hemos tenido en

cuenta dos ejemplos como base de aprendizaje y referencia. Un ejemplo del fabricante de la

placa Avnet y un ejemplo de aplicación de la empresa fabricante del sistema operativo

μC/OS-II, Micrium.

El libro sobre μC/OS-II [3] realizado por el autor del sistema operativo: Jean Labrosse, fue

también de mucha utilidad. Por todo el código llamamos y hacemos uso de las funciones de

μC/OS-II.

La estructura del software. Ejecuta dos tareas principales: la primera que procesa comandos

recibidos (por parte de ambas UART's la USB y la del MSP430) y la segunda que envía datos

hacia la UART del MSP430, además de configurarlo en modo ED. Ambas tareas se ejecutan de

forma automática cada 500ms.

El software detecta interrupciones de ambas UART's, recibe comandos, y los ejecuta de una

forma u otra según sea un comando de lectura o un comando de escritura. Los comandos que

sean de lectura devolverán aquella lectura mediante la UART MSP430. La mensajería de

comunicación será descrita en el apartado 12.4.3 Comunicaciones.



En este software se han implementado diversas funciones que ayudan a las dos tareas antes

descritas. Para todo el código hemos creado dos archivos en lenguaje C que se llaman:

application.c y bsp.c.

En las siguientes imágenes, cada caja es una función en el código fuente.

El código se encuentra comentado y sigue el estilo de codificación estándar de programas

escritos en lenguaje C.

También hemos creado una variable general que, activándola, nos permite analizar y hacer

“debug” (recibir mucha información para detectar posibles problemas de código) del

programa, en caso necesario.

Ilustración 24: Gráfico de funciones del archivo application.c



Se han implementado más funciones que, pese a no ser usadas en la versión final, han sido

útiles para realizar pruebas y depurar el código durante el desarrollo.

Ilustración 25: Gráfico de funciones del archivo bsp.c



12.3 Kit Texas Instruments: eZ430-RF2500El kit electrónico de la empresa Texas Instruments, con referencia eZ430-RF2500, es un kit de

desarrollo inalámbrico de conexión USB basado en el microcontrolador MSP430F2274 y el radio

transceptor inalámbrico a frecuencia de 2.4GHz, CC2500. El kit contiene dos piezas

denominadas eZ430-RF2500T “target board” (placa objetivo/principal, en castellano) y una

para hacer “debug” mediante un interfaz USB denominada eZ430-RF USB.

En la siguiente ilustración se muestran los componentes del kit y el nombre de cada parte.

Ilustración 26: Fotografía que presenta el kit eZ430-RF2500

Ilustración 27: Esquema de componentes del kit eZ430-RF2500



12.3.1 Hardware Texas InstrumentsViendo el detalle del kit eZ430-RF2500T, que es la placa más interesante debido a que es la

que tiene el microcontrolador y el chip de comunicación de radio, observamos que además

tiene 1 botón, 2 LED's, 18 GPIO's y una antena. Todo ello se indica en la ilustración siguiente.

Como observamos y hemos comentado anteriormente, el microcontrolador es el

MSP430F2274. Este microcontrolador consta de una CPU de 16 bits de arquitectura RISC. Tiene

32KBytes + 256Bytes de memoria flash y 1KBytes de memoria RAM.

Su arquitectura interna puede verse en la siguiente ilustración.

Ilustración 28: Esquema de componentes internos del eZ430i-RF USB + eZ430-RF2500T

Ilustración 29: Esquema de la arquitectura interna del MSP430F2274



Se realizó un estudio de los puertos y señales que teníamos disponibles con el fin de usar

aquellas que fuesen más fácilmente implementables para comunicar con la placa Avnet.

El MSP430F2274 tiene 2 módulos USCI (“universal serial communications interface”, interfaz

de comunicación serie universal, en castellano). Este tipo de comunicación serie puede ser

síncrona, cómo SPI y I2C, o asíncrona cómo las de tipo UART.

El módulo USCI_A0 soporta las siguientes comunicaciones:

• SPI (de 3 ó 4 pins)

• UART

• enhanced UART (es decir UART de detección automática del baudrate, denominada

LIN)

• irDA, adaptada a los infrarrojos

El módulo USCI_B0 soporta las siguientes:

• SPI (de 3 ó 4 pins)

• I2C

Analizando estas señales disponibles vemos que el el SPI forma parte de los dos puertos y este

fue uno de los motivos que inicialmente llevaron a pensar que el SPI era la mejor opción de

conexión.



De estas señales pueden observarse, visualizando la placa, cuales se usan y cuales no. Los

puertos y señales principales están presentes en la ilustración siguiente.

También se tuvo que analizar en detalle el esquema electrónico de la placa para saber cómo

estaba conectado en CC2500 con el MSP430F2274.

Ilustración 30: Esquema de los puertos y señales de la placa eZ430-RF2500T



En la siguiente ilustración se muestra el esquema correspondiente.

Ilustración 31: Esquema electrónico de la placa eZ430-RF2500T



El CC2500 es un transceptor de radio frecuencia de bajo coste que trabaja en la banda de

2.4GHz ISM (“Industrial, Scientific and Medical”, industrial, científica y médica, en

castellano) y la SRD (“Short Range Device”, dispositivos de corto alcance, en castellano).

Las dos letras CC del nombre se debe a que este dispositivo pertenecía a la empresa ChipCon,

que posteriormente fue comprada por Texas Instruments.

La arquitectura de bloques del chip se muestra en la siguiente ilustración.

Ilustración 32: Esquema de la arquitectura interna del CC2500



El CC2500 está conectado mediante SPI al MSP430 así que la idea inicial de conectarlo por SPI

acabó perdiendo fuerza enseguida porque hubiese sido más complicado y difícil de

conexionar.

En la siguiente ilustración vemos la conexión SPI entre el MSP430F2274 y el CC2500.

Como se puede deducir el SPI del módulo USCI_B0, es el usado para la interconexión del

MSP430F2274 y el CC2500.

Por lo que se eligió cómo solución de comunicación entre la placa Avnet y la placa eZ430-

RF2500T, una comunicación mediante una UART, como se ha comentado anteriormente.

Ilustración 33: Esquema de la interconexión SPI entre el MSP430F2274 y el CC2500



Usando para ello el módulo USCI_A0 disponible.

El esquema de conexiones propuesto entre la placa de Avnet que contiene la FPGA y la placa

eZ430-RF2500T es el siguiente. Como puede verse, es sencilla la implementación física.

Sería suficiente realizando alguna placa electrónica que pueda conectarse entre ambos

dispositivos. En nuestro caso hemos adoptado una solución rápida únicamente usando cable.

Ilustración 34: Esquema de conexiones entre placa Avnet (FPGA) y eZ430-RF2500T

Ilustración 35: Fotografía de la implementación para test



12.3.2 Software MSP430Para el desarrollo del software MSP430F2274 hemos usado el software oficial que la empresa

Texas Instruments indica, este se llama “Code Compose Studio”, concretamente la versión

4.2.4.00033. Dicho software está basado en el popular EDK Eclipse.

Este software nos ha permitido realizar un código fuente limitado, por la licencia de la

versión en cuanto a tamaño de memoria, pero no obstante las limitaciones suficiente para

cumplir con los requisitos de comunicaciones requeridos.

Ilustración 36: Captura de pantalla del About del Code Composer Studio



Es más, se realizó un esfuerzo de programación para que, usando un único programa, es decir

un único firmware para este dispositivo, se comportase en modo AP (Access Point) y en modo

ED (End Point) mediante configuración sobre el mismo. Esto fue un requisito del proyecto

para evitar la carga constante del firmware sobre el MSP430 en las futuras prácticas con este

dispositivo.

La limitación del espacio de código provocó que se tuvieran que comentar código fuente

escrito inicialmente, cómo por ejemplo, muchos controles de errores, y con ello optimizar al

Ilustración 37: Captura de pantalla del aspecto del Code Composer



máximo el espacio y la memoria usada. No por ello se ha eliminado el código fuente inicial

sino que se ha dejado comentado a modo de opciones de desarrollo futuras.

El programa se ha realizado mediante uso del lenguaje C. Como organización del código se

han creado funciones que podrían emplearse en posteriores adaptaciones de código.

El funcionamiento del programa se basa en un bucle que está en continua ejecución por lo

que siempre comprobará si debe realizar algún comando o función que haya recibido. Los

comandos pueden recibirse desde dos medios físicos diferentes: vía radio o vía UART.

Asimismo, los comandos provocan la emisión de respuestas por los mismos medios. Por lo

tanto para ello hacemos uso de interrupciones del programa cuando se recibe vía radio o vía

UART.

También gracias a la programación de una función específica para ello, podemos saber la

temperatura del dispositivo en todo momento. El programa se ha realizado separando el

código en dos ficheros en lenguaje C.

Ilustración 38: Gráfico de la estructura del programa MSP430



En las imágenes se muestran las funciones de cada fichero. Las flechas indican qué función

llama a otra función.

Para que este software funcione correctamente, una vez tenemos el programa grabado en el

microcontrolador, se le tiene que indicar una dirección de recepción, otra de emisión y

configurar el modo de funcionamiento que se le dará, denominado modo AP y modo ED. De

esta forma nos evitamos tener que indicar si un dispositivo es el AP y otro el ED.

Ocurre lo mismo en cuanto a la dirección de recepción y emisión, ésta podría haberse grabado

sobre la memoria que lleva el microcontrolador, pero se optó por la obligatoriedad de

asignarla en el momento de la configuración.

No debemos perder de vista que este dispositivo debe configurarse en un entorno de

laboratorio por alumnos realizando prácticas de diferentes grupos. Evitando por lo tanto la

programación continuada sobre el dispositivo, y únicamente dejando al alumno que mediante

el uso de una UART configure el dispositivo según las necesidades de cada clase o grupo.

Queda claro por lo tanto, que las direcciones de comunicaciones entre modo AP y modo ED

deberán ser diferentes y estas diferentes entre otros pares AP-ED.

Entonces cuando se desea configurar el dispositivo eZ430-RF2500T en modo AP, sabemos que

este será el del lado del PC y se le deberá indicar la dirección ED y la dirección AP que

tendrá. Desde el lado FPGA el dispositivo se configurará en modo ED e igualmente se le

deberá configurar la dirección ED y la dirección AP.

Ilustración 39: Gráfico de la estructura del programa MSP430 (librerías)



Para las comunicaciones vía radio, como se indicó en el apartado de hardware, se utiliza el

chip CC2500, que puede controlarse mediante software con cualquier protocolo y con

SimpliciTI. Esto puede verse con detalle en la siguiente ilustración.

Ilustración 40: Captura de pantalla sobre data-sheet del CC2500



Inicialmente se inició una investigación para la creación de un protocolo propio de

comunicaciones pero la idea se desestimó debido a que este proyecto no tiene como fin el

desarrollo de un nuevo protocolo de bajo nivel sino que su objetivo es la comunicación

inalámbrica, y debido a la dificultad que ello implicaba, se optó por usar el protocolo (y sus

librerías de control) SimpliciTI. Este protocolo está desarrollado por Texas Instruments y a

pesar de ser código abierto, éste está licenciado (es propiedad de) por Texas Instruments.

SimpliciTI tiene numerosas ventajas: ocupa poca memoria flash (menos de 8kB) y poca

memoria RAM (1kB) dependiendo de la configuración. Control avanzado de la red: seguridad y

cambio de frecuencia en función del ruido (“frequency agility” en inglés). Soporta modo de

suspensión para ahorro de batería. Todo ello usando una API (Application Programming

Interface en inglés, e Interfaz de programación de aplicaciones, en castellano).

En este protocolo, cada uno de los dispositivos realiza una acción. Tenemos el AP (Access

Point) que es el conector de los demás componentes de la red; tenemos el ED (End Device)

que es el componente final de la red y por lo tanto el componente básico. También puede

existir un RE (Range Extender, en inglés, o extensor de rango, en castellano) que es el

dispositivo configurado para ayudar a amplificar y hacer más grande la red, extendiéndola.

Ilustración 41: Captura de pantalla sobre relación entre SimpliciTI y el CC2500



La topología de red que este protocolo es capaz de implementar son dos: en estrella y punto

a punto.

Conceptualmente soporta tres capas, que no siguen estrictamente el modelo OSI ("open

system interconnection", modelo de interconexión de sistemas abiertos, en castellano) de

referencia: capa de aplicación, capa de red y capa de enlace de datos o física.

No hay capa de transporte, ni de presentación.

Ilustración 42: Captura de pantalla de la topología y flujo de mensajes de SimpliciTI



Vemos en la siguiente imagen las tres capas indicadas. La capa de aplicación soporta las

siguientes funciones:

• Ping (Port 0x01): detecta la presencia de un dispositivo específico.

• Link (0x02 Port): apoya la gestión de enlaces de dos pares.

• Ingreso (Port 0x03): protege la entrada a la red en topologías con APs.

• Seguridad (puertos 0x04): cambia la información de seguridad, como son las claves de

cifrado y el contexto de cifrado.

• Freq (Port 0x05): realiza el cambio de canal o la solicitud de petición del cambio.

• Mgmt (0x06 Puerto): puerto de gestión general administra el dispositivo.

Por último en la capa de enlace de datos o física, se divide en dos entidades:

• BSP (Board Support Package, paquete de soporte de la placa, en castellano): para

abstraer el interfaz SPI de la capa de red que interactúa con la radio.

• MRFI (Minimal RF Interface, interfaz mínimo de radio frecuencia, en castellano): para

encapsular las diferencias entre el hardware de radio soportado hacia la capa de red.

Ilustración 43: Captura de pantalla de capas SimpliciTI



12.4 Configuración, control y monitorización del sistemaEn este apartado se va a exponer cómo se ha realizado el control de todo el sistema, cómo se

realiza la configuración y cómo la monitorización.

12.4.1 Desarrollo, instalación y configuración del entornoLa decisión clave de este desarrollo (y de todo el proyecto) fue la de hacer una aplicación

web para el control de todo el sistema. Hoy en día por todos es sabido la importancia de

Internet, por lo que desarrollar una aplicación web en la que el navegador es la parte

principal del programa de control, dota a este proyecto de un gran valor innovador y lo hace

destacar especialmente.

Al tratarse de una web, se ha tenido en cuenta y se ha verificado que dicha web pueda

instalarse y funcionar correctamente tanto en un sistema operativo Windows como en un

sistema operativo GNU/Linux, y todo ello sin perder de vista que todas las pruebas y detalles

de instalación tenían como requisito que fuera una aplicación para el sistema operativo

Windows.

Vemos que la web se sustenta sobre el servidor web Apache, utiliza lenguaje de programación

web PHP, lenguaje web HTML5, lenguaje dinámico JavaScript, lenguaje de diseño CSS3 y

Ilustración 44: Gráfico de la arquitectura de la web



Python para comunicaciones a bajo nivel (mediante el uso del módulo CGI de Apache).

Se ha preparado un tutorial que explica paso a paso cómo realizar la instalación de la web.

Destacar aquí que hacemos uso de un programa llamado WAMP (por sus siglas de Windows

Apache MySQL PHP).

Este programa realiza una instalación de los anteriores citados programas que sus siglas

indican. En nuestro caso no hemos hecho uso de base de datos (MySQL) porque no ha sido

necesario.

La web ha sido elaborada sin el uso de ningún IDE de programación y únicamente valiéndonos

de un editor de textos. Con lo que el código ha sido escrito partiendo desde cero y por lo

tanto el código de la web es muy limpio. La web se ha elaborado con el estándar web HTML5

que todavía no tiene cerradas las normas de estandarización, por lo que éstas pueden variar.

No obstantes lo anterior, se usó ese estándar por ser la última y más moderna tecnología en

desarrollo web.

Ilustración 45: Captura de pantalla del software WAMP

Ilustración 46: Captura de pantalla del logo del lenguaje PHP



El lenguaje de la programación dinámica ha sido PHP. Este lenguaje está muy extendido en la

web y presenta muchas librerías que nos facilitan la programación. Nuestra comunicación

entre el PC y el módulo AP se basa en el puerto serie.

Es justo en el puerto serie dónde PHP ha presentado dificultades porque no tiene librerías

para ello, al menos no las tiene, de forma oficial.

Existen librerías PHP elaboradas por la comunidad de usuarios que, en algunos casos,

funcionan en sistemas operativos GNU/Linux, pero no en sistemas operativos cómo Windows,

o funcionan como escritura en un sistema operativo, y no como lectura en otro, etc. Es decir

que después de valorarlo, probar estas librerías y en algunos casos mejorar su código, se optó

por buscar otra estrategia de control.

Aún así, a nivel de código fuente, se ha dejado para que sirva en un futuro todas las

comunicaciones que funcionaron y todas las pruebas que se realizaron.

Ilustración 47: Captura de pantalla de código fuente HTML5 y PHP



La estrategia fue entonces escoger otro lenguaje de programación el cual dispusiera de

librerías de control del puerto serie y funcionase en ambos sistemas operativos. Y para ello

escogimos el lenguaje de programación Python.

Python se comunica con la aplicación web mediante un módulo de Apache, el módulo CGI.

Esto nos ha permitido tener un control total de escritura y lectura del puerto serie.

Una dificultad añadida fue la de no usar la misma versión de Python para los diferentes

sistemas operativos, lo que provocó tener que duplicar todas las funciones (una para cada

sistema operativo).

Ilustración 48: Captura de pantalla de código fuente Python



Otra técnica relevante es que se usó objetos JSON cómo los objetos devueltos por los scripts

de Python para facilitar la recepción mediante código JavaScript y el tratado de los datos

devueltos.

A nivel de diseño hemos utilizado la librería de estilos Bootstrap que la empresa Twitter ha

desarrollado y que permite desarrollar gráficamente la web para ser más potente, más rápida

y más fácil de usar.

Algunas de las imágenes que forman parte de la web se han diseñado de forma vectorial

(formato estándar SVG) que garantizan la correcta visualización sin importar el zoom o la

pantalla de visualización, y transmiten una calidad de imagen máxima. El diseño se ha

combinado con librerías de JavaScript que mejoran la navegación y hacen la web más ágil y

sencilla de usar.

La web se ha desarrollado en tres idiomas básicos para el aprendizaje en la universidad UPC:

el inglés, el catalán y el español.

Ilustración 49: Captura de pantalla de código fuente AJAX y JSON



12.4.2 Control y monitorizaciónEl objetivo de la web es el control de todo el sistema y por lo tanto también se monitoriza

todo desde la misma web.

Vamos a explicar las diferentes partes de la web. La estructura general es la de un menú

superior dónde puede acceder a todas las funcionalidades y a la elección del idioma. En la

parte central se dispondrán los elementos de control, las imágenes y los gráficos.

Ilustración 50: Gráfico del menú de la web



La configuración del sistema es muy intuitiva ya que el sistema va realizando preguntas. La

primera es la de conocer el sistema operativo que se está usando, datos de configuración

típicos del puerto serie (cómo el puerto, la velocidad, bit de datos, paridad, bit de parada y

control de flujo) y una comprobación de si tenemos el puerto preparado para la

comunicación. Todo ello se puede hacer de forma manual o automática desde el menú de

“Configuración”.

El siguiente paso una vez hemos configurado el puerto serie sería el de configuración del

dispositivo MSP430 en modo AP.

Ilustración 51: Captura de pantalla de la portada de la web



Esto lo hacemos en la primera opción del menú “Comunicación”, en el submenú

“Configuración AP”. Allí indicaremos la dirección del ED, la dirección del AP y por último

confirmaremos la configuración del AP mediante un botón.

Por otro lado el módulo ED deberá ser configurado de forma análoga pero, en este caso, por

la placa de la FPGA.

Para entender el detalle de cómo funciona el siguiente submenú “AJAX Python”, que es el de

comunicación con todo el sistema, el lector puede mirar el siguiente apartado donde se

describe el protocolo de comunicaciones que hemos utilizado.

Como su nombre indica, las comunicaciones se realizan desde la web con peticiones

asimétricas de tipo AJAX (acrónimo del inglés Asynchronous JavaScript And XML, en

castellano: JavaScript asíncrono y XML). AJAX es una técnica que permite crear aplicaciones

que se ejecutan en el lado cliente (el navegador web) permitiendo una comunicación

asíncrona en segundo plano con el servidor. Evitando recargar páginas web para realizar

cambios, aumentando con ello la interactividad, velocidad y usabilidad. En nuestro caso, lado

cliente y lado servidor, corren en la misma máquina.

Ilustración 52: Captura de pantalla de la configuración AP



Cada uno de los campos de la imagen, se muestran siguiendo el orden de los bytes a enviar.

En total serán 8 bytes los que construyan el mensaje final. Es decir que primero indicamos el

destino, luego lo que deseamos realizar (lectura o escritura). La dirección de memoria

implicada y los datos del mensaje. Pulsando el botón de “Enviar”, se enviará el mensaje que

irá al destino indicado.

Esta página, cómo puede observarse, también tiene una serie de controles adicionales: Temp,

RSSI, Volt, led1_on, led1_off, led2_on y led2_off. Pulsando estos botones se envía el mensaje

adecuado solicitando aquello que indica el botón, al destino seleccionado.

Ilustración 53: Captura de pantalla del submenú AJAX Python



En el submenú “AJAX Control con imagen” vemos la imagen anterior que nos permite

controlar los LED's tanto del AP cómo del ED, apagando y encendiendo, el LED1 verde o el

LED2 rojo. Todo ello con sólo pasar el ratón por encima de cada imagen, sin necesidad de

pulsar nada (mediante peticiones en segundo plano AJAX).

En el menú de “Monitorización” podremos visualizar tres indicadores que provienen o del ED o

del AP según escojamos en el submenú. Estos tres indicadores son el voltaje, la temperatura y

el RSSI (acrónimo del inglés, Receive Signal Strength Indication, o en castellano: Indicador de

fuerza de señal de recepción).

Ilustración 54: Captura de pantalla del control AJAX con imagen



La monitorización de estos indicadores se realiza mediante una librería de JavaScript que nos

permite obtener un gráfico en tiempo real de los valores que se reciben. En las siguientes

imágenes superior e inferior, vemos los gráficos, tanto del AP, como del ED.

Ilustración 55: Captura de pantalla del gráfico del AP

Ilustración 56: Captura de pantalla del gráfico del ED



Los diferentes menús que forman la web de control son para proporcionar información del

sistema y para ayuda a la instalación de la aplicación.

Aquí hay que destacar que lo que se visualiza en la siguiente ilustración es una imagen SVG

(vectorial) pero que con la ayuda de programación en PHP cambia dinámicamente el texto de

la imagen vectorial. Es decir que establece variables leídas en PHP y las muestra en tiempo

real en una imagen vectorial. Es una tecnología muy actual y muy poco utilizada aún por la

misma razón.

Y finalmente, menú de información y contacto; en él se nos mostrará, referencias de la

universidad UPC y los datos del autor del trabajo.

Ilustración 57: Captura de pantalla de la parte de información de la web



12.4.3 ComunicacionesEl protocolo usado se basa en un sistema de mensajería propio. Es propio para obtener un

mejor rendimiento y una optimización de las comunicaciones. Se investigó antes de crear una

mensajería propia el uso de algún otro protocolo, como es el SNMP, pero se descarto debido a

su complejidad para este sencillo sistema.

Cada mensaje que circula por todo el sistema ocupa 8 bytes. Estos bytes viajan por todo el

sistema de diferentes formas físicas. En un hipotético mensaje desde la parte de WEB (un

extremo) hasta el otro extremo del sistema (la placa de la FPGA), el mensaje será enviado

por la web mediante protocolo serie, llegando al módulo AP. El módulo AP lo recibirá y lo

transmitirá vía radio hacia el módulo ED. El módulo ED finalmente lo transmitirá a la FPGA

usando protocolo serie RS232, mediante una UART.

Es importante que cada módulo integrante del sistema conozca el origen y destino del

mensaje. Es por ello que el primer byte del mensaje será la cabecera que indique el origen y

destino del mensaje. El segundo byte indicará si es un mensaje de lectura (R) o de escritura

(W). El tercer y cuarto byte indicarán la dirección de memoria afectada por el mensaje. El

quinto, sexto y séptimo byte serán los datos del mensaje. El último byte (el octavo) será un

indicativo de fin de mensaje con un valor de “retorno de carro”, en hexadecimal indicado

mediante 0D.

Tabla 6: Tabla de cabeceras de mensajería

NÚM. ASCII HEX DEC ORIGEN MEDIO DESTINO MEDIO PC AP ED FG(FPGA)1 A 41 65 PC UART AP UART emisor receptor (UART) - -2 B 42 66 PC UART ED RADIO emisor transporte (UART2RADIO) receptor (RADIO) -3 C 43 67 PC UART FG UART emisor transporte (UART2RADIO) transporte (RADIO2UART) receptor4 D 44 68 AP UART PC UART receptor emisor - -5 E 45 69 AP RADIO ED RADIO - emisor receptor (RADIO) -6 F 46 70 AP RADIO FG UART - emisor transporte (RADIO2UART) receptor7 G 47 71 ED RADIO PC UART receptor transporte (RADIO2UART) emisor -8 H 48 72 ED RADIO AP RADIO - receptor (RADIO) emisor -9 I 49 73 ED UART FG UART - - emisor receptor

10 J 4A 74 FG UART PC UART receptor transporte (RADIO2UART) transporte (UART2RADIO) emisor11 K 4B 75 FG UART AP RADIO - receptor (RADIO) transporte (UART2RADIO) emisor12 L 4C 76 FG UART ED UART - - receptor (UART) emisor



En la siguiente imagen vemos una composición de las cabeceras del sistema.

Ilustración 58: Gráfico de la mensajería del sistema



La siguiente tabla muestra los posibles mensajes que pueden usarse en referencia a un origen

o destino de los módulos AP o ED.

A continuación tenemos algunos ejemplos de estos mensajes y su significado:

Tabla 7: Tabla de mensajería del AP y del ED

COMPONENTE PUERTO CABECERA LECTURA / DIRECCIÓN REN DIR DATA FINESCRITURA 0=no pull-up 0=output 0=on MENSAJE

1=pull-up 1=input 1=offLED2_rojo P1.0 A,B,K,L R,W 10 (0/1) (0/1) (0/1) \r = x0D = 13LED1_verde P1.1 A,B,K,L R,W 11 (0/1) (0/1) (0/1) \r = x0D = 13Pulsador P1.2 A,B,K,L R 12 (0/1) (0/1) (0/1) \r = x0D = 13P3 P2.0 A,B,K,L R,W 20 (0/1) (0/1) (0/1) \r = x0D = 13P4 P2.1 A,B,K,L R,W 21 (0/1) (0/1) (0/1) \r = x0D = 13P5 P2.2 A,B,K,L R,W 22 (0/1) (0/1) (0/1) \r = x0D = 13P6 P2.3 A,B,K,L R,W 23 (0/1) (0/1) (0/1) \r = x0D = 13P7 P2.4 A,B,K,L R,W 24 (0/1) (0/1) (0/1) \r = x0D = 13P8 P4.3 A,B,K,L R,W 43 (0/1) (0/1) (0/1) \r = x0D = 13P9 P4.4 A,B,K,L R,W 44 (0/1) (0/1) (0/1) \r = x0D = 13P10 P4.5 A,B,K,L R,W 45 (0/1) (0/1) (0/1) \r = x0D = 13P11 P4.6 A,B,K,L R,W 46 (0/1) (0/1) (0/1) \r = x0D = 13Temperatura P5.0 A,B,K,L R 50 X X X \r = x0D = 13RSSI P5.1 A,B,K,L R 51 X X X \r = x0D = 13VOLTAGE P5.2 A,B,K,L R 52 X X X \r = x0D = 13EndPoint P6.0 A,B,K,L W 60 X X X \r = x0D = 13AccessPoint P6.1 A,B,K,L W 61 X X X \r = x0D = 13Setup P6.2 A,B,K,L W 62 X X X \r = x0D = 13

Número bytes 1 byte 1 byte 2 bytes 1 byte 1 byte 1 byte 1 byteMensaje 0 1 2+3 4 5 6

Comando 0 1+2 3 4 5

Tabla 8: Tabla de ejemplos de mensajería desde Web y desde Putty

Origen Mensaje Descripción Origen Mensaje DescripciónWEB AR50000 Retorna temperatura PUTTY LR50000 Retorna temperaturaWEB AR51000 Retorna RSSI PUTTY LR51000 Retorna RSSIWEB AR52000 Retorna voltaje PUTTY LR52000 Retorna voltajeWEB AW60xxx Establece xxx cómo dirección del ED PUTTY LW60xxx Establece xxx cómo dirección del EDWEB AW61yyy Establece yyy cómo dirección del AP PUTTY LW61yyy Establece yyy cómo dirección del APWEB AW62001 Configura cómo módulo AP PUTTY LW62000 Configura cómo módulo EDWEB AW10001 Apaga led2 rojo AP PUTTY LW10001 Apaga led2 rojo EDWEB AW10000 Enciende led2 rojo AP PUTTY LW10000 Enciende led2 rojo EDWEB AW11001 Apaga led1 verde AP PUTTY LW11001 Apaga led1 verde EDWEB AW11000 Enciende led1 verde AP PUTTY LW11000 Enciende led1 verde EDWEB AW20001 Apaga led3 amarillo AP PUTTY LW20001 Apaga led3 amarillo EDWEB AW20000 Enciende led3 amarillo AP PUTTY LW20000 Enciende led3 amarillo ED



Algunos de estos ejemplos son enviados desde la propia web o a veces lanzados mediante el

programa Putty, que permite enviar comunicación serie.

La tabla anterior hace referencia a los posibles mensajes que pueden ser destinados a la placa

FPGA. Y a continuación algunos ejemplos de mensajería, junto con su significado.

Con todos los ejemplos anteriores puede alcanzarse un conocimiento de las comunicaciones y

la mensajería que circula por todo el sistema.

Tabla 9: Tabla de mensajería de la FPGA

COMPONENTE PUERTO CABECERA LECTURA / DIRECCIÓN DATA FINESCRITURA MEMORIA 000=on MENSAJE

001=offLED 1 P1.0 C,F,I W 10 (000/001) \r = x0D = 13LED 1 P1.1 C,F,I W 11 (000/001) \r = x0D = 13LED 1 P1.2 C,F,I W 12 (000/001) \r = x0D = 13LED 1 P1.3 C,F,I W 13 (000/001) \r = x0D = 13INTERRUPTOR 1 P2.0 C,F,I R 20 000 \r = x0D = 13INTERRUPTOR 2 P2.1 C,F,I R 21 000 \r = x0D = 13INTERRUPTOR 3 P2.2 C,F,I R 22 000 \r = x0D = 13Temperatura C,F,I R 50 000 \r = x0D = 13RESET C,F,I W 00 000 \r = x0D = 13

Número bytes 1 byte 1 byte 2 bytes 3 byte 1 byteMensaje 0 1 2+3 4+5+6 7

Comando 0 1+2 3+4+5

Tabla 10: Tabla de ejemplos de mensajes de la FPGA

Origen Mensaje DescripciónFPGA xW00000 resetFPGA CW10001 1 led, 0 bit, 000 offFPGA CW11001 1 led, 1 bit, 000 offFPGA CW12001 1 led, 2 bit, 000 offFPGA CW13001 1 led, 3 bit, 000 offFPGA CW10000 1 led, 0 bit, 000 onFPGA CW11000 1 led, 1 bit, 000 onFPGA CW12000 1 led, 2 bit, 000 onFPGA CW13000 1 led, 3 bit, 000 onFPGA LW10000 Enciende led2 rojo EDFPGA LW10001 Apaga led2 rojo EDFPGA KW10000 Enciende led2 rojo APFPGA KW10001 Apaga led2 rojo APFPGA xR50000 Retorna temperaturaFPGA xR20000 Retorna 0/1 desde interruptor 1FPGA xR21000 Retorna 0/1 desde interruptor 2FPGA xR22000 Retorna 0/1 desde interruptor 3



13 ResultadosLos resultados obtenidos con este trabajo realizado han sido los esperados, es decir, se ha

obtenido un sistema inalámbrico, con posibilidad de configurarlo, monitorizarlo y ampliarlo

mediante la construcción de una red de sensores.

Todo el desarrollo se ha realizado fuera de laboratorio, en un ambiente doméstico. Es por ello

que nos hemos visto obligados a dotarnos de los instrumentos y elementos de desarrollo

necesarios para alcanzar el objetivo, entre ellos fue necesaria la adquisición de un pequeño

analizador lógico por USB, que permitió observar las comunicaciones que fluían por todo el

sistema.

La validación de todo el sistema se ha realizado aislando cada parte del mismo y realizando

pruebas a cada elemento de forma individual, consiguiendo así que todo el sistema en su

conjunto, funcionara sin ningún problema añadido. Además de lo anterior, se realizaron

pruebas de conectividad serie desde la web hacia dispositivos serie y hacia puertos serie

virtuales para analizar las comunicaciones enviadas y recibidas.

Para realizar las pruebas de radio y comunicaciones entre los MSP430 se tuvo en cuenta las

posibles interferencias que otros dispositivos de red inalámbricos podrían causar al sistema,

tales como los routers domésticos, razón por la que ajustó para ello el canal de emisión para

evitar en lo posible solapamientos de frecuencia.

Para las pruebas sobre la placa de Avnet y también las anteriores pruebas de los diferentes

componentes del sistema nos ayudamos del programa Putty ya que el mismo permite

conexiones serie. También hemos realizado algunos scripts (programas) en lenguaje Python,

que han permitido realizar pruebas.

Durante las pruebas se ha simulado el comportamiento de los diferentes elementos del

sistema mediante un script para probar que todo el sistema se comportara de forma adecuada

y según lo esperado. Esta parte es de vital importancia puesto que el objetivo es la aplicación

del proyecto al ámbito de la docencia. Los scripts que simulan el comportamiento del

hardware (concretamente de las comunicaciones) serán muy interesantes a aquellos alumnos

que posiblemente deban realizar prácticas en las cuales no dispongan del hardware necesario.



14 ConclusionesLa principal conclusión es que este proyecto ha cumplido con creces con el objetivo general

de ser de utilidad al ámbito de la docencia. Los logros alcanzados han sido múltiples; se ha

implementado un software para cada uno de los elementos del sistema, con los requisitos

iniciales impuestos de hardware; se ha conseguido una comunicación mediante un nuevo

protocolo de bajo nivel de todos los sistemas; además todo el sistema es supervisado

mediante una web que permite controlar y monitorizar los elementos hardware.

Durante la realización del proyecto, el objetivo inicial del mismo ha sido ampliado al realizar:

• Control con una implementación teniendo en cuenta que el sistema pueda funcionar

en entorno GNU/Linux (y no sólo en Microsoft Windows).

• Creado elementos de simulación (scripts en Python) capaces de simular cada uno de

los componentes que forman el sistema, para que el alumno no dependa del

hardware.

La siguiente tabla muestra la estadística del código fuente. Los números indican el número de

líneas en blanco, líneas en comentarios y líneas de código fuente por cada uno de los

lenguajes de programación usados. Se ha realizado con la ayuda del programa CLOC (Count

Lines of Code, contar el número de líneas de código, en castellano).

Tabla 11: Tabla estadística del código fuente



15 Ambientalización y sostenibilidad del PFCEn el desarrollo de este PFC se han buscado las metodologías para lograr un software que sea

eficaz y que permita el ahorro de energía. Además se ha optimizado el protocolo de

comunicaciones haciendo también que éste sea sostenible.

El tratamiento totalmente digitalizado de la información de este PFC nos permite afirmar que

este PFC cumple con las normativas actuales (Ley 12/2006, de 27 de julio, de medidas en

materia de medio ambiente, y la Ley 4/2004, relativa al proceso de adecuación de las

actividades de incidencia ambiental). El cumplimiento de la legislación vigente confirma que

este PFC es ambientalmente no contaminante en todos sus procesos y perfectamente

sostenible por su búsqueda de la optimización de los mismos.



16 Líneas de trabajo futurasLas posibles mejoras futuras de este proyecto, podrían ser, entre otras, las siguientes:

• A pesar de ser un PFC ambientalmente no contaminante y sostenible, cómo se ha

indicado en el capítulo anterior, creemos que podría mejorarse y optimizar aún más

parte del código fuente para el uso mínimo de energía en el MSP430.

• Se debería ajustar el código web y ajustar aquello que fuera necesario, cuando se

publique el estándar definitivo del HTML5.

• Podríamos ajustar y adaptar a las últimas versiones de todos los componentes software

del sistema. Aunque en la mayoría de casos estarán cerca de la última versión

disponible. Una posible actualización es el software PSoC Programmer a la última

versión 3.14 de febrero 2012.

• Se podría entrar en más detalles de las comunicaciones del SimpliciTI en lo que a la

frecuencia de radio se refiere, así cómo parte del protocolo usado internamente.

• Se podrían realizar pruebas construyendo un sistema de red distribuido más grande.



17 PlanificaciónEl desarrollo completo del proyecto ha durado casi 3 años, desde la publicación de las

necesidades del PFC hasta la elaboración de esta memoria.

En este tiempo se han realizado diversas tareas que han llevado a la finalización con éxito del

proyecto. Se enumeran a continuación:

• Se recibió el material necesario para la elaboración del proyecto del director del

mismo, así cómo libros de ayuda.

• Se estudiaron los requerimientos para lograr el objetivo del proyecto.

• Se realizó una planificación de lo que sería la ejecución del proyecto.

• Se realizó un estudio de comunicaciones entre el MSP430 y la placa de Avnet,

estudiando cada posible conexionado entre sí.

• Se estudiaron los posibles protocolos vía radio que podrían transmitirse con el

hardware del MSP430.

• Se realizó la compra de más material, necesario para realizar pruebas y tener más

elementos en el sistema.

• Se realizó un intenso estudio sobre el la denominada softCPU de MicroBlaze. Nunca

antes el autor había tratado la tecnología usada con MicroBlaze.

• Se compró instrumentación para realizar pruebas.

• Se tuvo que preparar el entorno de desarrollo instalando y preparando un PC con todo

el software y drivers necesarios. Y adecuar otro PC para GNU/Linux.

• Se realizó un extenso estudio sobre el protocolo SPI que finalmente no fue usado pero

que nos ha servido para aprender mucho sobre él, ya que antes el autor no había

usado dicho protocolo.

• Se realizaron trabajos de conexionado de las UART's.

• Se desarrolló el software de la placa de Avnet que contiene la FPGA con el XPS.



• Se desarrolló el software del MSP430 con el Code Composer de TI.

• Se realizó toda la web desde cero creando todas las líneas de código de la misma en la

última tecnología web, HTML5 y ayudado del último lenguaje de diseño web, CSS3.

• Se reajustó el protocolo de comunicaciones para adaptarnos a necesidades de más

bajo nivel necesarias.

• Se reajustó por lo tanto el software del MSP430 para cumplir nuevos requerimientos.

• Se reajustó el software de la FPGA para cumplir nuevos requerimientos.

• Se realizaron pruebas completas de todo el sistema.

• Se realizó un tutorial de instalación de los componentes de todo el sistema.

• Se realizó la elaboración de la memoria que está leyendo.

• Se preparó la presentación, que será la exposición y defensa de este PFC y “máster

tesis”.



17.1 Diagrama de Gantt

Ilustración 59: Captura de pantalla del diagrama de Gantt



17.2 PresupuestoEl proyecto ha sido económicamente viable por el valor de los componentes seleccionados

como requisitos del proyecto, y porque el material extra, así cómo el instrumental necesario

para análisis, es económico también.

En el presupuesto de este proyecto no se ha contemplado ni ha sido necesario la contratación

de ningún servicio, no se ha tenido en cuenta amortización de equipos y tampoco la

recuperación de la inversión.

A continuación se desglosará el presupuesto en horas de personal y material.

Instrumentación y material

Descripción Unidades Precio Total

Xilinx Platform Cable USB, modelo DLC9G 1 90€ 90€

Analizador lógico de 8 canales Saleae Logic 1 164€ 164€

Kit Avnet: Xilinx Spartan-3A Evaluation Kit 1 60€ 60€

Kit Texas Instruments: eZ430-RF2500 1 30€ 30€

Total: 344,00€

Ingeniería

Descripción Unidades Precio Total

Desarrollo software web 358 horas 40€ / hora 14.320€

Desarrollo software del MSP430 134 horas 60€ / hora 8.040€

Desarrollo software de la FPGA 152 horas 80€ / hora 12.160€

Documentación 198 horas 25€ / hora 4.950€

Total: 39.470,00€

TOTAL PRESUPUESTO: 39.814,00€

Tabla 12: Tabla de presupuesto del proyecto



18 Tabla de autoría de las ilustracionesMostramos en este apartado la tabla de autoría de las ilustraciones.

Número ilustración

Origen y autoría de la ilustración

1 Esquema realizado usando InkScape. Realizado por F. Quinto.

2 Reproducción con permiso de su autor: Bulavinov Sergey del blog http://bsvi.ru/klon-xilinx-platform-cable

3 Reproducción con permiso de su autor: Bulavinov Sergey del blog http://bsvi.ru/klon-xilinx-platform-cable

4 Montaje usando fotografías de la web saleae.com junto con un esquema de las dimensiones reales realizado con InkScape. Reproducido con permiso de sus fundadores (Joe and Mark Garrison). Realizado por F. Quinto.

5 Fotografía extraída del PDF: xlx-s3a-evl-pb-072309F.pdf (Avnet Product Brief Xilinx Spartan-3A Evaluation Kit)

6 Esquema de características y diagrama de bloques extraído del PDF: xlx-s3a-evl-pb-072309F.pdf (Avnet Product Brief Xilinx Spartan-3A Evaluation Kit) unidos usando GIMP. Realizado por F. Quinto.

7 Gráfico de bloques extraído del PDF: s3a_evl_block_diagram_042508.pdf

8 Montaje realizado usando InkScape y fotografías del PDF: xlx-s3a-evl-pb-072309F.pdf (Avnet Product Brief Xilinx Spartan-3A Evaluation Kit). Realizado por F. Quinto.

9 Esquema extraído del PDF: xlx_s3a_evl_ug_rev2_112008.pdf. Página 12.

10 Captura de pantalla del ordenador de desarrollo del proyecto.

11 Captura de pantalla del datasheet PDF: CY8C24894-24LFXI-Cypress-Semiconductor.pdf

12 Fotografía extraída de la web de www.cypress.com http://www.cypress.com/fckimages/Cy3217.jpg

13 Captura de pantalla del software “PSoC Programmer”.

14 Captura de pantalla del software “PSoC Programmer”.

15 Captura de pantalla del datasheet PDF: CY3217-MiniProg1 - Quick Start Guide.pdf



18 Captura de pantalla del sistema operativo. Realizado por F. Quinto.

19 Captura de pantalla de la versión del software XPS. Realizado por F. Quinto.

20 Captura de pantalla del Xilinx XPS. Realizado por F. Quinto.



23 Gráfico realizado usando InkScape. Realizado por F. Quinto.



26 Fotografía extraída de la web: http://www.ti.com/tool/ez430-rf2500

http://www.cypress.com/






28 Fotografía extraída del PDF: SLAU227e_eZ430-RF2500 Development Tool User's Guide (Rev. E). Página 6.

29 Esquema extraído del PDF: msp430f2274-ep.pdf de título “MSP430F2274-EP Mixed Signal Microcontroller (Rev. A)”. Página 3.


31 Esquema extraído del PDF: eZ430-RF2500T Schematic.pdf de título “eZ430-RF2500T_HW-V1.0_20070403.sch”. Página 1.

32 Esquema extraído del PDF: swrs040c_Low-Cost Low-Power 2.4 GHz RF Transceiver (Rev. C). Página 17.



35 Fotografía realizada por F.Quinto

36 Captura de pantalla del software Code Composer. Realizado por F. Quinto.

37 Captura de pantalla del software Code Composer. Realizado por F. Quinto.



40 Esquema extraído del PDF: slyt265e_MSP430 and Low-Power RF Devices.pdf de título “MSP430 Ultra-Low-Power MCUs and Low-Power RF Devices”. Página 1.

41 Esquema extraído del PDF: swru130b_SimpliciTI Overview (Rev. B).pdf de título “Introduction to SimpliciTI”. Página 6.

42 Esquema extraído del PDF: SimpliciTI Specification.pdf de título “SimpliciTI: Simple Modular RF Network Specification”. Página 12.

43 Esquema extraído del PDF: SimpliciTI Specification.pdf de título “SimpliciTI: Simple Modular RF Network Specification”. Página 7.


45 Captura de pantalla de la web de WAMP. Realizado por F. Quinto.

46 Gráfico del logo de PHP vectorial. Extraído de la web: http://en.wikipedia.org/wiki/File:PHP-logo.svg y libre de restricciones de copyright.

47 Captura de pantalla del software Kate mostrando parte del código. Realizado por F. Quinto.




51 Captura de pantalla del navegador mostrando el aplicativo desarrollado. Realizado por F. Quinto.





http://en.wikipedia.org/wiki/File:PHP-logo.svg

http://en.wikipedia.org/wiki/File:PHP-logo.svg








59 Captura de pantalla del diagrama de Gantt realizado con el programa Gantt Project. Realizado por F. Quinto.

Tabla 13: Autoría de las ilustraciones



19 Referencias: Bibliografía / ConsultasPara la elaboración de este apartado la norma de referencia utilizada para crear referencias

bibliográficas de documentos electrónicos ha sido la ISO 690:2010. Se escoge ésta como

referente internacional de creación de referencias bibliográficas y de inclusión de citaciones

de otros autores en la propia obra.

• [1] SILICA. Xilinx Spartan-3A Evaluation Kit. Comercial information sheet. Avnet, 2008.

• [2] Avnet Employee, bhfletcher. (27/11/2009). “Re: PSoC firmware v1.1 and AVProg

3.41” [Mensaje 6]. Mensaje enviado a <http://community.em.avnet.com/t5/Spartan-

3A-Evaluation-Kit/PSoC-firmware-v1-1-and-AVProg-3-41/m-p/434#M134>

• [3] LABROSSE, Jean J. MICROC/OS-II: The real-time kernel. Segunda edición. EEUU:

CMP Books, Junio 2002. 648 páginas. ISBN-13: 978-1-5782-0103-7

• DAVIES, John H. MSP430 Microcontroller Basics. EEUU: Newnes (Elsevier), Agosto 2008.

685 páginas. ISBN-13: 978-0-7506-8276-3

• LUECKE, Gerald. Analog and Digital Circuits for Electronic Control System Applications:

using the TI MSP430 Microcontroller. EEUU: Newnes (Elsevier), Septiembre 2004. 328

páginas. ISBN-13: 978-0-7506-7810-0

• Chipcon Products from Texas Instruments. CC2420 Datasheet. [En línea]

<http://enaweb.eng.yale.edu/drupal/system/files/CC2420_Data_Sheet_1_4.pdf>

[Consulta: 25 de Septiembre de 2009]

• Wireless Sensor Networks – Selection Of Routing Protocol For Applications. Y.Li y

T.Newe.

Melbourne : s.n., December 2006. Australian Telecommunication Networks and

Application Conference.

• Sohraby, Kazem, Minoli, Daniel and Znati, Taieb. Wireless Sensor Networks.

Technology, Protocols and Applications. Hoboken : John Wiley & Sons, Inc. , 2007.

http://enaweb.eng.yale.edu/drupal/system/files/CC2420_Data_Sheet_1_4.pdf

http://community.em.avnet.com/t5/Spartan-3A-Evaluation-Kit/PSoC-firmware-v1-1-and-AVProg-3-41/m-p/434#M134

http://community.em.avnet.com/t5/Spartan-3A-Evaluation-Kit/PSoC-firmware-v1-1-and-AVProg-3-41/m-p/434#M134



• Texas Instruments Incorporated. MSP430F15x, MSP430F16x, MSP430F161x MIXED SIGNAL

MICROCONTROLLER. [En línea]

<http://focus.ti.com/lit/ds/symlink/msp430f1611.pdf> [Consulta: 10 de octubre de

2009]

• NOBS, Samuel. “Reconfigurable Hardware OS Prototype – Part CPU”. Tutor: Herbert

Walder. Swiss Federal Institute of Technology Zurich, Computer Engineering and

Networks Laboratory, 2004.

• WATTEYNE, Thomas. “eZWSN: Experimenting with Wireless Sensor Networks using the

eZ430-RF2500”. Rice University, Houston, Texas. 2009.

<http://cnx.org/content/col10684/1.10/>

• ALMERICH, Omar y FLORES, Jose Daniel. “Diseño e implementación de un radiomódem

energéticamente autosuficiente”. Director: Gabriel Montoro López. Escola Politècnica

Superior de Castelldefels, UPC. 2010.

http://cnx.org/content/col10684/1.10/

http://focus.ti.com/lit/ds/symlink/msp430f1611.pdf

PROYECTO FINAL DE CARRERA

Y MÁSTER TESIS

ANEXOS

VOLUMEN II

Estudios:

Ingeniería Electrónica y

Máster Universitario en Ingeniería Electrónica

Autor: Quinto Recio, Francisco José

Director: Moreno Aróstegui, Juan Manuel

Año: 2013



20 Anexo A: Código fuente

20.1 Avnet FPGAapplication.c

/*********************************************************************************************************** Author : FQuinto* File: application.c* v. 1.00 | 2012-06-14 | First release**********************************************************************************************************/

#include <stdio.h>#include "includes.h"

#define char_c 99 // tecla c = 0x63#define char_C 67 // tecla C = 0x43#define char_t 116 // tecla t = 0x74#define char_T 84 // tecla T = 0x54#define CRTL_C 3 // tecla CONTROL+C = 0x3

/*********************************************************************************************************** GLOBAL VARIABLES**********************************************************************************************************/

static OS_STK AppTaskFirstStk [APP_TASK_FIRST_STK_SIZE]; /* Start task stack */static OS_STK AppTaskSecondStk [APP_TASK_SECOND_STK_SIZE]; /* Start task stack */static OS_STK AppTaskUARTStk [APP_TASK_UART_STK_SIZE]; /* Start task stack */

INT8U tecla;

/*********************************************************************************************************** PROTOTYPES**********************************************************************************************************/

static void AppTaskFirst(void *p_arg);static void AppTaskSecond(void *p_arg);static void AppTaskUART(void *p_arg);static void AppTaskCreate ();

/*********************************************************************************************************** main()* * Descripció: Aquest és el punt d'entrada estàndar de C. main() fa el següent:* * 1) Inicialitza el sistema operatiu* 2) Crea una primera tasca* 3) Inicia el sistema operatiu** Arguments : Cap**********************************************************************************************************/

int main (void){ if (DEBUG) xil_printf("DEBUG: INSIDE main\n\r");

CPU_INT08U err;

// inicialització de la variable que conté el caràcter rebut //caracter = 0; tecla = 0; // S'inhabiliten les interrupcions fins que el sistema operatiu no estigui inicialitzat if (DEBUG)



xil_printf("DEBUG: GOING BSP_IntDisAll\n\r");

BSP_IntDisAll(); if (DEBUG) xil_printf("DEBUG: GOING OSInit\n\r");

OSInit(); // Inicialitza el sistema operatiu

OSTaskCreateExt(AppTaskFirst, (void *)0, &AppTaskFirstStk[APP_TASK_FIRST_STK_SIZE - 1], APP_TASK_FIRST_PRIO, APP_TASK_FIRST_ID, &AppTaskFirstStk[0], APP_TASK_FIRST_STK_SIZE, (void *)0, OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR); OSTaskNameSet(APP_TASK_FIRST_PRIO, (CPU_INT08U *)"App Task First", &err);

// Aquesta funció proporciona un nom a la tasca dins del sistema operatiu // Només s'utilitza a efectes de depuració //OSTaskNameSet(TASK1_PRIO, (CPU_INT08U *)"InterficieControl", &err); if (DEBUG) { xil_printf("DEBUG: GOING OSStart\n\r"); }

OSStart(); //Inicia el sistema operatiu

return 0; }

/*********************************************************************************************************** AppTaskFirst()* * Description: This is the first task executed by uC/OS-II following OSStart()* * Arguments : p_arg Argument passed to this task when task is created. The argument is not used.** Returns : None**********************************************************************************************************/#define LEDS 4 // S3A400 - number of LEDS on the boardstatic void AppTaskFirst (void *p_arg){ if (DEBUG) xil_printf("DEBUG: INSIDE AppTaskFirst\n\r");

p_arg = p_arg; /* Prevent compiler warning by doing something with argument */ BSP_InitIO(); /* Initialize the I/Os */

#if OS_TASK_STAT_EN > 0 OSStatInit(); /* Initialize uC/OS-II's statistics */#endif

AppTaskCreate(); /* La resta de tasques de l'aplicació es crean normalment */ /* dins d'una altra funció per tal de mantenir neta la secció */ /* de codi corresponent a la funció m */

int led = 0; // S3A400 - initialize LED selector

while (1) { if (DEBUG) xil_printf("DEBUG: INSIDE AppTaskFirst while\n\r"); //BSP_LEDToggle(led + 1); // S3A400 - Light selected LED, all others off OSTimeDlyHMSM(0,0,5,0); // Release the CPU (every 5 second)

//led = (led + 1) % LEDS; // S3A400 - Select next LED }}

/*********************************************************************************************************** AppTaskSecond()* * Description: This task was added to perform any generic task.* * Arguments : p_arg Argument passed to this task when task is created. The argument is a string.*



* Returns : None**********************************************************************************************************/static void AppTaskSecond (void *p_arg){ if (DEBUG) xil_printf("DEBUG: INSIDE AppTaskSecond\n\r");

p_arg = p_arg; while (1) { if (DEBUG) xil_printf("DEBUG: INSIDE AppTaskSecond while\n\r"); procesa_comandos(); OSTimeDlyHMSM(0,0,0,500); // 500m second }}

/*********************************************************************************************************** AppTaskUART()* * Description: This task was added to perform any generic task.* * Arguments : p_arg Argument passed to this task when task is created. The argument is a string.** Returns : None**********************************************************************************************************/static void AppTaskUART (void *p_arg){ if (DEBUG) xil_printf("DEBUG: INSIDE AppTaskUART\n\r");

p_arg = p_arg; while (1) { if (DEBUG) xil_printf("DEBUG: INSIDE AppTaskUART while\n\r"); enviaMSP430(ReceiveBuffer); OSTimeDlyHMSM(0,0,0,500); // 500m second }}

/*********************************************************************************************************** AppTaskCreate()* * Descripció: Funció separada per generar la resta de tasques de l'aplicació* * Arguments : Cap** Returna : Res**********************************************************************************************************/

static void AppTaskCreate (void){ if (DEBUG) xil_printf("DEBUG: INSIDE AppTaskCreate\n\r");

CPU_INT08U err; /* Crea la segunda tarea de la aplicación */ OSTaskCreateExt(AppTaskSecond, (void *)0, &AppTaskSecondStk[APP_TASK_SECOND_STK_SIZE - 1], APP_TASK_SECOND_PRIO, APP_TASK_SECOND_ID, &AppTaskSecondStk[0], APP_TASK_SECOND_STK_SIZE, (void *)0, OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR); OSTaskNameSet(APP_TASK_SECOND_PRIO, (CPU_INT08U *)"App Task Second", &err); /* Crea la segunda tarea de la aplicación */ OSTaskCreateExt(AppTaskUART, (void *)0,



&AppTaskUARTStk[APP_TASK_UART_STK_SIZE - 1], APP_TASK_UART_PRIO, APP_TASK_UART_ID, &AppTaskUARTStk[0], APP_TASK_UART_STK_SIZE, (void *)0, OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR); OSTaskNameSet(APP_TASK_UART_PRIO, (CPU_INT08U *)"App Task UART", &err);}

application.h

/*********************************************************************************************************** Author : FQuinto* File: application.h* v. 1.00 | 2012-06-14 | First release**********************************************************************************************************/

/*********************************************************************************************************** TASKS PRIORITIES**********************************************************************************************************/

#define APP_TASK_FIRST_ID 2#define APP_TASK_SECOND_ID APP_TASK_FIRST_ID + 1#define APP_TASK_UART_ID APP_TASK_SECOND_ID + 1#define APP_TASK_FIRST_PRIO 3#define APP_TASK_SECOND_PRIO APP_TASK_FIRST_PRIO - 1#define APP_TASK_UART_PRIO APP_TASK_SECOND_PRIO - 1/*********************************************************************************************************** STACK SIZES* Size of the task stacks (# of OS_STK entries)**********************************************************************************************************/

#define APP_TASK_FIRST_STK_SIZE 256#define APP_TASK_SECOND_STK_SIZE APP_TASK_FIRST_STK_SIZE#define APP_TASK_UART_STK_SIZE APP_TASK_FIRST_STK_SIZE

bsp.c

/*********************************************************************************************************** Author : FQuinto* File: bsp.c* v. 1.00 | 2012-06-14 | First release********************************************************************************************************** UART EXAMPLES: C:\Xilinx\12.3\ISE_DS\EDK\sw\XilinxProcessorIPLib\drivers\uartlite_v2_00_a\examples\*/

#include <stdio.h>#include "includes.h"

/*********************************************************************************************************** LOCAL GLOBAL VARIABLES**********************************************************************************************************/

XUartLite UartLite1; /* The instance of the UartLite Device MSP430 */XUartLite UartLite2; /* The instance of the UartLite Device USB */

XIntc int_ctl;

/* work loop semaphores */INT8U sCommandSem = 0;INT8U sSendUARTMSP430Sem = 0;INT8U waitingresponse = 0;

static INT8U headResponseData;/*



* cmd_check: Return 1 if diferent, return 0 if equal */int cmd_check( char* string ){ int i,diferentes; int length = strlen(string); diferentes = 0; for( i = 0; i < length; i++) { if (comando[i] == string[i]) { diferentes = 1; } else { return 0; } } return diferentes;}

/*********************************************************************************************************** BSP_LEDOn()** Description : This function is used to control any or all the LEDs on the board.** Arguments : led is the number of the LED to control** Returns : None**********************************************************************************************************/

void BSP_LEDOn (INT8U led){ if (DEBUG) xil_printf("DEBUG: INSIDE BSP_LEDOn\n\r");

INT32U led_status;

#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */ OS_CPU_SR cpu_sr;#endif

led_status = XGpio_ReadReg(BSP_GPIO_ADDR,1);

OS_ENTER_CRITICAL(); switch (led) { case 0: led_status |= 0x0000000F; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 1: led_status |= 0x00000001; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 2: led_status |= 0x00000002; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 3: led_status |= 0x00000004; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 4: led_status |= 0x00000008; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; } OS_EXIT_CRITICAL();}

/*********************************************************************************************************** BSP_LEDOff()** Description : This function is used to control any or all the LEDs on the board.** Arguments : led is the number of the LED to turn OFF** Returns : None**********************************************************************************************************/



void BSP_LEDOff (INT8U led){ if (DEBUG) xil_printf("DEBUG: INSIDE BSP_LEDOff\n\r");

INT32U led_status;



OS_ENTER_CRITICAL(); switch (led) { case 0: led_status &= ~0x0000000F; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 1: led_status &= ~0x00000001; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 2: led_status &= ~0x00000002; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 3: led_status &= ~0x00000004; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 4: led_status &= ~0x00000008; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; } OS_EXIT_CRITICAL();}

/*********************************************************************************************************** LED_Get()** Description : This function is used to retrieve the LED state.** Arguments : None** Returns : Contents of the LED data register.**********************************************************************************************************/

INT32U LED_Get (void){ return(XGpio_ReadReg(BSP_GPIO_ADDR,1));}

/*********************************************************************************************************** Button_Get()** Description : This function is used to retrieve the button state.** Arguments : None** Returns : Contents of the button data register.**********************************************************************************************************/

INT32U Button_Get (void){ return(XGpio_ReadReg(BSP_BUTTON_ADDR,1));}

/*********************************************************************************************************** BSP_LEDToggle()** Description : This function is used to alternate the state of an LED** Arguments : led is the number of the LED to control** Returns : None*********************************************************************************************************



*/

void BSP_LEDToggle (INT8U led){ //if (DEBUG) //xil_printf("DEBUG: INSIDE BSP_LEDToggle\n\r");

INT32U led_status;



OS_ENTER_CRITICAL(); switch (led) { case 0: led_status ^= 0x0000000F; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 1: led_status ^= 0x00000001; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 2: led_status ^= 0x00000002; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 3: led_status ^= 0x00000004; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; case 4: led_status ^= 0x00000008; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); break; } OS_EXIT_CRITICAL();

}

/*********************************************************************************************************** BSP_LEDInit()** Description: This function initializes all of the board's LEDs** Arguments : None** Returns : None**********************************************************************************************************/

void BSP_LEDInit (void){ if (DEBUG) xil_printf("DEBUG: INSIDE BSP_LEDInit\n\r");

XGpio_WriteReg(BSP_GPIO_ADDR, XGPIO_TRI_OFFSET, 0x00000000); BSP_LEDOff(0); /* Turn off all of the LEDs */}

// BUTTON START/*********************************************************************************************************** button_read()** Description: This function read the button pushed** Arguments : None** Returns : INT32U**********************************************************************************************************/INT32U button_read(void){ //if (DEBUG) //xil_printf("DEBUG: INSIDE button_read\n\r");

INT32U current_state = 0; static INT32U button_latched_state = 0;

// Read the current button input.



current_state = Button_Get();

// Check to see if a button is depreseed or not, latch a button press // to the upper 16 bits of the latched button state. button_latched_state |= (current_state << 16);

return (button_latched_state | current_state);}

/*********************************************************************************************************** button_check_state()** Description: This function check the state of button** Arguments : INT32U bitno, INT32U push_button_state, INT32U push_button_state_change** Returns : None**********************************************************************************************************/void button_check_state(INT32U bitno, INT32U push_button_state, INT32U push_button_state_change){ if (DEBUG) xil_printf("DEBUG: INSIDE button_check_state\n\r");

// Check to see if pushbutton EFx has changed state. if ((push_button_state_change & (1 << bitno)) == (1 << bitno)) { // Erase current line so that it can be typed over. xil_printf("\033[2K");

// Display the current button state. xil_printf("Jboton");

if (bitno == 0) { xil_printf("A"); } else if (bitno == 1) { xil_printf("B"); } else if (bitno == 2) { xil_printf("C"); } else { xil_printf("?"); }

// EFx state was changed, determine what the new state is. if ((push_button_state & (1 << bitno)) == (1 << bitno)) { // The push button was activated. xil_printf("_on"); } else { // The push button was deactivated. xil_printf("_off"); }

xil_printf("\r"); }}

// ---------------------------------------------------------------------------void button_display_state_all(void){ if (DEBUG) xil_printf("DEBUG: INSIDE button_display_state_all\n\r");

INT32U push_button_state = 0;

// The current push button state should be read to determine the // state of each of the push buttons. push_button_state = button_read();

// Display the current state of the EFA button. button_display_state_single(2, push_button_state);

// Determine the state of the EFB button. button_display_state_single(1, push_button_state);



// Determine the state of the EFC button. button_display_state_single(0, push_button_state);

xil_printf("* EF4: Connected To FPGA System Reset *\r\n");}

// ---------------------------------------------------------------------------void button_display_state_single(INT32U bitno, INT32U push_button_state){ xil_printf("Jboton");

if (bitno == 0) { xil_printf("A"); } else if (bitno == 1) { xil_printf("B"); } else if (bitno == 2) { xil_printf("C"); } else { xil_printf("?"); }

xil_printf(": ");

// EFx state was changed, determine what the new state is. if ((push_button_state & (1 << bitno)) == (1 << bitno)) { // The push button was activated. xil_printf("_on"); } else { // The push button was deactivated. xil_printf("_off"); }

xil_printf("\r");}

// ---------------------------------------------------------------------------int button_process(void){ int push_button_index; int push_button_change_deteted = BUTTON_STATE_NO_CHANGE; INT32U push_button_current_state = 0; INT32U push_button_state_change = 0; static INT32U push_button_state = 0;

// The current push button state should be read and compared to the // previous state to determine if a button was pressed or not. push_button_current_state = button_read();

if (push_button_current_state != push_button_state) { // A button state change was detected, determine which buttons // have changed state. The XOR operator will highlight which // bits have changed state. push_button_state_change = push_button_current_state ^ push_button_state;

for (push_button_index = 0; push_button_index < BUTTON_COUNT; push_button_index++) { // Check to see if push button EFx has changed state. button_check_state(push_button_index, push_button_current_state, push_button_state_change); }

// Update the push button state with the current status. push_button_state = push_button_current_state;

// Since a push button state change was detected, return a // status indicating so. push_button_change_deteted = BUTTON_STATE_CHANGE; }

return push_button_change_deteted;}



/*********************************************************************************************************** BSP_Timer0Handler()* * Description: This function services interrupts produced by the timer counter. These interrupts serve* as uC/OS-II's tick source.

* Arguments : baseaddr_p is a pointer to the XTmrCtr driver structure** Returns : None**********************************************************************************************************/

void BSP_Timer0Handler (void *baseaddr_p){ INT32S baseaddr; INT32U csr;

baseaddr = *(INT32S *)baseaddr_p; csr = XTmrCtr_GetControlStatusReg(BSP_TIMER0_ADDR, 0); if (csr & XTC_CSR_INT_OCCURED_MASK) { XTmrCtr_SetControlStatusReg(BSP_TIMER0_ADDR, 0, csr); /* Notify uC/OS-II that a tick interrupt occurred */ OSTimeTick(); }}

/*********************************************************************************************************** BSP_TmrInit()** Description: This function should intialize the timers used by your application** Arguments : None** Returns : None**********************************************************************************************************/

void BSP_TmrInit (void){ /* Set the timer's period */ XTmrCtr_SetLoadReg(BSP_TIMER0_ADDR, 0, BSP_TMR_VAL); /* Reset the timer */ XTmrCtr_SetControlStatusReg(BSP_TIMER0_ADDR, 0, XTC_CSR_INT_OCCURED_MASK | XTC_CSR_LOAD_MASK); /* Start the timer */ XTmrCtr_SetControlStatusReg(BSP_TIMER0_ADDR, 0, XTC_CSR_ENABLE_TMR_MASK | XTC_CSR_ENABLE_INT_MASK | XTC_CSR_AUTO_RELOAD_MASK | XTC_CSR_DOWN_COUNT_MASK);}

/*********************************************************************************************************** BSP_IntHandler()** Description: This function is called by OS_CPU_ISR() in os_cpu_a.s to service all active interrupts * from the interrupt controller. Two versions of this function are provided. One of these * versions uses the interrupt controller's IVR to determine the highest priority pending * interrupt, while the other version consults the relevant status register. The code that * uses the IVR is capable of processing interrupts quickly, so the relatively slow code that * uses a status register is excluded with a #if 0 directive. If, however, your interrupt * controller has been modified from the default configuration and it doesn't offer the IVR, * you will need to place a #if 0 around the faster code, and include the code that is * currently ignored in your project.** Handlers for devices connected to the interrupt controller can be registered in one of * two ways: via the "Interrupt Handlers" section of your project's "Software Platform* Settings", or by calling XIntc_Connect(), which is used to register a handler for the * operating system's tick interrupt in this file's BSP_InitIntCtrl(). Both of these methods * achieve similar results, placing a pointer to your handler in the table accessed by * BSP_IntHandler(). Regardless of which method is used, then, the interrupt corresponding * to your device should be enabled by calling XIntc_Enable() or a similar function.* * Arguments : None** Returns : None**********************************************************************************************************/#if 1void BSP_IntHandler (void) { /* This handler uses the interrupt controller's IVR */ INT32U int_status; INT32U int_mask; INT32U int_vector;



XIntc_Config *CfgPtr; XIntc_VectorTableEntry *tbl_ptr;

CfgPtr = &XIntc_ConfigTable[0]; int_status = XIntc_GetIntrStatus(BSP_INTC_ADDR);

while (int_status != 0) { /* Get the interrupts waiting to be serviced */ int_vector = *(INT32U *)(BSP_INTC_ADDR + 0x00000018); int_mask = 1 << int_vector; if (((CfgPtr->AckBeforeService) & int_mask) != 0) { XIntc_AckIntr(BSP_INTC_ADDR, int_mask); } tbl_ptr = &(CfgPtr->HandlerTable[int_vector]); tbl_ptr->Handler(tbl_ptr->CallBackRef); /* Call the handler assigned to the interrupt */ if (((CfgPtr->AckBeforeService) & int_mask) == 0) { XIntc_AckIntr(BSP_INTC_ADDR, int_mask); } int_status = XIntc_GetIntrStatus(BSP_INTC_ADDR); }}#endif

#if 0void BSP_IntHandler (void) { /* This handler doesn't use the IVR */ INT32U IntrStatus; INT32U IntrMask = 1; INT32U IntrNumber; XIntc_Config *CfgPtr;

CfgPtr = &XIntc_ConfigTable[(Xuint32)BSP_INTC_DEVICE_ID];

IntrStatus = XIntc_mGetIntrStatus(CfgPtr->BaseAddress); for (IntrNumber = 0; IntrNumber < XPAR_INTC_MAX_NUM_INTR_INPUTS; IntrNumber++) { if (IntrStatus & 1) { XIntc_VectorTableEntry *TablePtr;

if (CfgPtr->AckBeforeService & IntrMask) { XIntc_mAckIntr(CfgPtr->BaseAddress, IntrMask); }

TablePtr = &(CfgPtr->HandlerTable[IntrNumber]); TablePtr->Handler(TablePtr->CallBackRef);

if ((CfgPtr->AckBeforeService & IntrMask) == 0) { XIntc_mAckIntr(CfgPtr->BaseAddress, IntrMask); }

if (CfgPtr->Options == XIN_SVC_SGL_ISR_OPTION) { return; } }

IntrMask <<= 1; IntrStatus >>= 1; if (IntrStatus == 0) { break; } } }#endif

/*********************************************************************************************************** BSP_IntDisAll()* * Description: Disable all interrupts at the interrupt controller.** Arguments : None** Returns : None



**********************************************************************************************************/

void BSP_IntDisAll (void){ if (DEBUG) xil_printf("DEBUG: INSIDE BSP_IntDisAll\n\r");

XIntc_MasterDisable(BSP_INTC_ADDR);}

/*********************************************************************************************************** BSP_InitIntCtrl()** Description: This function initializes the interrupt controller by registering the appropriate handler* functions and enabling interrupts.** Arguments : None** Returns : None**********************************************************************************************************/

void BSP_InitIntCtrl (XIic *IicInstPtr, XUartLite *UartLitePtrMSP430, XUartLite *UartLitePtrUSB){ XStatus init_status;

/* Initialize a handle for the interrupt controller */ init_status = XIntc_Initialize(&int_ctl, BSP_INTC_DEVICE_ID); /* Connect the first timer with its handler */ init_status = XIntc_Connect(&int_ctl, BSP_INTC_TIMER0_ID,BSP_Timer0Handler,(void *)0); /* Connect the IIC device with its handler */ init_status = XIntc_Connect(&int_ctl, IIC_INTR_ID,(XInterruptHandler) XIic_InterruptHandler,IicInstPtr); /* Connect the MSP430 UART device with its handler */ init_status = XIntc_Connect(&int_ctl, MSP430_INTR_ID,(XInterruptHandler)XUartLite_InterruptHandler, (void *)UartLitePtrMSP430); /* Connect the USB UART device with its handler */ init_status = XIntc_Connect(&int_ctl, USB_INTR_ID,(XInterruptHandler)XUartLite_InterruptHandler, (void *)UartLitePtrUSB); /* Enable interrupts from the first timer */ XIntc_Enable(&int_ctl, BSP_INTC_TIMER0_ID); /* Enable interrupts from the IIC device */ XIntc_Enable(&int_ctl, IIC_INTR_ID); /* Enable interrupts from the MSP430 UART device */ XIntc_Enable(&int_ctl, MSP430_INTR_ID); /* Enable interrupts from the USB UART device */ XIntc_Enable(&int_ctl, USB_INTR_ID); /* Start the interrupt controller */ init_status = XIntc_Start(&int_ctl, XIN_REAL_MODE); /* * Initialize the exception table. */ //Xil_ExceptionInit();

/* * Register the interrupt controller handler with the exception table. */ //Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, //(Xil_ExceptionHandler)XIntc_InterruptHandler, //&int_ctl);

/* * Enable exceptions. */ //Xil_ExceptionEnable();

}

/*********************************************************************************************************** BSP_IicInit()** Description: This function initializes the IIC device** Arguments : None** Returns : None



**********************************************************************************************************/

void BSP_IicInit (void){ //u8 Index; int Index; XStatus init_status;

/* Initialize the IIC Instance */ init_status = XIic_Initialize(&IicInstance, IIC_DEVICE_ID); /* Set the Transmit and Receive handlers */ XIic_SetSendHandler(&IicInstance, &IicInstance,(XIic_Handler) SendHandler); XIic_SetRecvHandler(&IicInstance, &IicInstance,(XIic_Handler) ReceiveHandler); /* Set the address of the slave */ init_status = XIic_SetAddress(&IicInstance, XII_ADDR_TO_SEND_TYPE,SLAVE_ADDRESS); /* MSP430 UART */ /* Initialize the instance */ if (XUartLite_Initialize(&UartLite1, MSP430_DEVICE_ID)!=XST_SUCCESS) printf("Error initialize MSP430" ); if (XUartLite_SelfTest(&UartLite1)!=XST_SUCCESS) printf("Error selftest MSP430" ); XUartLite_ResetFifos(&UartLite1); /* Set the Transmit and Receive handlers */ //XUartLite_SetSendHandler(&UartLite1, SendHandlerMSP430, &UartLite1); XUartLite_SetRecvHandler(&UartLite1, RecvHandlerMSP430, &UartLite1); XUartLite_ResetFifos(&UartLite1); /* Enable the interrupt of the UartLite so that interrupts will occur. */ XUartLite_EnableInterrupt(&UartLite1); /* USB UART */ /* Initialize the instance */ if (XUartLite_Initialize(&UartLite2, USB_DEVICE_ID)!=XST_SUCCESS) printf("Error initialize USB" ); if (XUartLite_SelfTest(&UartLite2)!=XST_SUCCESS) printf("Error selftest USB" ); XUartLite_ResetFifos(&UartLite2); /* Set the Transmit and Receive handlers */ //XUartLite_SetSendHandler(&UartLite2, SendHandlerUSB, &UartLite2); XUartLite_SetRecvHandler(&UartLite2, RecvHandlerUSB, &UartLite2); XUartLite_ResetFifos(&UartLite2); /* Enable the interrupt of the UartLite so that interrupts will occur. */ XUartLite_EnableInterrupt(&UartLite2); /* * Initialize the send buffer bytes with a pattern to send and the * the receive buffer bytes to zero to allow the receive data to be * verified. */ for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) { SendBuffer[Index] = Index; ReceiveBuffer[Index] = 0; } /* * Write two bytes to the IIC Slave to set the PointerRegister to * address the Configuration Register and set it to 12-bit * resolution (r[1:0] = b11). */ WriteBuffer[0] = 0x01; // Address Configuration register WriteBuffer[1] = 0x60; // Set 12-bit resolution WriteData(2); /* * Write one byte to the IIC Slave to set the PointerRegister to * address the Temperature Register */ WriteBuffer[0] = 0; WriteData(1); /* * Initialize the the read buffer (temperature) */ for (Index = 0; Index < SEND_COUNT; Index++) { ReadBuffer[Index] = 0; }}

/*********************************************************************************************************** SendHandler()** Description: This Send handler is called asynchronously from an interrupt context and* indicates that data in the specified buffer has been sent.



** Arguments : None** Returns : None**********************************************************************************************************/void SendHandler(XIic * InstancePtr){ TransmitComplete = 0;}

/*********************************************************************************************************** ReceiveHandler()** Description: This Send handler is called asynchronously from an interrupt context and* indicates that data in the specified buffer has been received.** Arguments : None** Returns : None**********************************************************************************************************/void ReceiveHandler(XIic * InstancePtr){ ReceiveComplete = 0;}

/*****************************************************************************//**** This function is the handler which performs processing to send data to the* UartLite. It is called from an interrupt context such that the amount of* processing performed should be minimized. It is called when the transmit* FIFO of the UartLite is empty and more data can be sent through the UartLite.** This handler provides an example of how to handle data for the UartLite,* but is application specific.** @param CallBackRef contains a callback reference from the driver.* In this case it is the instance pointer for the UartLite driver.* @param EventData contains the number of bytes sent or received for sent* and receive events.** @return None.** @note None.*****************************************************************************//*void SendHandlerMSP430(void *CallBackRef, unsigned int EventData){ //XTft_Write(&TftInstance,'S'); TotalSentCountMSP430 = EventData; if (DEBUG) xil_printf("DEBUG: INSIDE SendHandlerMSP430\n\r");}*//****************************************************************************//**** This function is the handler which performs processing to receive data from* the UartLite. It is called from an interrupt context such that the amount of* processing performed should be minimized. It is called data is present in* the receive FIFO of the UartLite such that the data can be retrieved from* the UartLite. The size of the data present in the FIFO is not known when* this function is called.** This handler provides an example of how to handle data for the UartLite,* but is application specific.** @param CallBackRef contains a callback reference from the driver, in* this case it is the instance pointer for the UartLite driver.* @param EventData contains the number of bytes sent or received for sent* and receive events.** @return None.** @note None.*****************************************************************************/void RecvHandlerMSP430(void *CallBackRef, unsigned int EventData){ unsigned int ReceivedCount = 0;



int Index; int i=0; int newBuffer = TEST_BUFFER_SIZE -1; u8 data;

TotalReceivedCountMSP430 = EventData; if (DEBUG) xil_printf("DEBUG: INSIDE RecvHandlerMSP430\n\r"); while (1) { ReceivedCount += XUartLite_Recv(&UartLite1, ReceiveBuffer + ReceivedCount, TEST_BUFFER_SIZE - ReceivedCount); if (ReceivedCount == TEST_BUFFER_SIZE) { if (DEBUG) xil_printf("DEBUG: RecvHandlerMSP430 TEST_BUFFER_SIZE exit\n\r"); break; } /* if (ReceivedCount == newBuffer) { if (DEBUG) xil_printf("DEBUG: RecvHandlerMSP430 newBuffer exit\n\r"); break; } if ( (ReceiveBuffer[i] == 0x0d) && (i>0) ) { if (DEBUG) xil_printf("DEBUG: RecvHandlerMSP430 0x0d i \n\r"); break; } ++i; */ } if (DEBUG) xil_printf("DEBUG: RecvHandlerMSP430 while exit!\n\r"); /* check received message structure * [0] = data is from (3 = C = x43) or (6 = F = x46) or (9 = I = x49) * [1] = data is from (R = x52) or (W = x57) * [7] = data is from (\r = x0d = d13) */ if ( (ReceiveBuffer[0]==0x43) || (ReceiveBuffer[0]==0x46) || (ReceiveBuffer[0]==0x49) ) { if ( (ReceiveBuffer[1]==0x52) || (ReceiveBuffer[1]==0x57) ) { if ( ReceiveBuffer[7]==0x0d ) { /* set semaphore */ sCommandSem = 1; } } } /* mensaje recibido por comprobación de la estructura */ if (sCommandSem) { if ( waitingresponse == 0 ) { /* process command received */ if (DEBUG) xil_printf("DEBUG: RecvHandlerMSP430 waitingresponse=0\n\r"); /* save command */ for (i=0; i<=(SIZE_COMANDO-1); ++i) // maximo = SIZE_COMANDO-1 { comando[i] = ReceiveBuffer[i+1]; // el comando no tiene cabecera, empiezo desde el 1 } if ( cmd_check("R") ) { /* read message = response, set header */ /* set header */ switch (ReceiveBuffer[0]) { case 0x43: // mensaje C (3): PC->FG headResponseData = 0x4A; // mensaje J (10): FG->PC break; case 0x46: // mensaje F (6): AP->FG headResponseData = 0x4B; // mensaje K (11): FG->AP break; case 0x49: // mensaje I (9): ED->FG headResponseData = 0x4C; // mensaje L (12): FG->ED break; default: ; }



} if ( cmd_check("W") ) { /* write message = no response, only process */ headResponseData = 0x00; } } else { /* return data received to USB UART */ if (DEBUG) xil_printf("DEBUG: RecvHandlerMSP430 waitingresponse=1\n\r");

/* clear semaphore */ sCommandSem = 0; waitingresponse = 0; } /* DEBUG: print buffer */ /* for (Index = 0; Index < newBuffer; Index++) { if ( (ReceiveBuffer[Index]!=0x0D) && (ReceiveBuffer[Index]!=0x0A) ) { xil_printf("%c",ReceiveBuffer[Index]); } } xil_printf("\r\n"); */ /* DEBUG: see data */ for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) { xil_printf("tecla: "); if (ReceiveBuffer[Index]==0x0D) { xil_printf(" (0x0D"); } else if (ReceiveBuffer[Index]==0x0A) { xil_printf(" (0x0A"); } else { xil_printf("%c (",ReceiveBuffer[Index]); xil_printf("0x%x",ReceiveBuffer[Index]); } xil_printf(")\r\n"); } } /* if(!XUartLite_IsReceiveEmpty(XPAR_MSP430_UART_BASEADDR)) { data = XUartLite_ReadReg(XPAR_MSP430_UART_BASEADDR, XUL_RX_FIFO_OFFSET); // receive FIFO, read only xil_printf("DEBUG: enviaMSP430 data:%x\n\r",data); } */ /* reset fifos */ //if (DEBUG) //xil_printf("DEBUG: RecvHandlerMSP430 reset fifos!\n\r"); //XUartLite_ResetFifos(&UartLite1); //XUartLite_EnableIntr(XPAR_MSP430_UART_BASEADDR); if (DEBUG) xil_printf("DEBUG: RecvHandlerMSP430 EXIT!\n\r");}

/*****************************************************************************//**** This function is the handler which performs processing to send data to the* UartLite. It is called from an interrupt context such that the amount of* processing performed should be minimized. It is called when the transmit* FIFO of the UartLite is empty and more data can be sent through the UartLite.** This handler provides an example of how to handle data for the UartLite,* but is application specific.** @param CallBackRef contains a callback reference from the driver.* In this case it is the instance pointer for the UartLite driver.* @param EventData contains the number of bytes sent or received for sent* and receive events.** @return None.** @note None.*



****************************************************************************//*void SendHandlerUSB(void *CallBackRef, unsigned int EventData){ //XTft_Write(&TftInstance,'S'); TotalSentCountUSB = EventData; if (DEBUG) xil_printf("DEBUG: INSIDE SendHandlerUSB\n\r");}*//****************************************************************************//**** This function is the handler which performs processing to receive data from* the UartLite. It is called from an interrupt context such that the amount of* processing performed should be minimized. It is called data is present in* the receive FIFO of the UartLite such that the data can be retrieved from* the UartLite. The size of the data present in the FIFO is not known when* this function is called.** This handler provides an example of how to handle data for the UartLite,* but is application specific.** @param CallBackRef contains a callback reference from the driver, in* this case it is the instance pointer for the UartLite driver.* @param EventData contains the number of bytes sent or received for sent* and receive events.** @return None.** @note None.*****************************************************************************/void RecvHandlerUSB(void *CallBackRef, unsigned int EventData){ unsigned int ReceivedCount = 0; int Index; int i=0; int newBuffer = TEST_BUFFER_SIZE -1; u8 data; TotalReceivedCountUSB = EventData; if (DEBUG) xil_printf("DEBUG: INSIDE RecvHandlerUSB\n\r"); while (1) { ReceivedCount += XUartLite_Recv(&UartLite2, ReceiveBuffer + ReceivedCount, newBuffer - ReceivedCount); if ( ReceivedCount == newBuffer ) { break; } if ( (ReceiveBuffer[i] == 0x0d) && (i>0) ) { break; } ++i; } /* check received message structure * [0] = data is from (10 = J = x4A) or (11 = K = x4B) or (12 = L = x4C) * [1] = data is from (R = x52) or (W = x57) * [7] = data is from (\r = x0d = d13) */ if ( (ReceiveBuffer[0]==0x4A) || (ReceiveBuffer[0]==0x4B) || (ReceiveBuffer[0]==0x4C) ) { if ( (ReceiveBuffer[1]==0x52) || (ReceiveBuffer[1]==0x57) ) { if ( ReceiveBuffer[7]==0x0d ) { /* set semaphore */ sSendUARTMSP430Sem = 1; } } } /* send data using UART MSP430 */ if (sSendUARTMSP430Sem) { /* save command */ for (i=0; i<=(SIZE_COMANDO-1); ++i) // maximo = SIZE_COMANDO-1 { comando[i] = ReceiveBuffer[i+1]; // el comando no tiene cabecera, empiezo desde el 1 }



if ( cmd_check("R") ) { /* set semaphore */ waitingresponse = 1; } /* print buffer */ for (Index = 0; Index < newBuffer; Index++) { if (ReceiveBuffer[Index]==0x0D) { //xil_printf(" (0x0D"); } else if (ReceiveBuffer[Index]==0x0A) { //xil_printf(" (0x0A"); } else { xil_printf("%c",ReceiveBuffer[Index]); } //xil_printf(")\r\n"); } xil_printf("\r\n"); } /* if(!XUartLite_IsReceiveEmpty(XPAR_MSP430_UART_BASEADDR)) { data = XUartLite_ReadReg(XPAR_MSP430_UART_BASEADDR, XUL_RX_FIFO_OFFSET); // receive FIFO, read only xil_printf("DEBUG: enviaMSP430 data:%x\n\r",data); } */ /* reset fifos */ //XUartLite_ResetFifos(&UartLite2); //XUartLite_EnableIntr(XPAR_USB_UART_BASEADDR);}

void enviaMSP430(u8 data2MSP430[]){ int newBuffer = TEST_BUFFER_SIZE -1; int Index=0; u8 data; if (DEBUG) xil_printf("DEBUG: enviaMSP430()\n\r"); if (sSendUARTMSP430Sem) { if (DEBUG) xil_printf("DEBUG: enviaMSP430 sSendUARTMSP430Sem=1\n\r"); /* if(!XUartLite_IsReceiveEmpty(XPAR_MSP430_UART_BASEADDR)) { data = XUartLite_ReadReg(XPAR_MSP430_UART_BASEADDR, XUL_RX_FIFO_OFFSET); // receive FIFO, read only xil_printf("DEBUG: enviaMSP430 data1:%x\n\r",data); } */ /* disable interruptions */ if (DEBUG) xil_printf("DEBUG: enviaMSP430 inter disable\n\r"); //XUartLite_DisableIntr(XPAR_MSP430_UART_BASEADDR); XUartLite_DisableInterrupt(&UartLite1); /* send using MPS430 UART */ if (DEBUG) xil_printf("DEBUG: enviaMSP430 start send\n\r"); for (Index = 0; Index < newBuffer; Index++) { XUartLite_SendByte(XPAR_MSP430_UART_BASEADDR,data2MSP430[Index]); } /* wait in a loop until send */ while ( XUartLite_IsSending(&UartLite1) ); if (DEBUG) xil_printf("DEBUG: enviaMSP430 end send\n\r"); /* clear semaphore */ sSendUARTMSP430Sem = 0; /* clear ReceiveBuffer */ if (DEBUG) xil_printf("DEBUG: enviaMSP430 clear ReceiveBuffer\n\r"); for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) { ReceiveBuffer[Index] = 0; } /* enable interruptions */



if (DEBUG) xil_printf("DEBUG: enviaMSP430 inter enable\n\r"); //XUartLite_EnableIntr(XPAR_MSP430_UART_BASEADDR); XUartLite_EnableInterrupt(&UartLite1); } if (DEBUG) xil_printf("DEBUG: enviaMSP430 EXIT\n\r");}

void procesa_comandos(void){ INT32U led_status; INT32U button_status; int bit; int data; int decimals; int newBuffer = TEST_BUFFER_SIZE -1; int Index; if (DEBUG) xil_printf("DEBUG: procesa_comandos()\n\r"); if (sCommandSem) { if (DEBUG) xil_printf("DEBUG: procesa_comandos sCommandSem=1\n\r"); // bit if (comando[2]=='0') { bit = BIT0; } if (comando[2]=='1') { bit = BIT1; } if (comando[2]=='2') { bit = BIT2; } if (comando[2]=='3') { bit = BIT3; } if (comando[2]=='4') { bit = BIT4; } if (comando[2]=='5') { bit = BIT5; } if (comando[2]=='6') { bit = BIT6; } if (comando[2]=='7') { bit = BIT7; } /* write message */ if ( cmd_check("W") ) { // data if (comando[5]=='1') { data = 1; } if (comando[5]=='0') { data = 0; } /* read led status */ led_status = XGpio_ReadReg(BSP_GPIO_ADDR,1); if (data) { //led off led_status &= ~bit; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); } else { //led on



led_status |= bit; XGpio_WriteReg(BSP_GPIO_ADDR,1,led_status); } /* debug */ if ( cmd_check("Wdebug") ) { if (DEBUG) { DEBUG = 0; } else { DEBUG = 1; } } } /* read message */ if ( cmd_check("R") ) { /* temperature */ if ( cmd_check("R50000") ) { ReadData(ReadBuffer, 2); /* * El primer byte representa la part sencera de la lectura de * temperatura en graus Celsius * El segon byte es la part decimal de la temperatura * Els quatre bits menys significatius del segon byte * es descarten. Els quatre bits restants representen * la part decimal de la tempetarura en fraccions de * 1/16 de grau */ decimals = (ReadBuffer[1]>>4)*10000/16; xil_printf("Temperatura actual: %d.%04d graus\n\r", ReadBuffer[0], decimals ); SendBuffer[0] = headResponseData; SendBuffer[1] = 0x52; // R SendBuffer[2] = 0x35; // 5 SendBuffer[3] = (ReadBuffer[0] / 10)+0x30; SendBuffer[4] = (ReadBuffer[0] % 10)+0x30; //atoi ( ReadBuffer[0] ); // ( "%d", ReadBuffer[0] ); SendBuffer[5] = (decimals / 1000)+0x30;//atoi ( (ReadBuffer[1]>>4)*10000/16 ); //sprintf ( "%02d", ((ReadBuffer[1]>>4)*10000/16) ); SendBuffer[6] = ((decimals % 1000)/100)+0x30; //0x30; // 0 SendBuffer[7] = 0x0d; // 0x0d = \r = 13d } if ( cmd_check("R2") ) { SendBuffer[0] = headResponseData; SendBuffer[1] = 0x52; // R SendBuffer[2] = 0x32; // 2 SendBuffer[4] = 0x30; // 0 SendBuffer[5] = 0x30; // 0 button_status = XGpio_ReadReg(BSP_BUTTON_ADDR,1); if ( (button_status & bit) == bit ) { SendBuffer[6] = 0x31; // 1 } else { SendBuffer[6] = 0x30; // 0 } SendBuffer[7] = 0x0d; // 0x0d = \r = 13d /* button 1 */ if ( cmd_check("R20000") ) { SendBuffer[3] = 0x30; // 0 } /* button 2 */ if ( cmd_check("R21000") ) { SendBuffer[3] = 0x31; // 1 } /* button 3 */ if ( cmd_check("R22000") ) { SendBuffer[3] = 0x32; // 2 } }



} if (headResponseData != 0x00) { /* set semaphore */ sSendUARTMSP430Sem = 1; /* send */ if (DEBUG) xil_printf("DEBUG: procesa_comandos SendBuffer\n\r");

for (Index = 0; Index < newBuffer; Index++) { ReceiveBuffer[Index] = SendBuffer[Index]; } //enviaMSP430(SendBuffer); } /* clear semaphore */ sCommandSem = 0; }}

/*********************************************************************************************************** BSP_InitIO()* * Description: Initialize all the I/O devices.** Arguments : None** Returns : None**********************************************************************************************************/

void BSP_InitIO (void) { BSP_InitIntCtrl(&IicInstance, &UartLite1, &UartLite2); /* Initialize the interrupt controller */ BSP_TmrInit(); /* Initialize the timers */ BSP_LEDInit(); /* Initialize LEDs */ BSP_IicInit(); /* Initialize the timers */}

bsp.h

/*********************************************************************************************************** Author : FQuinto* File: bsp.h* v. 1.00 | 2012-06-14 | First release**********************************************************************************************************/

#ifndef _BSP_H_#define _BSP_H_

#include "includes.h"

/*********************************************************************************************************** CONSTANTS**********************************************************************************************************/

#define BSP_INTC_DEVICE_ID XPAR_INTC_0_DEVICE_ID#define BSP_INTC_TIMER0_ID XPAR_INTC_0_TMRCTR_0_VEC_ID#define BSP_INTC_ADDR XPAR_INTC_0_BASEADDR#define BSP_TIMER0_ADDR XPAR_XPS_TIMER_0_BASEADDR

#define BSP_GPIO_ADDR XPAR_LEDS_4BIT_BASEADDR#define BSP_TMR_VAL (XPAR_CPU_DPLB_FREQ_HZ / OS_TICKS_PER_SEC)#define BSP_BUTTON_ADDR XPAR_CS_PUSH_3BIT_BASEADDR

// BUTTON START// Define the number of available push buttons.#define BUTTON_COUNT 3// Define the return states for the button_process.#define BUTTON_STATE_NO_CHANGE 0#define BUTTON_STATE_CHANGE 1// BUTTON END



#define IIC_DEVICE_ID XPAR_IIC_0_DEVICE_ID#define INTC_DEVICE_ID XPAR_INTC_0_DEVICE_ID#define IIC_INTR_ID XPAR_INTC_0_IIC_0_VEC_ID

// MSP430 UART#define MSP430_DEVICE_ID XPAR_UARTLITE_1_DEVICE_ID#define MSP430_INTR_ID XPAR_INTC_0_UARTLITE_1_VEC_ID

// USB UART#define USB_DEVICE_ID XPAR_UARTLITE_2_DEVICE_ID#define USB_INTR_ID XPAR_INTC_0_UARTLITE_2_VEC_ID

/* * The following constant controls the length of the buffers to be sent * and received with the UartLite device. */#define TEST_BUFFER_SIZE 9

/* * The following constant defines the address of the IIC * device on the IIC bus. This is the 7-bit value found * in the TMP100 datasheet for ADD[1:0] = b00. */#define SLAVE_ADDRESS 0x48

#define SEND_COUNT TEST_BUFFER_SIZE#define RECEIVE_COUNT TEST_BUFFER_SIZE

#define SIZE_COMANDO 6

#define BIT0 0x01#define BIT1 0x02#define BIT2 0x04#define BIT3 0x08#define BIT4 0x10#define BIT5 0x20#define BIT6 0x40#define BIT7 0x80/*********************************************************************************************************** PROTOTYPES**********************************************************************************************************/void BSP_TmrInit (void);void BSP_Init (void);void BSP_IntDisAll (void);void BSP_InitIntCtrl (XIic * IicInstPtr, XUartLite *UartLitePtrMSP430, XUartLite *UartLitePtrUSB);void BSP_InitIO (void);void BSP_IicInit (void);

void enviaMSP430(u8 data2MSP430[]);

// LED STARTINT32U LED_Get (void);void BSP_LEDToggle (INT8U led);void BSP_LEDOff (INT8U led);void BSP_LEDOn (INT8U led);void BSP_LEDInit (void);// LED END

// TEMP STARTvoid SendHandler (XIic * InstancePtr);void ReceiveHandler (XIic * InstancePtr);// TEMP END

// BUTTON STARTINT32U Button_Get (void);INT32U button_read (void);int button_process (void);void button_display_state_all (void);void button_display_state_single (INT32U bitno, INT32U push_button_state);// BUTTON END

// MSP430 and USB UART START//void SendHandlerMSP430(void *CallBackRef, unsigned int EventData);void RecvHandlerMSP430(void *CallBackRef, unsigned int EventData);//void SendHandlerUSB(void *CallBackRef, unsigned int EventData);void RecvHandlerUSB(void *CallBackRef, unsigned int EventData);// MSP430 and USB UART END

void procesa_comandos(void);

/*



********************************************************************************************************** Variable Definitions**********************************************************************************************************/XIic IicInstance;volatile u8 TransmitComplete;volatile u8 ReceiveComplete;u8 WriteBuffer[SEND_COUNT]; /* Write buffer for writing a page. */u8 ReadBuffer[RECEIVE_COUNT]; /* Read buffer for reading a page. */

u8 DEBUG;

INT8U comando[SIZE_COMANDO];

/* * The following buffers are used in this example to send and receive data * with the UartLite. */u8 SendBuffer[TEST_BUFFER_SIZE]; /* Buffer for Transmitting Data */u8 ReceiveBuffer[TEST_BUFFER_SIZE]; /* Buffer for Receiving Data */

/* * The following counters are used to determine when the entire buffer has * been sent and received. */static volatile int TotalReceivedCountMSP430;//static volatile int TotalSentCountMSP430;static volatile int TotalReceivedCountUSB;//static volatile int TotalSentCountUSB;/*********************************************************************************************************** WriteData()** Description: This function writes a buffer of data to IIC Slave** Arguments : ByteCount contains the number of bytes in the buffer to be written** Returns : None**********************************************************************************************************/static void WriteData(u16 ByteCount){ int Status; int BusBusy;

/* * Set the defaults. */ TransmitComplete = 1;

/* * Start the IIC device. */ Status = XIic_Start(&IicInstance);

/* * Set the Repeated Start option. */ IicInstance.Options = XII_REPEATED_START_OPTION;

/* * Send the data. */ Status = XIic_MasterSend(&IicInstance, WriteBuffer, ByteCount);

/* * Wait till data is transmitted. */ while (TransmitComplete) {

}

/* * This is for verification that Bus is not released and still Busy. */ BusBusy = XIic_IsIicBusy(&IicInstance);

TransmitComplete = 1; IicInstance.Options = 0x0;

/* * Send the Data.



*/ Status = XIic_MasterSend(&IicInstance, WriteBuffer, ByteCount);

/* * Wait till data is transmitted. */ while ((TransmitComplete) || (XIic_IsIicBusy(&IicInstance) == TRUE)) {

}

/* * Stop the IIC device. */ Status = XIic_Stop(&IicInstance);}

/*********************************************************************************************************** ReadData()** Description: This function reads a data from the IIC Slave into a specified buffer.** Arguments : BufferPtr contains the address of the data buffer to be filled* ByteCount contains the number of bytes to be read.** Returns : None**********************************************************************************************************/static void ReadData(u8 *BufferPtr, u16 ByteCount){ int Status; int BusBusy;

/* * Set the defaults. */ ReceiveComplete = 1;

/* * Start the IIC device. */ Status = XIic_Start(&IicInstance);

/* * Set the Repeated Start option. */ IicInstance.Options = XII_REPEATED_START_OPTION;

/* * Receive the data. */ Status = XIic_MasterRecv(&IicInstance, BufferPtr, ByteCount);

/* * Wait till all the data is received. */ while (ReceiveComplete) {

}

/* * This is for verification that Bus is not released and still Busy. */ BusBusy = XIic_IsIicBusy(&IicInstance);

ReceiveComplete = 1; IicInstance.Options = 0x0;

/* * Receive the Data. */ Status = XIic_MasterRecv(&IicInstance, BufferPtr, ByteCount);

/* * Wait till all the data is received. */ while ((ReceiveComplete) || (XIic_IsIicBusy(&IicInstance) == TRUE)) {

}

/* * Stop the IIC device. */ Status = XIic_Stop(&IicInstance);



}

#endif /* _BSP_H_ */

includes.h

/*********************************************************************************************************** Author : FQuinto* File: includes.h* v. 1.00 | 2012-06-14 | First release**********************************************************************************************************/

/*********************************************************************************************************** MASTER INCLUDE FILE**********************************************************************************************************/

#include "ucos_ii.h"#include "app_cfg.h"#include "cpu.h"#include "bsp.h"#include "xintc.h"#include "xintc_i.h"#include "xintc_l.h"#include "xtmrctr.h"#include "xiic.h"#include "xuartlite_l.h"#include "xuartlite.h"#include "xgpio_l.h"#include "xgpio.h"#include <string.h> // strlen()//#include "xil_exception.h"/*********************************************************************************************************** Aquí s'ha d'incloure sempre el fitxer de capçalera generat per XPS per el perifèric dissenyat**********************************************************************************************************/#include "application.h"



20.2 MSP430main_TOT.c

/*********************************************************************************************************** Author : FQuinto* File: main_TOT.c* v. 1.00 | 2012-07-16 | First release**********************************************************************************************************/#include "bsp.h"#include "mrfi.h"#include "bsp_leds.h"#include "bsp_buttons.h"#include "nwk_types.h"#include "nwk_api.h"#include "nwk.h"#include "virtual_com_cmds_TOT.h"

#ifndef APP_AUTO_ACK#error ERROR: Must define the macro APP_AUTO_ACK for this application.#endif

void toggleLED(uint8_t);

/* peer Link IDs */static linkID_t sLinkID0 = 0;

/* callback handler */static uint8_t sCB(linkID_t);

static void fromRadio( int byte );void toRadio( char* data );static void reset(void);//static void cls(void);static void linkFrom(void);static void setAP(void);static void linkTo(void);static void setED(void);int cmd_check( char* string );

/* work loop semaphores */static volatile uint8_t sSelfMeasureSem = 0;static volatile uint8_t sCommandSem = 0;static volatile uint8_t temp_loop = 0;

/* mensajería *///#define SIZE_COMANDO 15//#define SIZE_MENSAJE 16#define SIZE_COMANDO 6#define SIZE_MENSAJE 8signed int isAP = 5;signed int j = 0;//signed int byte_unoenviado = 0;//signed int byte_unorecibido = 0;static uint8_t dataFromUART[SIZE_MENSAJE];static uint8_t dataFromRADIO[SIZE_MENSAJE];static uint8_t headResponseData[1];static uint8_t byte_enviouno[8];//static uint8_t byte_enviodos[8];static uint8_t comando[SIZE_COMANDO];static void uart2radio( int byte );

/* device address */addr_t linkToAddr; // = {0x12, 0x34, 0x56, 0x78}; // EDaddr_t linkListenAddr; // = {0xAA, 0xBB, 0xCC, 0xDD}; // AP#define STATIC_PORT 0x3E

volatile int * tempOffset = (int *)0x10F4;

__interrupt void ADC10_ISR(void);__interrupt void Timer_A (void);

#define SPIN_ABOUT_A_SECOND NWK_DELAY(1000)

void main (void){ //WDTCTL = WDTPW + WDTHOLD; //stop watchdog timer



// Switch interrupts // Configure Switch on P1.2 //P1REN = BIT2; // P1.2 Enable pullup / pulldown //P1OUT = BIT2; // P1.2 pullup P1IE |= BIT2; // P1.2 interrupt enabled P1IES |= BIT2; // P1.2 hi/lo falling edge P1IFG &= ~BIT2; // P1.2 IFG cleared just in case //_EINT(); // Enable interrupts BSP_Init(); BCSCTL3 |= LFXT1S_2; // LFXT1 = VLO (Set LFXT1 to the VLO @ 12kHz) TACCTL0 = CCIE; // TACCR0 interrupt enabled TACCR0 = 12000; // ~1 second TACTL = TASSEL_1 + MC_1; // ACLK, upmode

// Configurar el puerto COM COM_Init(); // PxSEL: 0 = GPIO P2SEL = ~(0x1F); // set 2.0, 2.1, 2.2, 2.3 to GPIO mode P4SEL = ~(0x78); // set 4.3, 4.4, 4.5, 4.6 to GPIO mode while (1) { /* Wait for the Join semaphore to be set by the receipt of a Join frame from a * device that supports an End Device. * * An external method could be used as well. A button press could be connected * to an ISR and the ISR could set a semaphore that is checked by a function * call here, or a command shell running in support of a serial connection * could set a semaphore that is checked by a function call. */ int type; if (sCommandSem) { /* if ( cmd_check("help") ) { if (headResponseData[0]==0x44 & isAP==1) { //serial_log( "AP->PC\r\n" ); // debug UART_write((char *)headResponseData, 1 ); serial_log( "comandos: help aAP aED loop_on loop_off info led1_on led1_off led2_on led2_off reset setupAP setupED\r\n" ); } if (headResponseData[0]==0x49 & isAP==0) { //serial_log( "ED->FG\r\n" ); // debug UART_write((char *)headResponseData, 1 ); serial_log( "comandos: help aAP aED loop_on loop_off info led1_on led1_off led2_on led2_off reset setupAP setupED\r\n" ); } } */ /* if ( cmd_check("info") ) { sSelfMeasureSem = 1; } else if ( cmd_check("loop_on") ) { temp_loop = 1; } else if ( cmd_check("loop_off") ) { temp_loop = 0; } */ if ( cmd_check("W") ) { int puerto; int bit; int data; // puerto if (comando[1]=='1') { puerto = 1; }



if (comando[1]=='2') { puerto = 2; } if (comando[1]=='4') { puerto = 4; } if (comando[1]=='6') { puerto = 6; if ( cmd_check("W61") ) { if ( (isAP == 5) || (isAP == 3) ) { /* set address AP */ linkListenAddr.addr[0]=0; linkListenAddr.addr[1]=comando[3]; linkListenAddr.addr[2]=comando[4]; linkListenAddr.addr[3]=comando[5]; /* set status */ if (isAP == 5) { BSP_TURN_ON_LED2(); // LED rojo turn on isAP = 4; // address AP is set, address ED pending } if (isAP == 3) { BSP_TURN_ON_LED2(); // LED rojo turn on isAP = 2; // address ED & AP is set } } } else if ( cmd_check("W60") ) { if ( (isAP == 5) || (isAP == 4) ) { /* set address ED */ linkToAddr.addr[0]=0; linkToAddr.addr[1]=comando[3]; linkToAddr.addr[2]=comando[4]; linkToAddr.addr[3]=comando[5];

/* set status */ if (isAP == 5) { BSP_TURN_ON_LED1(); // LED verde turn on isAP = 3; // address ED is set, address AP pending } if (isAP == 4) { BSP_TURN_ON_LED1(); // LED verde turn on isAP = 2; // address ED & AP is set } } } else if ( cmd_check("W62001") ) { /* set AP */ if (isAP == 2) { setAP(); SMPL_Init(sCB); linkFrom(); isAP = 1; } } else if ( cmd_check("W62000") ) { /* set ED */ if (isAP == 2) { setED(); SMPL_Init(sCB); linkTo(); isAP = 0; } } } // data if (comando[5]=='1') {



data = 1; } if (comando[5]=='0') { data = 0; } // bit if (comando[2]=='0') { bit = BIT0; } if (comando[2]=='1') { bit = BIT1; } if (comando[2]=='2') { bit = BIT2; } if (comando[2]=='3') { bit = BIT3; } if (comando[2]=='4') { bit = BIT4; } if (comando[2]=='5') { bit = BIT5; } if (comando[2]=='6') { bit = BIT6; } // entradas y salidas if (puerto==1) { //st( if (data) { P1OUT &= ~BV(bit); } else { P1OUT |= BV(bit); } ); st( if (data) { P1OUT &= ~(bit); } else { P1OUT |= (bit); } ); } if (puerto==2) { if (comando[3]=='0') { // REN: 0 = no pull-up 1 = pull-up P2REN = ~(bit); // no pull-ups (0xff = pull-up) (0x00 = no pull-up, para LEDs) } else { P2REN = (bit); } if (comando[4]=='0') { // DIR: 0 = input 1 = output P2DIR |= bit; // P2.0 outputs (0xff = P2.0-P2.7 output) (0xc0 = P2.0-P2.5 input, P2.6-P2.7 output) //P2DIR = 0xFF; // All P2.x outputs } else { P2DIR &= ~bit; } // Clear P2.x LED off Set P2.x LED on x = bit //st( if (data) { P2OUT &= ~BV(bit); } else { P2OUT |= BV(bit); } ); st( if (data) { P2OUT &= ~(bit); } else { P2OUT |= (bit); } ); } if (puerto==4) { if (comando[3]=='0') { // REN: 0 = no pull-uo 1 = pull-up P4REN = ~(bit); // P4.bit => 0 = no pull-ups } else { P4REN = (bit); } if (comando[4]=='0') { // DIR: 0 = input 1 = output P4DIR |= bit; // P4.bit => 1 = output } else { P4DIR &= ~bit;



} // Clear P4.x LED off Set P4.x LED on x = bit st( if (data) { P4OUT &= ~(bit); } else { P4OUT |= (bit); } ); } if ( cmd_check("W00") ) { reset(); } } if ( cmd_check("R") ) { if ( cmd_check("R50000") ) { // Temperature type = 0; sSelfMeasureSem = 1; } else if ( cmd_check("R51000") ) { // RSSI type = 1; sSelfMeasureSem = 1; } else if ( cmd_check("R52000") ) { // Voltage type = 2; sSelfMeasureSem = 1; } /* else if ( cmd_check("R12") ) { char chardata; // lectura boton if (P1IN & ~BIT2) // P1.2 is Low? { chardata = '0'; } else { chardata = '1'; } if (isAP==1) { switch (headResponseData[0]) { case 0x44: // mensaje D (4): AP->PC => emisor UART UART_write((char *)headResponseData, 1 ); serial_log( "R1200" ); UART_write((char *)chardata, 1 ); serial_log( "\r\n" ); break; case 0x46: // mensaje F (6): AP->FG => emisor RADIO toRadio( "FR1200x\r" ); break; } } if (isAP==0) { switch (headResponseData[0]) { case 0x49: // mensaje I (9): ED->FG => emisor UART UART_write((char *)headResponseData, 1 ); serial_log( "R1200" ); UART_write((char *)chardata, 1 ); serial_log( "\r\n" ); break; case 0x47: // mensaje G (7): ED->PC => emisor RADIO toRadio( "GR1200x\r" ); break; } } } */ } /* else if ( cmd_check("led1_off") ) { BSP_TURN_OFF_LED1(); //LED verde turn off } else if ( cmd_check("led2_on") ) { BSP_TURN_ON_LED2(); // LED rojo turn on }



else if ( cmd_check("led2_off") ) { BSP_TURN_OFF_LED2(); //LED rojo turn off } */ /* else if ( cmd_check("cls") ) { cls(); } */ //else //{ /* if (isAP==1) { switch (headResponseData[0]) { case 0x44: // mensaje D (4): AP->PC => emisor UART //serial_log( "AP->PC\r\n" ); // debug UART_write((char *)headResponseData, 1 ); serial_log( "command error\r\n" ); break; case 0x46: // mensaje F (6): AP->FG => emisor RADIO //serial_log( "AP->FG\r\n" ); // debug toRadio( "Fcommand error\r" ); break; } } if (isAP==0) { switch (headResponseData[0]) { case 0x49: // mensaje I (9): ED->FG => emisor UART //serial_log( "ED->FG\r\n" ); // debug UART_write((char *)headResponseData, 1 ); serial_log( "command error\r\n" ); break; case 0x47: // mensaje G (7): ED->PC => emisor RADIO //serial_log( "ED->PC\r\n" ); // debug toRadio( "Gcommand error\r" ); break; } } */ //} sCommandSem = 0; }

if(sSelfMeasureSem) { char msg [3]; int degC, volt; volatile long temp; int results[2]; /* RSSI */ ioctlRadioSiginfo_t sigInfo; sigInfo.lid = sLinkID0; SMPL_Ioctl(IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_SIGINFO, (void *)&sigInfo); /* Temperature */ ADC10CTL1 = INCH_10 + ADC10DIV_4; // Temp Sensor ADC10CLK/5 ADC10CTL0 = SREF_1 + ADC10SHT_3 + REFON + ADC10ON + ADC10IE + ADC10SR; for( degC = 240; degC > 0; degC-- ); // delay to allow reference to settle ADC10CTL0 |= ENC + ADC10SC; // Sampling and conversion start __bis_SR_register(CPUOFF + GIE); // LPM0 with interrupts enabled results[0] = ADC10MEM; ADC10CTL0 &= ~ENC; /* Voltage */ ADC10CTL1 = INCH_11; // AVcc/2 ADC10CTL0 = SREF_1 + ADC10SHT_2 + REFON + ADC10ON + ADC10IE + REF2_5V; for( degC = 240; degC > 0; degC-- ); // delay to allow reference to settle ADC10CTL0 |= ENC + ADC10SC; // Sampling and conversion start __bis_SR_register(CPUOFF + GIE); // LPM0 with interrupts enabled results[1] = ADC10MEM; ADC10CTL0 &= ~ENC; ADC10CTL0 &= ~(REFON + ADC10ON); // turn off A/D to save power

// oC = ((A10/1024)*1500mV)-986mV)*1/3.55mV = A10*423/1024 - 278 // the temperature is transmitted as an integer where 32.1 = 321 // hence 4230 instead of 423 temp = results[0];



degC = (((temp - 673) * 4230) / 1024); if( (*tempOffset) != 0xFFFF ) { degC += (*tempOffset); } /* message format, UB = upper Byte, LB = lower Byte ------------------------------- |degC LB | degC UB | volt LB | ------------------------------- 0 1 2 */ temp = results[1]; volt = (temp*25)/512; msg[0] = degC&0xFF; msg[1] = (degC>>8)&0xFF; msg[2] = volt; if (isAP==1) { switch (headResponseData[0]) { case 0x44: // mensaje D (4): AP->PC => emisor UART //serial_log( "AP->PC\r\n" ); // debug transmitDataString( 1, sigInfo.sigInfo.rssi, msg, 1, type ); // 1 = AP, 1 = uart break; case 0x46: // mensaje F (6): AP->FG => emisor RADIO //serial_log( "AP->FG\r\n" ); // debug transmitDataString( 1, sigInfo.sigInfo.rssi, msg, 0, type ); // 1 = AP, 0 = radio break; } } if (isAP==0) { switch (headResponseData[0]) { case 0x49: // mensaje I (9): ED->FG => emisor UART //serial_log( "ED->FG\r\n" ); // debug transmitDataString( 0, sigInfo.sigInfo.rssi, msg, 1, type ); // 0 = ED, 1 = uart break; case 0x47: // mensaje G (7): ED->PC => emisor RADIO //serial_log( "ED->PC\r\n" ); // debug transmitDataString( 0, sigInfo.sigInfo.rssi, msg, 0, type ); // 0 = ED, 0 = radio break; } } sSelfMeasureSem = 0; } /* if ( BSP_BUTTON1() ) { if (isAP==1) { serial_log( "Dboton\r\n" ); SPIN_ABOUT_A_SECOND; } if (isAP==0) { serial_log( "Iboton\r\n" ); SPIN_ABOUT_A_SECOND; } } */ }}

/* * reset: set to initial conditions */static void reset(){ SMPL_Unlink(sLinkID0); sLinkID0 = 0; //sSelfMeasureSem = 0; temp_loop = 0; isAP = 5; WDTCTL = 0; /* clear screen */ //cls();}

/* * cls: clear screen *//*



static void cls(){ serial_log( "\f" );}*/

/* * linkFrom: used by AP to link device address */static void linkFrom(){ /* FOR AP */ // bypass linking process if(SMPL_Commission((addr_t*) &linkToAddr, STATIC_PORT, STATIC_PORT, &sLinkID0) != SMPL_SUCCESS) { // trap while(1) { toggleLED(2); //LED rojo } } BSP_TURN_OFF_LED2(); //LED rojo OFF /* turn on RX. default is RX off. */ SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);}

/* * linkTo: used by ED to link device address */static void linkTo(){ /* FOR ED */

// bypass linking process if(SMPL_Commission((addr_t*) &linkListenAddr, STATIC_PORT, STATIC_PORT, &sLinkID0) != SMPL_SUCCESS) { // trap while(1) { toggleLED(2); //LED rojo } }

BSP_TURN_OFF_LED2(); //LED rojo OFF

/* turn on RX. default is RX off. */ SMPL_Ioctl( IOCTL_OBJ_RADIO, IOCTL_ACT_RADIO_RXON, 0);}

/* * setAP: set AP device address */static void setAP(){ SMPL_Ioctl(IOCTL_OBJ_ADDR, IOCTL_ACT_SET, (addr_t*) &linkListenAddr);}

/* * setED: set ED device address */static void setED(){ SMPL_Ioctl(IOCTL_OBJ_ADDR, IOCTL_ACT_SET, (addr_t*) &linkToAddr);}

/* * toggleLED: set LED on when off and set LED off when on */void toggleLED(uint8_t which){ if (1 == which) { BSP_TOGGLE_LED1(); //LED verde } else if (2 == which) { BSP_TOGGLE_LED2(); //LED rojo }

return;}



/* Runs in ISR context. Reading the frame should be done in the *//* application thread not in the ISR thread. */static uint8_t sCB(linkID_t lid){ if (lid) { /* if (byte_unorecibido) { // recibir byte dos fromRadio(2); } else { // recibir byte uno fromRadio(1); } */ fromRadio(1); } /* * If the function returns 0 the received frame is left in the input frame queue for later * retrieval in the user thread. This is the recommended procedure. The callback can simply * set a flag or otherwise store the information about the waiting frame. The actual * reference to SMPL_Receive() should be done in the user thread. */ /* leave frame to be read by application. */ return 0;}

/* * fromRadio: receive data from radio. Input 1 = byte uno, 2 = byte dos */static void fromRadio( int byte ){ uint8_t msg[8], len; // 8 = 1 byte uint8_t i; int headdata; len = sizeof(msg); if (SMPL_SUCCESS == SMPL_Receive(sLinkID0, msg, &len)) { //byte_unorecibido = 1; if (byte==1) { for (i=0; i<=SIZE_COMANDO+1; ++i) // +1 por el 0x0d { if ((msg[i]==0x0d) & (i>1)) { dataFromRADIO[i] = 0x0d; // guardo x0d //byte_unorecibido = 0; break; } else { dataFromRADIO[i] = msg[i]; } } } /* if (byte==2) { for (i=8; i<=15; ++i) { if (msg[i]==0x0d) { break; } else { dataFromRADIO[i] = msg[i-8]; } } byte_unorecibido = 0; } */ /* fin del mensaje: porque he detectado un ENTER o porque ha llegado el segundo byte */ //if (byte_unorecibido == 0) //{



/* guardo comando */ for (i=0; i<=(SIZE_COMANDO-1); ++i) // máximo = SIZE_COMANDO-1 { comando[i] = dataFromRADIO[i+1]; // el comando no tiene cabecera, empiezo desde el 1 } headdata = dataFromRADIO[0]; if (isAP==1) { switch (headdata) { case 0x47: // mensaje G (7): ED->PC => transporte RADIO2UART //serial_log( "ED->PC\r\n" ); // debug UART_write( dataFromRADIO, SIZE_MENSAJE ); serial_log( "\r\n" ); break; case 0x4A: // mensaje J (10): FG->PC => transporte RADIO2UART //serial_log( "FG->PC\r\n" ); // debug UART_write( dataFromRADIO, SIZE_MENSAJE ); serial_log( "\r\n" ); break; case 0x4B: // mensaje K (11): FG->AP => receptor RADIO //serial_log( "FG->AP\r\n" ); // debug headResponseData[0] = 'F'; // mensaje F (6) sCommandSem = 1; /* semáforo comando */ break; default: ; } } if (isAP==0) { switch (headdata) { case 0x42: // mensaje B (2): PC->ED => receptor RADIO //serial_log( "PC->ED\r\n" ); // debug headResponseData[0] = 'G'; // mensaje G (7) sCommandSem = 1; /* semáforo comando */ break; case 0x43: // mensaje C (3): PC->FG => transporte RADIO2UART //serial_log( "PC->FG\r\n" ); // debug UART_write( dataFromRADIO, SIZE_MENSAJE ); serial_log( "\r\n" ); break; case 0x46: // mensaje F (6): AP->FG => transporte RADIO2UART //serial_log( "AP->FG\r\n" ); // debug UART_write( dataFromRADIO, SIZE_MENSAJE ); serial_log( "\r\n" ); break; default: ; } } //} }}

/* * toRadio: send data to Radio */void toRadio( char* data ){ uint8_t i; /* establecer byte_enviouno */ for (i=0; i<=SIZE_COMANDO+1; ++i) // +1 por el 0x0d { byte_enviouno[i] = data[i]; } /* To establish a packet-error rate the newest send command can be used (SMPL _SendOpt(linkID_t lid, uint8 *msg, uint8 len, uint8 opt) instead of SMPL _Send(linkID_t lid, uint8 *msg, uint8 len)) which uses the opt bitmap to add different features for the transmission, such as implementing an ACK (parameter SMPL_TXOPTION_ACKREQ). This will tell the program to request an acknowledgement from the peer and the return status of the SMPL_SendOpt can be checked to determine transmission success. If no acknowledgment is received then the program can perform error checking or implement a resend routine. For more information on these features see the SimpliciTI API guide, most notably page 13. http://processors.wiki.ti.com/index.php/EZ430_Chat */ /* envio mensaje */ SMPL_Send(sLinkID0, byte_enviouno, sizeof byte_enviouno ); /* establecer byte_enviodos */ /* for (i=8; i<=15; ++i) {



byte_enviodos[i-8] = data[i]; } */ /* envio mensaje */ //SMPL_Send(sLinkID0, byte_enviodos, sizeof byte_enviodos );}

/* * cmd_check: Return 1 if diferent, return 0 if equal */int cmd_check( char* string ){ int i,diferentes; int length = strlen(string); diferentes = 0; for( i = 0; i < length; i++) { if (comando[i] == string[i]) { diferentes = 1; } else { return 0; } } return diferentes;}

/* * uart2radio: envia byte 1 ó 2 */static void uart2radio( int byte ){ uint8_t i; int headdata = dataFromUART[0]; /* Envia si mensaje ( B = 0x42 O C = 0x43 ) Y isAP = 1 * o * si mensaje ( J = 0x4A O K = 0x4B ) Y isAP = 0 */ if ( (((headdata == 0x42) || (headdata == 0x43)) & isAP==1) || (((headdata == 0x4A) || (headdata == 0x4B)) & isAP==0) ) { if (byte==1) { /* establecer byte_enviouno */ for (i=0; i<=SIZE_COMANDO+1; ++i) // +1 por el 0x0d { byte_enviouno[i] = dataFromUART[i]; } /* envio mensaje */ SMPL_Send(sLinkID0, byte_enviouno, sizeof byte_enviouno ); } /* if (byte==2) { // establecer byte_enviodos for (i=8; i<=15; ++i) { byte_enviodos[i-8] = dataFromUART[i]; } // envio mensaje SMPL_Send(sLinkID0, byte_enviodos, sizeof byte_enviodos ); } */ }}

/*------------------------------------------------------------------------------* USCIA interrupt service routine------------------------------------------------------------------------------*//* * Accept a command entered on the serial terminal */#pragma vector=USCIAB0RX_VECTOR__interrupt void USCI0RX_ISR(void){ uint8_t data = UCA0RXBUF; uint8_t i; if (j==0)



{ /* 0x41 = A, 0x42 = B, 0x43 = C (from PC) */ if ( ((data == 0x41) || (data == 0x42) || (data == 0x43)) ) { j++; } /* 0x4A = J, 0x4B = K, 0x4C = L (from FPGA) */ if ( ((data == 0x4A) || (data == 0x4B) || (data == 0x4C)) ) { j++; } dataFromUART[0] = data; // guardo cabecera //byte_unoenviado = 0; } else { /* para j>0 */ if( (data==0x0d) & (j>1) ) // minimo 1 byte de mensaje por eso j>1 { /* guardo comando */ // j es el valor actual, luego -1 para quitar cabecera y -1 para quitar el x0d = -2 for (i=0; i<=(j-2); ++i) { comando[i] = dataFromUART[i+1]; // el comando no tiene cabecera, empiezo desde el 1 } for (i; i<=(SIZE_COMANDO-1); ++i) // máximo = SIZE_COMANDO-1 { comando[i] = 0x20; // rellena el comando con espacios = 0x20 } /* semáforo comando si mensaje es A (1)*/ if ( (dataFromUART[0] == 0x41) & isAP==1 ) { headResponseData[0] = 'D'; // mensaje D (4) sCommandSem = 1; } /* semáforo comando si mensaje es L (12)*/ if ( (dataFromUART[0] == 0x4C) & isAP==0 ) { headResponseData[0] = 'I'; // mensaje 9 sCommandSem = 1; } /* Para los estados 5, 4, 3, 2 procesa lo recibido (configuración) */ if ( (isAP != 0) && (isAP != 1) ) { sCommandSem = 1; } /* establecer final mensaje, agrega x0d */ dataFromUART[j] = 0x0d; /* OPCIONAL: continuo agregando datos a comando */ /* j++; for (i=j; i<=SIZE_MENSAJE; ++i) { dataFromUART[i] = 0x20; // rellena el comando con espacios = 0x20 } */ /* if (byte_unoenviado) { // hacer envio byte dos uart2radio(2); } else { // hacer envio byte uno uart2radio(1); } */ // hacer envio byte uno uart2radio(1); j = 0; } else { /* if (j==SIZE_COMANDO) { dataFromUART[j] = data; if (byte_unoenviado == 0) { // hacer envio byte uno



uart2radio(1); byte_unoenviado = 1; j++; } } else if (j>=15) { dataFromUART[j] = data; // hacer envio byte dos uart2radio(2); j = 0; } */ if (j>=SIZE_COMANDO+1) // +1 por el 0x0d { j = 0; } else { dataFromUART[j] = data; j++; } } }}

/*------------------------------------------------------------------------------* ADC10 interrupt service routine------------------------------------------------------------------------------*/#pragma vector=ADC10_VECTOR__interrupt void ADC10_ISR(void){ __bic_SR_register_on_exit(CPUOFF); // Clear CPUOFF bit from 0(SR)}

/*------------------------------------------------------------------------------* Timer A0 interrupt service routine------------------------------------------------------------------------------*/#pragma vector=TIMERA0_VECTOR__interrupt void Timer_A (void){ /* if (temp_loop) { sSelfMeasureSem = 1; } */}

/*------------------------------------------------------------------------------* Port1 interrupt service routine (switch)------------------------------------------------------------------------------*/#pragma vector=PORT1_VECTOR__interrupt void Port_1(void){ volatile unsigned int i; if (isAP==1) { serial_log( "DR12001\r\n" ); SPIN_ABOUT_A_SECOND; } if (isAP==0) { serial_log( "IR12001\r\n" ); SPIN_ABOUT_A_SECOND; } //P1OUT ^= BIT1; // Toggle Port P1.1 using exclusive-OR /* i=1500; // Delay, button debounce do (i--); while (i !=0); while (! (P1IN & BIT2)); // Wait for the release of the button i=1500; // Delay, button debounce do (i--); while (i !=0); */ P1IFG &= ~BIT2; // P1.2 Interrupt Flag cleared}



smpl_config.dat

## Filename: smpl_config.dat# Revised: $Date: 2008-11-18 16:54:54 -0800 (Tue, 18 Nov 2008) $# Revision: $Revision: 18453 $# Author: $Author: lfriedman $## Description: This file supports the SimpliciTI Customer Configuration for Access Points.## Copyright 2008-2009 Texas Instruments Incorporated. All rights reserved.## IMPORTANT: Your use of this Software is limited to those specific rights granted under# the terms of a software license agreement between the user who downloaded the software,# his/her employer (which must be your employer) and Texas Instruments Incorporated (the# "License"). You may not use this Software unless you agree to abide by the terms of the# License. The License limits your use, and you acknowledge, that the Software may not be# modified, copied or distributed unless embedded on a Texas Instruments microcontroller# or used solely and exclusively in conjunction with a Texas Instruments radio frequency# transceiver, which is integrated into your product. Other than for the foregoing purpose,# you may not use, reproduce, copy, prepare derivative works of, modify, distribute,# perform, display or sell this Software and/or its documentation for any purpose.## YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS� �# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY# WARRANTY OF MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.# IN NO EVENT SHALL TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,# NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER LEGAL EQUITABLE# THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES INCLUDING BUT NOT LIMITED TO ANY# INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST# DATA, COST OF PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY# THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.## Should you have any questions regarding your right to use this Software,# contact Texas Instruments Incorporated at www.TI.com.

# Number of connections supported. Each connection supports bi-directional# communication. Access Points and Range Extenders can set this to 0 if they# do not host End Device objects.--define=NUM_CONNECTIONS=8

# Size of low level queues for sent and received frames. Affects RAM usage

# AP needs larger input frame queue if it is supporting store-and-forward# clients because the forwarded messages are held here.--define=SIZE_INFRAME_Q=6

# The output frame queue can be small since Tx is done synchronously. Actually# 1 is probably enough. If an Access Point device is also hosting an End Device # that sends to a sleeping peer the output queue should be larger -- the waiting # frames in this case are held here. In that case the output frame queue should # be bigger.--define=SIZE_OUTFRAME_Q=2

# This device's address. The first byte is used as a filter on the CC1100/CC2500# radios so THE FIRST BYTE MUST NOT BE either 0x00 or 0xFF. Also, for these radios# on End Devices the first byte should be the least significant byte so the filtering# is maximally effective. Otherwise the frame has to be processed by the MCU before it# is recognized as not intended for the device. APs and REs run in promiscuous mode so# the filtering is not done. This macro intializes a static const array of unsigned# characters of length NET_ADDR_SIZE (found in nwk_types.h). The quotes (") are# necessary below unless the spaces are removed.--define=THIS_DEVICE_ADDRESS="{0x78, 0x56, 0x34, 0x12}"

# Device Type--define=ACCESS_POINT

# In the spcial case in which the AP is a data hub, the AP will automaically# listen for a link each time a new device joins the network. This is a special# case scenario in which all End Device peers are the AP and every ED links# to the AP. In this scenario the ED must automatically try and link after the# Join reply.--define=AP_IS_DATA_HUB

# Store and forward support: number of clients--define=NUM_STORE_AND_FWD_CLIENTS=3#--define=STARTUP_JOINCONTEXT_ON



virtual_com_cmds_TOT.c

/*---------------------------------------------------------------------------- * Demo Application for SimpliciTI * * L. Friedman * Texas Instruments, Inc. *---------------------------------------------------------------------------- */

/********************************************************************************************** Copyright 2007-2009 Texas Instruments Incorporated. All rights reserved.

IMPORTANT: Your use of this Software is limited to those specific rights granted under the terms of a software license agreement between the user who downloaded the software, his/her employer (which must be your employer) and Texas Instruments Incorporated (the "License"). You may not use this Software unless you agree to abide by the terms of the License. The License limits your use, and you acknowledge, that the Software may not be modified, copied or distributed unless embedded on a Texas Instruments microcontroller or used solely and exclusively in conjunction with a Texas Instruments radio frequency transceiver, which is integrated into your product. Other than for the foregoing purpose, you may not use, reproduce, copy, prepare derivative works of, modify, distribute, perform, display or sell this Software and/or its documentation for any purpose.

YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS� � WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.

Should you have any questions regarding your right to use this Software, contact Texas Instruments Incorporated at www.TI.com.**************************************************************************************************/#include <string.h>

static int degCMode;

/******************************************************************************/// Virtual Com Port Communication/******************************************************************************/#define MESSAGE_LENGTH 3

void COM_Init(void);void serial_log( char* string );void UART_write( const char *string, int length );void UART_putChar (char c);void transmitDataString( int isAP, signed char rssi, char msg[MESSAGE_LENGTH], int uart, int type );

virtual_com_cmds_TOT.h

/*---------------------------------------------------------------------------- * Demo Application for SimpliciTI * * L. Friedman * Texas Instruments, Inc. *---------------------------------------------------------------------------- */

/********************************************************************************************** Copyright 2007-2009 Texas Instruments Incorporated. All rights reserved.

IMPORTANT: Your use of this Software is limited to those specific rights granted under the terms of a software license agreement between the user who downloaded the software, his/her employer (which must be your employer) and Texas Instruments Incorporated (the "License"). You may not use this Software unless you agree to abide by the terms of the License. The License limits your use, and you acknowledge, that the Software may not be modified, copied or distributed unless embedded on a Texas Instruments microcontroller or used solely and exclusively in conjunction with a Texas Instruments radio frequency transceiver, which is integrated into your product. Other than for the foregoing purpose, you may not use, reproduce, copy, prepare derivative works of, modify, distribute, perform, display or sell this Software and/or its documentation for any purpose.



YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE PROVIDED AS IS� � WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.

Should you have any questions regarding your right to use this Software, contact Texas Instruments Incorporated at www.TI.com.**************************************************************************************************/#include <string.h>

static int degCMode;

/******************************************************************************/// Virtual Com Port Communication/******************************************************************************/#define MESSAGE_LENGTH 3

void COM_Init(void);void serial_log( char* string );void UART_write( const char *string, int length );void UART_putChar (char c);void transmitDataString( int isAP, signed char rssi, char msg[MESSAGE_LENGTH], int uart, int type );

20.3 WebAccion.php

<?phpif (!isset($_SESSION)) { session_start();}

include "../linux/php_serial.class.php";

// Let's start the class$_SESSION['clase_serial']=new phpSerial;$serial = $_SESSION['clase_serial'];

if (isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!=""){ switch ($_GET['accion']) { case "abrir": // Then we need to open it $serial->deviceSet($_SESSION['puerto']); $serial->deviceOpen(); $_SESSION['estado'] = 'abierto'; break; case "leer": // Or to read from //$serial->deviceOpen(); //$_SESSION['leido'] = $serial->readPort(); $PATH="http://".$_SERVER['HTTP_HOST']."/serie/cgi-bin/lectura.py"; $_SESSION['leido'] = file_get_contents($PATH,0); //$serial->deviceClose(); break; case "escribir": // To write into if (isset($_POST['mensaje']) && $_POST['mensaje']!="") { $serial->deviceSet($_SESSION['puerto']); //$serial->deviceOpen(); $serial->sendMessage($_POST['mensaje']); //$serial->deviceClose(); } break; case "cerrar": $serial->deviceSet($_SESSION['puerto']); // If you want to change the configuration, the device must be closed $serial->deviceClose(); $_SESSION['estado'] = 'cerrado'; break; case "configura":



// We can change the baud rate if (isset($_POST['velocidad'])) { //$serial->confBaudRate($_POST['velocidad']); $_SESSION['velocidad'] = $_POST['velocidad']; } // We can change databit if (isset($_POST['databit'])) { //$serial->confParity($_POST['databit']); $_SESSION['databit'] = $_POST['databit']; } // We can change parity if (isset($_POST['paridad'])) { //$serial->confParity($_POST['paridad']); $_SESSION['paridad'] = $_POST['paridad']; } // We can change stopbit if (isset($_POST['stopbit'])) { //$serial->confParity($_POST['stopbit']); $_SESSION['stopbit'] = $_POST['stopbit']; } // We can change control if (isset($_POST['control'])) { //$serial->confFlowControl($_POST['control']); $_SESSION['control'] = $_POST['control']; } break; default: break; }}header("Location: configuracio.php");exit;?>

check_port.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?></head><body><?php include("../menu.php"); ?><div class="container"><h1><?php echo( MANUAL_MESSAGE ); ?> <small><?php echo( CHECK_PORT_MESSAGE ); ?></small></h1><?phpif ( isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!="" ){?> <h2>Control <small><?php echo INFOOS_MESSAGE; ?>:<strong> <?php echo $_SESSION['OS'];?></strong> · <?php echo PORT_SELECTED_MESSAGE; ?> <strong><?php echo $_SESSION['puerto'];?></strong></small></h2><?php if ( $_SESSION['OS']=='LINUX' ) { /* if (exec("stty -F " . $_SESSION['puerto']) === 0) { //echo "Puerto escribible!!<br>"; $puerto_ok = $puerto_ok+1; echo 'A:'.$puerto_ok; }

if (exec("echo 'test' >> ".$_SESSION['puerto']) == 0) { echo "Test 2: Puerto escribible!!<br>"; $puerto_ok = $puerto_ok+1; }

if (exec("ls -la ".$_SESSION['puerto']." | awk '{ print $1 }'") === "crwxrwxrwx") {



echo "Permisos OK!!<br>"; $puerto_ok = $puerto_ok+1; } */ if ((exec("ls -la ".$_SESSION['puerto']." | awk '{ print $3 }'") === exec('whoami')) && (exec("ls -la ".$_SESSION['puerto']." | awk '{ print substr( $1, length($2), 3 ) }'")=== "crw") || (exec("ls -la ".$_SESSION['puerto']." | awk '{ print $1 }'") === "crwxrwxrwx")) { // puerto OK?> <div class="alert alert-block alert-success fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading"><?php echo OK_MESSAGE; ?></h4> <?php echo ( CHECKOK_MESSAGE ); ?> </div><?php } else { // puerto KO?> <div class="alert alert-block alert-error fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading">ERROR</h4> <?php echo ( ERROR_PORTNOT_DETECTED_MESSAGE ); ?><?php $puerto=exec("ls -la ".$_SESSION['puerto']); if (!empty($puerto)) { echo ( " " . ERROR_PERMISSIONS_PORT_MESSAGE . ":" )." <code>".exec("ls -la ".$_SESSION['puerto']).'</code><br>'; echo ( ERROR_PERM_SOLUTION_MESSAGE . ": " ); echo "<code>"."sudo chmod 777 " . $_SESSION['puerto'] . "</code><br>"; } else {?> <?php echo ( ERROR_NOTEXIST_PORT_MESSAGE ); ?><br><br> <a class="btn" href="quita.php?quitar=puerto&ir=<?php echo substr($_SERVER['SCRIPT_NAME'],0,-14)."configuracio";?>" title="<?php echo CHANGE_PORT_MESSAGE; ?>"><i class="icon-wrench"></i> <?php echo CHANGE_PORT_MESSAGE; ?></a><?php }?> </div><?php } }if ($_SESSION['OS']=='WINDOWS') { if ( writable_port($_SESSION['puerto'])==1 ) { // puerto OK?> <div class="alert alert-block alert-success fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading"><?php echo OK_MESSAGE; ?></h4> <?php echo ( CHECKOK_MESSAGE ); ?> </div><?php } else { // puerto KO?> <div class="alert alert-block alert-error fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading">ERROR</h4> <?php echo ( ERROR_PORTNOT_DETECTED_MESSAGE ); ?> <?php //echo " " . ERROR_PORTBUSY_MESSAGE . "<br>" . ERROR_CATNOTEXIST_PORT_MESSAGE );?><?php

if ( check_if_exist_port($_SESSION['puerto'])==1 ) {

?> <?php echo " " . ERROR_PORTBUSY_MESSAGE; ?><?php } else {?> <?php echo ( ERROR_NOTEXIST_PORT_MESSAGE ); ?><br><br> <a class="btn" href="quita.php?quitar=puerto&ir=<?php echo substr($_SERVER['SCRIPT_NAME'],0,-14)."configuracio";?>" title="<?php echo CHANGE_PORT_MESSAGE; ?>"><i class="icon-wrench"></i> <?php echo CHANGE_PORT_MESSAGE; ?></a><?php }?> </div><?php } }?><?php} else { ?>

<div class="alert alert-block alert-error fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading">ERROR</h4> <p><?php echo ERROR_BEFOREWRITE_MESSAGE; ?></p> <p> <?php if (!isset($_SESSION['OS']) || $_SESSION['OS']=="") { ?> <a class="btn btn-primary" href="../configuracion/osinfo.php"><?php echo( DETECT_OS_MESSAGE );?></a> <?php } elseif (!isset($_SESSION['puerto']) || $_SESSION['puerto']=="") { ?> <a class="btn btn-primary" href="../configuracion/detectar_port.php"><?php echo( DETECT_PORT_MESSAGE );?></a> <?php } ?> </p> </div><?php } ?><a class="btn" href="javascript:history.back(1)"><i class="icon-chevron-left"></i> <?php echo( GOBACK_MESSAGE );?></a><a class="btn" href="../"><i class="icon-home"></i> <?php echo( GOHOME_MESSAGE );?></a></div> 

<?php include("../javascript.php"); ?>

</body></html>

check_port_ajax.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?php

$puerto = $_GET['q'];

if ( isset($_SESSION['OS']) && $_SESSION['OS']!="" && isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['velocidad']) && $_SESSION['velocidad']!="" && isset($_SESSION['databit']) && isset($_SESSION['paridad']) && isset($_SESSION['stopbit']) && isset($_SESSION['control']) ){ ?><?php if ( writable_port($puerto)==1 ) { ?> <div class="alert alert-success"> <a class="close" data-dismiss="alert" href="#">×</a> <?php echo CHECKOK_MESSAGE; ?> </div><?php } else {?> <div class="alert alert-error"> <a class="close" data-dismiss="alert" href="#">×</a> <?php echo CHECKNOK_MESSAGE; ?> <a class="btn btn-mini" href="check_port.php"><?php echo INFORMATION_MESSAGE; ?></a></div><?php } ?><?php } ?>

config_ajax.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpif ($_GET['q']=="os" ) {

// init clear all session's$_SESSION['puerto'] = NULL;unset($_SESSION['puerto']);$_SESSION['velocidad'] = NULL;$_SESSION['databit'] = NULL;$_SESSION['paridad'] = NULL;$_SESSION['stopbit'] = NULL;$_SESSION['control'] = NULL;unset($_SESSION['velocidad']);unset($_SESSION['databit']);unset($_SESSION['paridad']);unset($_SESSION['stopbit']);unset($_SESSION['control']);

$_SESSION['OS']=giveme_os();



?> <h2><?php echo( CONFIGURACION_MESSAGE ); ?>:</h2> <p> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['OS']; ?></a><?phpif (isset($_SESSION['puerto'])){ ?> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['puerto']; ?></a><?php} else { ?> <a class="btn btn-primary btn-large" href="javascript:config_ajax('port');" title="<?php echo "Auto ".strtolower( DETECT_PORT_MESSAGE );?>"><?php echo "Auto ".strtolower( DETECT_PORT_MESSAGE );?> »</a><?php } ?> </p><?php } ?><?phpif ($_GET['q']=="port") {

// init clear all session's$_SESSION['velocidad'] = NULL;$_SESSION['databit'] = NULL;$_SESSION['paridad'] = NULL;$_SESSION['stopbit'] = NULL;$_SESSION['control'] = NULL;unset($_SESSION['velocidad']);unset($_SESSION['databit']);unset($_SESSION['paridad']);unset($_SESSION['stopbit']);unset($_SESSION['control']);

if ( !(isset($_SESSION['OS'])) || $_SESSION['OS']=="" ){ $_SESSION['OS']=giveme_os();}if ( isset($_SESSION['OS']) && $_SESSION['OS']!="" ){ $_SESSION['puerto'] = giveme_port($_SESSION['OS']);}?> <h2><?php echo( CONFIGURACION_MESSAGE ); ?>:</h2> <p> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['OS']; ?></a> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['puerto']; ?></a>

<?phpif (isset($_SESSION['velocidad'])){ ?> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['velocidad'] . " " . $_SESSION['databit'] . " " . $_SESSION['paridad'] . " " . $_SESSION['stopbit'] . " " . $_SESSION['control']; ?></a><?php} else { ?> <a class="btn btn-primary btn-large" href="javascript:config_ajax('velocidad');" title="<?php echo "Auto ".strtolower( CONFIG_PORT_MESSAGE );?>"><?php echo "Auto ".strtolower( CONFIG_PORT_MESSAGE );?> »</a><?php } ?></p><?php } ?><?phpif ($_GET['q']=="velocidad") {if ( !(isset($_SESSION['OS'])) || $_SESSION['OS']=="" ){ $_SESSION['OS']=giveme_os();}if ( !(isset($_SESSION['puerto'])) || $_SESSION['puerto']=="" ){ $_SESSION['puerto'] = giveme_port($_SESSION['OS']);}if ( isset($_SESSION['OS']) && $_SESSION['OS']!="" && isset($_SESSION['puerto']) && $_SESSION['puerto']!=""){//configuració per defecte:$_SESSION['velocidad']="9600";$_SESSION['databit']="8";$_SESSION['paridad']="none";$_SESSION['stopbit']="1";$_SESSION['control']="none";}?> <h2><?php echo( CONFIGURACION_MESSAGE ); ?>:</h2> <p> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['OS']; ?></a> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['puerto']; ?></a> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['velocidad'] . " " . $_SESSION['databit'] . " " . $_SESSION['paridad'] . " " . $_SESSION['stopbit'] . " " . $_SESSION['control']; ?></a> <a class="btn btn-info btn-large" href="javascript:check_port2('<?php echo $_SESSION['puerto']; ?>');" title="<?php echo CHECK_PORT_MESSAGE;?>"><i class="icon-pencil icon-white"></i> <?php echo( CHECK_MESSAGE );?></a>

</p><?php } ?><?phpif (isset($_SESSION['OS']) || isset($_SESSION['puerto']) || isset($_SESSION['velocidad'])){ ?> <p> <a class="btn" href="configuracion/configuracio.php" title="<?php echo ( MANUAL_MESSAGE );?>"><?php echo ( MANUAL_MESSAGE );?></a> <a class="btn btn-danger" href="configuracion/quita.php" title="<?php echo DELETE_MESSAGE . " " . strtolower(CONFIGURACION_MESSAGE); ?>"><i class="icon-trash icon-white"></i> <?php echo DELETE_MESSAGE;?></a> </p><?php}?>

configuracio.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);/*They need access to the /dev/ttyS0 serial port, which is owned by the dialout group.

I can chmod the permissions of the /dev/ttyS0 serial port every time the box reboots, but that's not a good solution. Is there any way to change the default group of /dev/ttyS0 to "users"? If not, is there a way to add the "users" group to "dialout"?

SOLVED I addedCode: KERNEL=="ttyS0", MODE="0777"to /lib/udev/rules.d/10-local.rules and unplug & plug USB (or rebooted)

NOTE:-jQquery fade out message from: "http://flintmaker.com/code/jquery-fade-message-in-or-out/"*/?><script type="text/javascript"></script></head><body><?php include("../menu.php"); ?><div class="container"><h1><?php echo( MANUAL_MESSAGE ); ?> <small><?php echo( CONFIGURACION_MESSAGE ); ?></small></h1><?php$colname_puerto = "0";if (isset($_POST['puerto']) && $_POST['puerto']!="") { $colname_puerto = (get_magic_quotes_gpc()) ? $_POST['puerto'] : addslashes($_POST['puerto']); $_SESSION['puerto']=$colname_puerto;}?><?phpif ( isset($_SESSION['OS']) && ($_SESSION['OS']!="") ) { if ((!isset($_SESSION['puerto'])) && ($_SESSION['OS']=='WINDOWS')) {?> <div class="span8"> <form id='config' method="post" action="" class="form-horizontal"> <fielset>

<div class="control-group"> <label class="control-label"><?php echo INFOOS_MESSAGE; ?>: </label> <input id="disabledInput" class="input-small disabled" type="text" disabled="" placeholder="<?php echo $_SESSION['OS'];?>"> <a class="btn btn-danger" href="quita.php?quitar=os" title="<?php echo RESET_SELECTED_MESSAGE;?>"><i class="icon-trash icon-white"></i> <?php echo RESET_SELECTED_MESSAGE;?></a><br> </div>



<div class="control-group"> <label class="control-label"><?php echo PORT_SELECTED_MESSAGE; ?></label> <div class="controls"> <select name="puerto" id="puerto" class="input-small span2" > <option value="COM1">COM 1</option> <option value="COM2">COM 2</option> <option value="COM3">COM 3</option> <option value="COM4">COM 4</option> <option value="COM5">COM 5</option> <option value="COM6">COM 6</option> <option value="COM7">COM 7</option> <option value="COM8">COM 8</option> <option value="COM9">COM 9</option> <option value="CNCA0">CNCA0</option> <option value="CNCB0">CNCB0</option> <option value="COM33">COM33</option> <option value="COM34">COM34</option> <option value="COM35">COM35</option> </select> <?php echo( DETECT_PORT_MESSAGE ); ?>: <select id="automanual" class="span2"> <option value="0"><?php echo MANUAL_MESSAGE;?></option> <option value="1"><?php echo AUTO_MESSAGE;?></option> </select> </div> </div><?php }

if ((!isset($_SESSION['puerto'])) && ($_SESSION['OS']=='LINUX')) {?> <div class="span8"> <form id='config' method="post" action="" class="form-horizontal"> <fielset>


<div class="control-group"> <label class="control-label"><?php echo PORT_SELECTED_MESSAGE; ?></label> <div class="controls"> <select name="puerto" id="puerto" class="input-small span2" > <option value="/dev/ttyS0">/dev/ttyS0</option> <option value="/dev/ttyS1">/dev/ttyS1</option> <option value="/dev/ttyS2">/dev/ttyS2</option> <option value="/dev/ttyS3">/dev/ttyS3</option> <option value="/dev/ttyS30">/dev/ttyS30</option> <option value="/dev/ttyS31">/dev/ttyS31</option> <option value="/dev/ttyS32">/dev/ttyS32</option> <option value="/dev/ttyS33">/dev/ttyS33</option> <option value="/dev/ttyUSB0">/dev/ttyUSB0</option> <option value="/dev/ttyACM0">/dev/ttyACM0</option> <option value="/dev/ttyACM1">/dev/ttyACM1</option> </select> <?php echo( DETECT_PORT_MESSAGE ); ?>: <select id="automanual" class="span2"> <option value="0"><?php echo MANUAL_MESSAGE;?></option> <option value="1"><?php echo AUTO_MESSAGE;?></option> </select> </div> </div><?php }

if (isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!="") {?> <div class="span8"> <form id='config' method="post" action="accion.php?accion=configura" class="form-horizontal"> <fielset>


<div class="control-group">



<label class="control-label"><?php echo PORT_SELECTED_MESSAGE; ?></label> <input id="disabledInput" class="input-small disabled" type="text" disabled="" placeholder="<?php echo $_SESSION['puerto'];?>"> <a class="btn" href="quita.php?quitar=puerto&ir=<?php echo substr($_SERVER['SCRIPT_NAME'],0,-4);?>" title="<?php echo CHANGE_PORT_MESSAGE; ?>"><i class="icon-wrench"></i> <?php echo CHANGE_PORT_MESSAGE; ?></a><br> </div>

<div class="control-group"> <label class="control-label"><?php echo( SPEED_MESSAGE ); ?></label> <div class="controls"> <?php if ( isset($_SESSION['velocidad']) ) { ?> <select name="velocidad" id="velocidad" class="span2" > <option value="110" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="110") ? 'selected="selected" ' : ''; ?>>110</option> <option value="150" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="150") ? 'selected="selected" ' : ''; ?>>150</option> <option value="300" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="300") ? 'selected="selected" ' : ''; ?>>300</option> <option value="600" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="600") ? 'selected="selected" ' : ''; ?>>600</option> <option value="1200" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="1200") ? 'selected="selected" ' : ''; ?>>1200</option> <option value="2400" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="2400") ? 'selected="selected" ' : ''; ?>>2400</option> <option value="4800" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="4800") ? 'selected="selected" ' : ''; ?>>4800</option> <option value="9600" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="9600") ? 'selected="selected" ' : ''; ?>>9600</option> <option value="38400" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="38400") ? 'selected="selected" ' : ''; ?>>38400</option> <option value="57600" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="57600") ? 'selected="selected" ' : ''; ?>>57600</option> <option value="115200" <?php echo (isset($_SESSION['velocidad']) && $_SESSION['velocidad']=="115200") ? 'selected="selected" ' : ''; ?>>115200</option> </select> <?php } else { ?> <select name="velocidad" id="velocidad" class="span2" > <option value="110" >110</option> <option value="150" >150</option> <option value="300" >300</option> <option value="600" >600</option> <option value="1200" >1200</option> <option value="2400" >2400</option> <option value="4800" >4800</option> <option value="9600" selected="selected" >9600</option> <option value="38400" >38400</option> <option value="57600" >57600</option> <option value="115200" >115200</option> </select> <?php } ?> <p class="help-inline"><?php echo DEFAULT_MESSAGE; ?> "9600"</p> </div> </div>

<div class="control-group"> <label class="control-label"><?php echo( DATABIT_MESSAGE ); ?></label> <div class="controls"> <?php if ( isset($_SESSION['databit']) ) { ?> <select name="databit" id="databit" class="span1" > <option value="5" <?php echo (isset($_SESSION['databit']) && $_SESSION['databit']=="5") ? 'selected="selected" ' : ''; ?>>5</option> <option value="6" <?php echo (isset($_SESSION['databit']) && $_SESSION['databit']=="6") ? 'selected="selected" ' : ''; ?>>6</option> <option value="7" <?php echo (isset($_SESSION['databit']) && $_SESSION['databit']=="7") ? 'selected="selected" ' : ''; ?>>7</option> <option value="8" <?php echo (isset($_SESSION['databit']) && $_SESSION['databit']=="8") ? 'selected="selected" ' : ''; ?>>8</option> </select> <?php } else { ?> <select name="databit" id="databit" class="span1" > <option value="5" >5</option> <option value="6" >6</option> <option value="7" >7</option> <option value="8" selected="selected" >8</option> </select> <?php } ?> <p class="help-inline"><?php echo DEFAULT_MESSAGE; ?> "8"</p> </div> </div>

<div class="control-group"> <label class="control-label"><?php echo( PARITY_MESSAGE ); ?></label> <div class="controls"> <select name="paridad" id="paridad" class="span2" >



<option value="none" <?php echo (isset($_SESSION['paridad']) && $_SESSION['paridad']=="none") ? 'selected="selected" ' : ''; ?>><?php echo( NOPARITY_MESSAGE ); ?></option> <option value="odd" <?php echo (isset($_SESSION['paridad']) && $_SESSION['paridad']=="odd") ? 'selected="selected" ' : ''; ?>><?php echo( PARITYODD_MESSAGE ); ?></option> <option value="even" <?php echo (isset($_SESSION['paridad']) && $_SESSION['paridad']=="even") ? 'selected="selected" ' : ''; ?>><?php echo( PARITYEVEN_MESSAGE ); ?></option> </select> <p class="help-inline"><?php echo DEFAULT_MESSAGE . ' "' . NOPARITY_MESSAGE . '"'; ?></p> </div> </div><?php/*<select name="stopbit" id="stopbit" class="span1" > <option value="1" <?php echo (isset($_SESSION['stopbit']) && $_SESSION['stopbit']=="1") ? 'selected="selected" ' : ''; ?>>1</option> <option value="1.5" <?php echo (isset($_SESSION['stopbit']) && $_SESSION['stopbit']=="1.5") ? 'selected="selected" ' : ''; ?>>1.5</option> <option value="2.0" <?php echo (isset($_SESSION['stopbit']) && $_SESSION['stopbit']=="2.0") ? 'selected="selected" ' : ''; ?>>2.0</option></select>*/?> <div class="control-group"> <label class="control-label"><?php echo( STOPBIT_MESSAGE ); ?></label> <div class="controls"> <label class="radio inline"> <?php if ( isset($_SESSION['stopbit']) ) { ?> <input id="optionsRadios1" type="radio" <?php echo (isset($_SESSION['stopbit']) && $_SESSION['stopbit']=="1") ? 'checked=""' : ''; ?> value="1" name="stopbit"> 1 </label> <label class="radio inline"> <input id="optionsRadios1.5" type="radio" <?php echo (isset($_SESSION['stopbit']) && $_SESSION['stopbit']=="1.5") ? 'checked=""' : ''; ?> value="1.5" name="stopbit"> 1.5 </label> <label class="radio inline"> <input id="optionsRadios2" type="radio" <?php echo (isset($_SESSION['stopbit']) && $_SESSION['stopbit']=="2.0") ? 'checked=""' : ''; ?> value="2" name="stopbit"> 2 <?php } else { ?> <input id="optionsRadios1" type="radio" checked="" value="1" name="stopbit"> 1 </label> <label class="radio inline"> <input id="optionsRadios1.5" type="radio" value="1.5" name="stopbit"> 1.5 </label> <label class="radio inline"> <input id="optionsRadios2" type="radio" value="2" name="stopbit"> 2 <?php } ?> </label> <p class="help-block"><?php echo DEFAULT_MESSAGE; ?> "1"</p> </div> </div>

<div class="control-group"> <label class="control-label"><?php echo( CONTROL_MESSAGE ); ?></label> <div class="controls"> <select name="control" id="control" class="span2" > <option value="none" <?php echo (isset($_SESSION['control']) && $_SESSION['control']=="none") ? 'selected="selected" ' : ''; ?>><?php echo( NOCONTROL_MESSAGE ); ?></option> <option value="rts/cts" <?php echo (isset($_SESSION['control']) && $_SESSION['control']=="rts/cts") ? 'selected="selected" ' : ''; ?>>rts/cts (hardware)</option> <option value="xon/xoff" <?php echo (isset($_SESSION['control']) && $_SESSION['control']=="xon/xoff") ? 'selected="selected" ' : ''; ?>>xon/xoff (software)</option> </select> <p class="help-inline"><?php echo DEFAULT_MESSAGE . ' "' . NOCONTROL_MESSAGE . '"'; ?></p> </div> </div>

<?php }?> <div class="form-actions"> <a class="btn btn-primary" href="javascript:messagebox();" ><?php echo SAVE_MESSAGE;?></a> <a class="btn" href="javascript:history.back(1)"><i class="icon-chevron-left"></i> <?php echo( GOBACK_MESSAGE );?></a> <a class="btn" href="../"><i class="icon-home"></i> <?php echo( GOHOME_MESSAGE );?></a> <a class="btn btn-danger" href="quita.php" ><i class="icon-trash icon-white"></i> <?php echo DELETE_MESSAGE . " " . strtolower(CONFIGURACION_MESSAGE); ?></a> <div id="messageBox"> </div> </div>

</fielset> </form>

</div>  </div> <?php } else {?> <div class="alert alert-block alert-error fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading">ERROR</h4> <p><?php echo ERROR_OSNOT_DETECTED_MESSAGE; ?></p> <p> <?php if (!isset($_SESSION['OS']) || $_SESSION['OS']=="") { ?> <a class="btn btn-primary" href="../configuracion/osinfo.php"><?php echo( DETECT_OS_MESSAGE );?></a> <?php } ?> </p> </div><a class="btn" href="javascript:history.back(1)"><i class="icon-chevron-left"></i> <?php echo( GOBACK_MESSAGE );?></a><a class="btn" href="../"><i class="icon-home"></i> <?php echo( GOHOME_MESSAGE );?></a><?php }?></div> 

<?php include("../javascript.php"); ?><script type="text/javascript" charset="utf-8"> $(function(){ $("select#automanual").change(function(){ <?php if ( $_SESSION['OS']=="LINUX" ) { ?> $.getJSON("../cgi-bin/givemeports_linux.py",{id: $(this).val()}, function(j){ <?php } ?> <?php if ( $_SESSION['OS']=="WINDOWS" ) { ?> $.getJSON("../cgi-bin/portsnobusy_windows.py",{id: $(this).val()}, function(j){ <?php } ?> var options = ''; for (var i = 0; i < j.length; i++) { options += '<option value="' + j[i].optionValue + '">' + j[i].optionDisplay + '</option>'; } $("#puerto").html(options); $('#puerto option:first').attr('selected', 'selected'); }) }) })</script></body></html>

detectar_port.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?></head><body><?php include("../menu.php"); ?><div class="container"><h1><?php echo MANUAL_MESSAGE; ?> <small><?php echo DETECT_PORT_MESSAGE; ?></small></h1><?phpif ( isset($_SESSION['OS']) && ($_SESSION['OS']!="") ) { $_SESSION['puerto'] = giveme_port($_SESSION['OS']);?> <br> <h2><?php echo ucfirst(DETECTED_PORT_MESSAGE).":"; ?> <strong><?php echo $_SESSION['puerto']; ?></strong></h2> <br><br><?php } else {?> <div class="alert alert-block alert-error fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading">ERROR</h4> <p><?php echo ERROR_OSNOT_DETECTED_MESSAGE; ?></p>

<p> <?php if (!isset($_SESSION['OS']) || $_SESSION['OS']=="") { ?> <a class="btn btn-primary" href="../configuracion/osinfo.php"><?php echo( DETECT_OS_MESSAGE );?></a> <?php } ?> </p> </div><?php }?><a class="btn" href="javascript:history.back(1)"><i class="icon-chevron-left"></i> <?php echo( GOBACK_MESSAGE );?></a><a class="btn" href="../"><i class="icon-home"></i> <?php echo( GOHOME_MESSAGE );?></a></div> 


</body></html>

detectar_tot.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?> <meta http-equiv="Refresh" content="5;url=../" /></head><body><?php include("../menu.php"); ?><div class="container"><h1><?php echo( AUTO_MESSAGE ); ?> <small><?php echo( AUTODETECALL_MESSAGE ); ?></small></h1><?php$_SESSION['OS'] = giveme_os();$_SESSION['puerto'] = giveme_port($_SESSION['OS']);?><h2>Control <small><?php echo INFOOS_MESSAGE; ?>:<strong> <?php echo $_SESSION['OS'];?></strong> · <?php echo PORT_SELECTED_MESSAGE; ?> <strong><?php echo $_SESSION['puerto'];?></strong></small></h2><?php//configuració per defecte:$_SESSION['velocidad']="9600";$_SESSION['databit']="8";$_SESSION['paridad']="none";$_SESSION['stopbit']="1";$_SESSION['control']="none";?><br><?php echo( SPEED_MESSAGE ); ?> <strong><?php echo $_SESSION['velocidad'];?></strong><br><?php echo( DATABIT_MESSAGE ); ?> <strong><?php echo $_SESSION['databit'];?></strong><br><?php echo( PARITY_MESSAGE ); ?> <strong><?php echo $_SESSION['paridad'];?></strong><br><?php echo( STOPBIT_MESSAGE ); ?> <strong><?php echo $_SESSION['stopbit'];?></strong><br><?php echo( CONTROL_MESSAGE ); ?> <strong><?php echo $_SESSION['control'];?></strong><br><br><p><span class="label label-warning"><?php echo( WARNING_MESSAGE ); ?></span> <?php echo( REDIRECT_MESSAGE ); ?></p><br><a class="btn" href="javascript:history.back(1)"><i class="icon-chevron-left"></i> <?php echo( GOBACK_MESSAGE );?></a><a class="btn" href="../"><i class="icon-home"></i> <?php echo( GOHOME_MESSAGE );?></a></div> 


</body></html>

emulatorMSP430_linux.py

#!/usr/bin/python

# Description:# SERIAL PORT EMULATOR# for specific sentence to emulate MSP430

# Author Version Date Change# F.Quinto 1.0 2012-08-05 Initial release

import serial



import sysimport timefrom time import time,sleepimport random

# =================== VARS ===================

# Puerto comunicacionesport = "/dev/pts/6"velocidad = 9600

# emulacion de AP=1 o ED=0emulaAP = 1

# ================= END VARS =================

ser = serial.Serial(port, velocidad, timeout=0)

# estado leds inicial = OFFestado_led1 = "001"estado_led2 = "001"estado_led3 = "001"estado = "000"data = ''veces = 2n = 0while True: #data = ser.read(99) newdata = ser.readline() if (len(newdata) > 0): n = 1 data += newdata if (len(data) == 8): header = data[0:1] readwrite = data[1:2] address = data[2:4] datamsg = data[4:7] print "-------------------------------------" print 'RECIBIDO: '+ header + readwrite + address + datamsg + ' = ', if (header == "A"): print "AP ", respuesta = "D" if (header == "B"): print "ED ", respuesta = "G" if (header == "C"): print "FPGA ", respuesta = "J" if (readwrite == "R"): print "READ ", if (readwrite == "W"): print "WRITE ", if (address == "10"): print "Led2 (rojo) ", if (readwrite == "W"): if (datamsg == "000"): #ON estado_led2 = "000" else: #OFF estado_led2 = "001" estado = estado_led2 if (address == "11"): print "Led1 (verde) ", if (readwrite == "W"): if (datamsg == "000"): #ON estado_led1 = "000" else: #OFF estado_led1 = "001" estado = estado_led1 if (address == "12"): print "Button ", if (datamsg == "000"): estado = "000" if (address == "20"): print "Led3 (amarillo) ", if (readwrite == "W"): if (datamsg == "000"): #ON estado_led3 = "000" else: #OFF



estado_led3 = "001" estado = estado_led3 if (address == "50"): print "Temperatura ", if (readwrite == "R"): if (datamsg == "000"): a = "2" b = str(random.randint(7, 9)) c = str(random.randint(0, 9)) estado = a + b + c if (address == "51"): print "RSSI ", if (readwrite == "R"): if (datamsg == "000"): a = str(random.randint(2, 3)) b = str(random.randint(0, 9)) c = str(random.randint(0, 9)) estado = a + b + c if (address == "52"): print "Voltage ", if (readwrite == "R"): if (datamsg == "000"): a = "3" b = str(random.randint(5, 6)) c = str(random.randint(0, 9)) estado = a + b + c if (address == "60"): print "Set address ED ", print datamsg if (address == "61"): print "Set address AP ", print datamsg if (address == "62"): if (datamsg == "000"): print "Setup ED " if (datamsg == "001"): print "Setup AP " datamsg = "xxx" if (datamsg == "000"): print "ON" if (datamsg == "001"): print "OFF" if (readwrite == "R"): envia = respuesta + "R" + address + estado + "\r\n" print 'ENVIA:',envia ser.write(envia) #if (data == (header+readwrite+address+"123\r")): #envia = "DNode:AP,Temp: 34.5C,Battery:3.7V,Strength:028%\r\n" #print 'ENVIA:',envia #ser.write(envia) data = '' veces = 2 if (veces < 1): data = '' veces = 2 veces = veces - 1ser.close()

emulatorMSP430_windows.py

#!C:\Python32\python.exe -u#!/usr/bin/env python

# Description:# SERIAL PORT EMULATOR# for specific sentence to emulate MSP430

# Author Version Date Change# F.Quinto 1.0 2012-08-05 Initial release

import serialimport sysimport timefrom time import time,sleepimport random

# =================== VARS ===================

# Puerto comunicacionesport = "COM11"



velocidad = 9600

# emulacion de AP=1 o ED=0emulaAP = 1

# ================= END VARS =================

ser = serial.Serial(port, velocidad, timeout=0)

# estado leds inicial = OFFestado_led1 = "001"estado_led2 = "001"estado_led3 = "001"estado = "000"data = ''veces = 2n = 0while True: #data = ser.read(99) newdata = ser.readline() if (len(newdata) > 0): n = 1 data += newdata.decode('utf-8') #print ("newdata = ",newdata.decode('utf-8')) #print ("data = ",str(data)) if (len(data) == 8): header = data[0:1] readwrite = data[1:2] address = data[2:4] datamsg = data[4:7] print ("-------------------------------------") print ('RECIBIDO: '+ header + readwrite + address + datamsg + ' = ', end="") if (header == "A"): print ("AP ", end="") respuesta = "D" if (header == "B"): print ("ED ", end="") respuesta = "G" if (header == "C"): print ("FPGA ", end="") respuesta = "J" if (readwrite == "R"): print ("READ ", end="") if (readwrite == "W"): print ("WRITE ", end="") if (address == "10"): print ("Led2 (rojo) ", end="") if (readwrite == "W"): if (datamsg == "000"): #ON estado_led2 = "000" else: #OFF estado_led2 = "001" estado = estado_led2 if (address == "11"): print ("Led1 (verde) ", end="") if (readwrite == "W"): if (datamsg == "000"): #ON estado_led1 = "000" else: #OFF estado_led1 = "001" estado = estado_led1 if (address == "12"): print ("Button ", end="") if (datamsg == "000"): estado = "000" if (address == "20"): print ("Led3 (amarillo) ", end="") if (readwrite == "W"): if (datamsg == "000"): #ON estado_led3 = "000" else: #OFF estado_led3 = "001" estado = estado_led3 if (address == "50"): print ("Temperatura ", end="") if (readwrite == "R"): if (datamsg == "000"): a = "2"



b = str(random.randint(7, 9)) c = str(random.randint(0, 9)) estado = a + b + c if (address == "51"): print ("RSSI ", end="") if (readwrite == "R"): if (datamsg == "000"): a = str(random.randint(2, 3)) b = str(random.randint(0, 9)) c = str(random.randint(0, 9)) estado = a + b + c if (address == "52"): print ("Voltage ", end="") if (readwrite == "R"): if (datamsg == "000"): a = "3" b = str(random.randint(5, 6)) c = str(random.randint(0, 9)) estado = a + b + c if (address == "60"): print ("Set address ED ", end="") print (datamsg) if (address == "61"): print ("Set address AP ", end="") print (datamsg) if (address == "62"): if (datamsg == "000"): print ("Setup ED ") if (datamsg == "001"): print ("Setup AP ") datamsg = "xxx" if (datamsg == "000"): print ("ON") if (datamsg == "001"): print ("OFF") if (readwrite == "R"): envia = respuesta + "R" + address + estado + "\r\n" print ('ENVIA:',envia) ser.write(envia.encode('utf-8')) #if (data == (header+readwrite+address+"123\r")): #envia = "DNode:AP,Temp: 34.5C,Battery:3.7V,Strength:028%\r\n" #print 'ENVIA:',envia #ser.write(envia) data = '' veces = 2 if (veces < 1): data = '' veces = 2 veces = veces - 1ser.close()

enviar.php

<?phpif (!isset($_SESSION)) { session_start();}

include("../init.php");include "../linux/php_serial.class.php";

// Let's start the class$serial = new phpSerial;

$enable_exceptions=1; // 1 = ON and 0 = OFF

if (isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!=""){ //envio normal if (isset($_GET['q']) && $_GET['q']!="") { $_SESSION['mensaje']=$_GET['q']; $enable_exceptions=0; } //envio ajax if (isset($_GET['q2']) && $_GET['q2']!="") { $_SESSION['mensaje']=$_GET['q2']; }



try { $serial->deviceSet($_SESSION['puerto']); } catch (Exception $e) { if ($enable_exceptions) { echo 'Caught exception: <trong>', $e->getMessage(), "</strong>\n"; exit; } } if (isset($_SESSION['velocidad'])) { try { $serial->confBaudRate($_SESSION['velocidad']); } catch (Exception $e) { if ($enable_exceptions) { echo 'Caught exception: <trong>', $e->getMessage(), "</strong>\n"; exit; } } } if (isset($_SESSION['databit'])) { try { $serial->confCharacterLength($_SESSION['databit']); } catch (Exception $e) { if ($enable_exceptions) { echo 'Caught exception: <trong>', $e->getMessage(), "</strong>\n"; exit; } } } if (isset($_SESSION['paridad'])) { try { $serial->confParity($_SESSION['paridad']); } catch (Exception $e) { if ($enable_exceptions) { echo 'Caught exception: <trong>', $e->getMessage(), "</strong>\n"; exit; } } } if (isset($_SESSION['stopbit'])) { try { $serial->confStopBits($_SESSION['stopbit']); } catch (Exception $e) { if ($enable_exceptions) { echo 'Caught exception: <trong>', $e->getMessage(), "</strong>\n"; exit; } } } if (isset($_SESSION['control'])) { try { $serial->confFlowControl($_SESSION['control']); } catch (Exception $e) { if ($enable_exceptions) { echo 'Caught exception: <trong>', $e->getMessage(), "</strong>\n"; exit; } } } try { $serial->deviceOpen(); } catch (Exception $e) { if ($enable_exceptions) { echo 'Caught exception: <trong>', $e->getMessage(), "</strong>\n"; exit; } } try { $serial->sendMessage($_SESSION['mensaje']."\r"); } catch (Exception $e) { if ($enable_exceptions) { echo 'Caught exception: <trong>', $e->getMessage(), "</strong>\n";



exit; } } //envio normal if (isset($_GET['q']) && $_GET['q']!="") { header("Location: escriure_port.php"); exit; } //envio ajax if (isset($_GET['q2']) && $_GET['q2']!="") { usleep(1000); echo "<br><br>\n".SENT_MESSAGE . " <strong>" . $_SESSION['mensaje'] . "</strong>"; usleep(1000); } }?>

enviar_linux.py

#!/usr/bin/python# Import modules for CGI handling

import cgi, cgitbimport sys, serial, time

# Create instance of FieldStorageform = cgi.FieldStorage() # instantiate only once!

# Get the first#name = form.getfirst('name', 'empty')

# getlist() returns a list containing the# values of the fields with the given name#colors = form.getlist('color')

puerto = form.getvalue('puerto')velocidad = form.getvalue('velocidad')databit = form.getvalue('databit')if (databit == "5"): databit = serial.FIVEBITSif (databit == "6"): databit = serial.SIXBITSif (databit == "7"): databit = serial.SEVENBITSif (databit == "8"): databit = serial.EIGHTBITSstopbit = form.getvalue('stopbit')if (stopbit == "1"): stopbit = serial.STOPBITS_ONEif (stopbit == "1.5"): stopbit = serial.STOPBITS_ONE_POINT_FIVEif (stopbit == "2.0"): stopbit = serial.STOPBITS_TWOparidad = form.getvalue('paridad')if (paridad == "none"): paridad = serial.PARITY_NONEif (paridad == "odd"): paridad = serial.PARITY_ODDif (paridad == "even"): paridad = serial.PARITY_EVENcontrol = form.getvalue('control')if (control == "none"): hard=0 soft=0if (control == "rts/cts"): hard=1 soft=0if (control == "xon/xoff"): hard=0 soft=1cabecera = form.getvalue('destino_msg')if (cabecera == "AP"): cabecera = chr(0x41)if (cabecera == "ED"): cabecera = chr(0x42)if (cabecera == "FG"):



cabecera = chr(0x43)if (cabecera == "undefined"): cabecera = chr(0x43)

rw_msg = form.getvalue('rw')if (rw_msg == "undefined" or rw_msg == None): rw_msg = "R"

address_msg = form.getvalue('address')if (address_msg == "undefined" or address_msg == None): address_msg = "10"

data_msg = form.getvalue('data')if (data_msg == "undefined" or data_msg == None): data_msg = "000"

message = rw_msg + address_msg + data_msg

lang_msg = form.getvalue('lang')

if (str(lang_msg) == "undefined" or str(lang_msg) == "None"): lang_msg = "es"

if (lang_msg == "es"): error_msg = "ERROR: no puedo abrir el puerto!" info_msg = "Mensaje enviado: "if (lang_msg == "ca"): error_msg = "ERROR: no puc obrir el port!" info_msg = "Missatge enviat: "if (lang_msg == "en"): error_msg = "ERROR: Could not open port!" info_msg = "Message sent: "

print ("Content-Type: text/html\n")try: # Avoid script injection escaping the user input message = cgi.escape(message) #ser = serial.Serial(port=puerto, baudrate=velocidad, timeout=2, bytesize=databit, stopbits=stopbit, parity=paridad, rtscts=hard, xonxoff=soft) ser = serial.Serial() ser.port = puerto ser.baudrate = velocidad ser.timeout = 2 ser.parity = paridad ser.stopbits = stopbit ser.bytesize = databit ser.rtscts = hard ser.xonxoff = soft ser.open() #ser.isOpen()except: print """\<html><body><p>%s</p></body></html>""" % (error_msg)else: #ser.open() #while (name != "2"): #time.sleep(1.5) ser.write(cabecera) time.sleep(0.15) #if (len(message)>7): #ser.write(message[0:7]) #time.sleep(0.15) #ser.write(message[7:]) #else: ser.write(message) if (len(message)<15): ser.write("\r") print """\<html><body><p>%s</p></body></html>""" % (info_msg+cabecera+message) #time.sleep(2) #ser.close()## tested on Arduino: abans treure el RESET (http://www.arduino.cc/playground/Main/DisablingAutoResetOnSerialConnection)

http://www.arduino.cc/playground/Main/DisablingAutoResetOnSerialConnection



enviar_windows.py

#!C:\Python32\python.exe -u#!/usr/bin/env python# Import modules for CGI handling import cgi, cgitbimport sys, serial, time

# Create instance of FieldStorageform = cgi.FieldStorage() # instantiate only once!

# Get the first#name = form.getfirst('name', 'empty')

# getlist() returns a list containing the# values of the fields with the given name#colors = form.getlist('color')

puerto = form.getvalue('puerto')velocidad = form.getvalue('velocidad')databit = form.getvalue('databit')if (databit == "5"): databit = serial.FIVEBITSif (databit == "6"): databit = serial.SIXBITSif (databit == "7"): databit = serial.SEVENBITSif (databit == "8"): databit = serial.EIGHTBITSstopbit = form.getvalue('stopbit')if (stopbit == "1"): stopbit = serial.STOPBITS_ONEif (stopbit == "1.5"): stopbit = serial.STOPBITS_ONE_POINT_FIVEif (stopbit == "2.0"): stopbit = serial.STOPBITS_TWOparidad = form.getvalue('paridad')if (paridad == "none"): paridad = serial.PARITY_NONEif (paridad == "odd"): paridad = serial.PARITY_ODDif (paridad == "even"): paridad = serial.PARITY_EVENcontrol = form.getvalue('control')if (control == "none"): hard=0 soft=0if (control == "rts/cts"): hard=1 soft=0if (control == "xon/xoff"): hard=0 soft=1cabecera = form.getvalue('destino_msg')if (cabecera == "AP"): cabecera = chr(0x41)if (cabecera == "ED"): cabecera = chr(0x42)if (cabecera == "FG"): cabecera = chr(0x43)if (cabecera == "undefined"): cabecera = chr(0x43)

rw_msg = form.getvalue('rw')if (rw_msg == "undefined" or rw_msg == None): rw_msg = "R"

address_msg = form.getvalue('address')if (address_msg == "undefined" or address_msg == None): address_msg = "10"

data_msg = form.getvalue('data')if (data_msg == "undefined" or data_msg == None): data_msg = "000"

message = rw_msg + address_msg + data_msg





if (lang_msg == "es"): error_msg = "ERROR: no puedo abrir el puerto!" info_msg = "Mensaje enviado: "if (lang_msg == "ca"): error_msg = "ERROR: no puc obrir el port!" info_msg = "Missatge enviat: "if (lang_msg == "en"): error_msg = "ERROR: Could not open port!" info_msg = "Message sent: "

print ("Content-Type: text/html\n")try: ser = serial.Serial(port=puerto, baudrate=velocidad, timeout=2, bytesize=databit, stopbits=stopbit, parity=paridad, rtscts=hard, xonxoff=soft)# ser = serial.Serial(port='COM3', baudrate=9600, timeout=2, bytesize=serial.EIGHTBITS, stopbits=serial.STOPBITS_ONE, parity=serial.PARITY_NONE, rtscts=0, xonxoff=0)except: print ("<html><body><p>",error_msg,"</p></body></html>")else: ser.write(cabecera.encode()) time.sleep(0.15) #if (len(message)>7): #ser.write(message[0:7].encode('utf-8')) #time.sleep(0.15) #ser.write(message[7:].encode('utf-8')) #else: ser.write(message.encode('utf-8')) if (len(message)<15): ser.write(b'\r') print ("<html><body><p>",info_msg+cabecera+message,"</p></body></html>") #time.sleep(2) #ser.close()

## tested on Arduino: abans treure el RESET (http://www.arduino.cc/playground/Main/DisablingAutoResetOnSerialConnection)

escriure_ajax.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?><script> function foco(){ document.enviar.q2.focus() document.enviar.q2.select() }</script><script type="text/javascript">function showHint(str){if (str.length==0) { document.getElementById("txtHint").innerHTML=""; return; }if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmlhttp=new XMLHttpRequest(); }else {// code for IE6, IE5 xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); }xmlhttp.onreadystatechange=function() { if (xmlhttp.readyState==4 && xmlhttp.status==200) { document.getElementById("txtHint").innerHTML=xmlhttp.responseText; } }xmlhttp.open("GET","enviar.php?q2="+str,true);xmlhttp.send();document.enviar.q2.value="";}</script></head>



<body onload="foco();"><?php include("../menu.php"); ?><div class="container"><?php if (isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!=""){ ?> <?php echo INFOOS_MESSAGE; ?> <strong><?php echo $_SESSION['OS'];?></strong><br> <?php echo PORT_SELECTED_MESSAGE; ?> <strong><?php echo $_SESSION['puerto'];?></strong><br> <br><br> <form id="enviar" name="enviar" method="post" action=""> <?php echo WRITE_MESSAGE; ?> <input name="q2" type="text" id="q2" size="10" maxlength="10" onkeyup="showHint(this.value)" /> </form><br> <span id="txtHint"></span><?php} else { echo ERROR_BEFOREWRITE_MESSAGE;} ?></div>


</body></html>

escriure_port.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?> <script> function foco(){ document.enviar.q.focus() document.enviar.q.select() } </script> <link rel="stylesheet" type="text/css" href="../css/button.css" /></head><body onload="foco();"><?php include("../menu.php"); ?><div class="container"><?php if (isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!=""){ ?> <?php echo INFOOS_MESSAGE; ?> <strong><?php echo $_SESSION['OS'];?></strong><br> <?php echo PORT_SELECTED_MESSAGE; ?> <strong><?php echo $_SESSION['puerto'];?></strong><br> <br><br> <form name="enviar" method="get" action="enviar.php"> <?php echo WRITE_MESSAGE; ?> <input name="q" id="q" type="text" size="10" maxlength="10" value="<?php echo (isset($_SESSION['mensaje'])) ? $_SESSION['mensaje'] : '' ?>" /> <input type="submit" class="button" value="<?php echo SEND_BUTTON_MESSAGE; ?>" /> </form><?php} else { echo ERROR_BEFOREWRITE_MESSAGE;} ?></div>


</body></html>

givemeports_linux.py

#!/usr/bin/python# -*- coding: iso-8859-15 -*-#----------------------------------------------------------------------------# scan.py Modulo para obtener una lista de los puertos series disponibles#----------------------------------------------------------------------------# Notas: En Linux solo se detectan los puertos del tipo /dev/ttySx # disponibles, que son a los que la libreria pyserial les asigna los # valores 0, 1, 2, etc. Los dispositivos del tipo /dev/ttyUSBx no se# detectan. Para poder usarlos como cualquier otro dispositivo, se



# puede hacer un enlace simbolico:# # ln -s /dev/ttyUSB0 /dev/ttyS10# Asociamos el dispositivo ttyUSB0 a uno del tipo ttyS10. En ese caso si # se detecta correctamente con esta rutina. En este ejemplo devolveria el# valor 10 (si realmente en /dev/ttyUSB0 hay un conversor usb-serie)## 2012: cambiamos para devolver según parámetros el JSON adecuado.#----------------------------------------------------------------------------## (C)2002 Chris Liechti ([email protected])# (C)2007 Juan Gonzalez# (C)2012 F.Quinto## LICENCIA GPL#----------------------------------------------------------------------------

import sysimport serialimport cgi, cgitbimport json

#-----------------------------------------------------------------------------# Buscar puertos series disposibles. # ENTRADAS:# -num_ports : Numero de puertos a escanear. Por defecto 20# -verbose : Modo verboso True/False. Si esta activado se va # imprimiendo todo lo que va ocurriendo# DEVUELVE: # Una lista con todos los puertos encontrados. Cada elemento de la lista# es una tupla con el numero del puerto y el del dispositivo #-----------------------------------------------------------------------------def scan(num_ports = 20, verbose=True): #-- Lista de los dispositivos serie. Inicialmente vacia dispositivos_serie = [] if verbose: print "Escanenado %d puertos serie:" % num_ports #-- Escanear num_port posibles puertos serie for i in range(num_ports): if verbose: sys.stdout.write("puerto %d: " % i) sys.stdout.flush() try: #-- Abrir puerto serie s = serial.Serial(i) if verbose: print "OK --> %s" % s.portstr #-- Si no hay errores, anadir el numero y nombre a la lista dispositivos_serie.append( (i, s.portstr)) #-- Cerrar puerto s.close() #-- Si hay un error se ignora except: if verbose: print "NO" pass #-- Devolver la lista de los dispositivos serie encontrados return dispositivos_serie

#--------------------------# Pruebas del modulo Scan #--------------------------if __name__=='__main__':

form = cgi.FieldStorage() # instantiate only once! auto = form.getvalue('id') #-- Escanear los puertos. #-- Se puede indicar el numero de puertos a escaner #-- El modo "verbose" esta activado por defecto. Se desactiva con False puertos_disponibles=scan(num_ports=33,verbose=False) #-- Recorrer la lista mostrando los que se han podido abrir print "Content-Type: application/json\n" if (auto == "1"):



if len(puertos_disponibles)!=0: jsondata = [] for n,nombre in puertos_disponibles: #print " (%d) %s" % (n,nombre) #jsondata = [jsondata + [n, nombre]] #aux = {n, nombre} aux = { 'optionValue':nombre, 'optionDisplay':nombre } jsondata.append(aux) print json.dumps( jsondata ) else: print "0" else: jsondata = [ {"optionValue": "/dev/ttyS0", "optionDisplay": "/dev/ttyS0"}, {"optionValue": "/dev/ttyS1", "optionDisplay": "/dev/ttyS1"}, {"optionValue": "/dev/ttyS2", "optionDisplay": "/dev/ttyS2"}, {"optionValue": "/dev/ttyS3", "optionDisplay": "/dev/ttyS3"}, {"optionValue": "/dev/ttyS30", "optionDisplay": "/dev/ttyS30"}, {"optionValue": "/dev/ttyS31", "optionDisplay": "/dev/ttyS31"}, {"optionValue": "/dev/ttyS32", "optionDisplay": "/dev/ttyS32"}, {"optionValue": "/dev/ttyS33", "optionDisplay": "/dev/ttyS33"}, {"optionValue": "/dev/ttyUSB0", "optionDisplay": "/dev/ttyUSB0"}, {"optionValue": "/dev/ttyACM0", "optionDisplay": "/dev/ttyACM0"}, {"optionValue": "/dev/ttyACM1", "optionDisplay": "/dev/ttyACM1"} ] print json.dumps( jsondata )

givemeports_windows.py

#!C:\Python32\python.exe -u#!/usr/bin/env python# -*- coding: iso-8859-15 -*-#----------------------------------------------------------------------------# scan.py Modulo para obtener una lista de los puertos series disponibles#----------------------------------------------------------------------------# Notas: En Linux solo se detectan los puertos del tipo /dev/ttySx # disponibles, que son a los que la libreria pyserial les asigna los # valores 0, 1, 2, etc. Los dispositivos del tipo /dev/ttyUSBx no se# detectan. Para poder usarlos como cualquier otro dispositivo, se # puede hacer un enlace simbolico:# # ln -s /dev/ttyUSB0 /dev/ttyS10# Asociamos el dispositivo ttyUSB0 a uno del tipo ttyS10. En ese caso si # se detecta correctamente con esta rutina. En este ejemplo devolveria el# valor 10 (si realmente en /dev/ttyUSB0 hay un conversor usb-serie)## 2012: cambiamos para devolver según parámetros el JSON adecuado.#----------------------------------------------------------------------------## (C)2002 Chris Liechti ([email protected])# (C)2007 Juan Gonzalez# (C)2012 F.Quinto## LICENCIA GPL#----------------------------------------------------------------------------

import sysimport serialimport cgi, cgitbimport json

#-----------------------------------------------------------------------------# Buscar puertos series disposibles. # ENTRADAS:# -num_ports : Numero de puertos a escanear. Por defecto 20# -verbose : Modo verboso True/False. Si esta activado se va # imprimiendo todo lo que va ocurriendo# DEVUELVE: # Una lista con todos los puertos encontrados. Cada elemento de la lista# es una tupla con el numero del puerto y el del dispositivo #-----------------------------------------------------------------------------def scan(num_ports = 20, verbose=True): #-- Lista de los dispositivos serie. Inicialmente vacia dispositivos_serie = [] #if verbose: #print "Escanenado %d puertos serie:" % num_ports #-- Escanear num_port posibles puertos serie for i in range(num_ports): if verbose: sys.stdout.write("puerto %d: " % i) sys.stdout.flush() try: #-- Abrir puerto serie s = serial.Serial(i) #if verbose: print "OK --> %s" % s.portstr #-- Si no hay errores, anadir el numero y nombre a la lista dispositivos_serie.append( (i, s.portstr)) #-- Cerrar puerto



s.close() #-- Si hay un error se ignora except: #if verbose: print "NO" pass #-- Devolver la lista de los dispositivos serie encontrados return dispositivos_serie

#--------------------------# Pruebas del modulo Scan #--------------------------if __name__=='__main__':

form = cgi.FieldStorage() # instantiate only once! auto = form.getvalue('id')

#-- Escanear los puertos. #-- Se puede indicar el numero de puertos a escaner #-- El modo "verbose" esta activado por defecto. Se desactiva con False puertos_disponibles=scan(num_ports=33,verbose=False) #-- Recorrer la lista mostrando los que se han podido abrir print ("Content-Type: application/json\n") if (auto == "1"): if len(puertos_disponibles)!=0: jsondata = [] for n,nombre in puertos_disponibles: #print " (%d) %s" % (n,nombre) #jsondata = [jsondata + [n, nombre]] #aux = {n, nombre} aux = { 'optionValue':nombre, 'optionDisplay':nombre } jsondata.append(aux) print (json.dumps( jsondata )) else: print ("0") else: jsondata = [ {"optionValue": "COM1", "optionDisplay": "COM 1"}, {"optionValue": "COM2", "optionDisplay": "COM 2"}, {"optionValue": "COM3", "optionDisplay": "COM 3"}, {"optionValue": "COM4", "optionDisplay": "COM 4"}, {"optionValue": "COM5", "optionDisplay": "COM 5"}, {"optionValue": "COM6", "optionDisplay": "COM 6"}, {"optionValue": "COM7", "optionDisplay": "COM 7"}, {"optionValue": "COM8", "optionDisplay": "COM 8"}, {"optionValue": "COM9", "optionDisplay": "COM 9"}, {"optionValue": "COM33", "optionDisplay": "COM 33"}, {"optionValue": "COM34", "optionDisplay": "COM 34"}, {"optionValue": "COM35", "optionDisplay": "COM 35"}, {"optionValue": "CNCA0", "optionDisplay": "CNCA0"}, {"optionValue": "CNCB0", "optionDisplay": "CNCB0"}] print (json.dumps( jsondata ))

graph_image.php

<?phpinclude("../init.php");

/* Library settings */define("PCHART_PATH", "../pChart2.1.2/");

include(PCHART_PATH."class/pData.class.php");include(PCHART_PATH."class/pDraw.class.php");include(PCHART_PATH."class/pImage.class.php");

$datosSERIE = array();//__________________________________________________________________________/* * DATA FROM PYTHON (serial port) *//*$PATH = url_completa('../cgi-bin/lectura_graph_linux.py'); //$PATH=http://127.0.0.1/serie/cgi-bin/lectura_graph_linux.py

for ($i = 0; $i <= 9; $i++) { $var= @stripslashes( @join( @file( $PATH ),"" ) ); $pieces = explode(",", $var); $valor = str_replace(array("\r\n", "\n", "\r"), '', $pieces[1]); //echo $valor; array_push($datosSERIE, $valor);}*///__________________________________________________________________________/* * DATA FOR TEST */$datosSERIE = array(829,745,713,842,810,812,874,880,874,880);//__________________________________________________________________________



$myData = new pData();$myData->addPoints($datosSERIE,"Serie1");//$myData->setSerieTicks("Serie1",4);$myData->setSerieDescription("Serie1",GRAPHIC_DATA);$myData->setSerieOnAxis("Serie1",0);

//$myData->addPoints(array("January","February","March","April","May","June","July","August"),"Absissa");$myData->addPoints(array("0","1","2","3","4","5","6","7","8","9"),"Absissa");$myData->setSerieDescription("Absissa","Months"); $myData->setAbscissa("Absissa");

$myData->setAxisPosition(0,AXIS_POSITION_LEFT);$myData->setAxisName(0,GRAPHIC_VALUES);$myData->setAxisUnit(0," ºC");

/* Will append the "autumn" palette to the current one */$myData->loadPalette(PCHART_PATH."palettes/navy.color",TRUE);

$myPicture = new pImage(700,330,$myData,TRUE);$myPicture->drawRectangle(0,0,699,329,array("R"=>0,"G"=>0,"B"=>0));

$myPicture->setShadow(TRUE,array("X"=>1,"Y"=>1,"R"=>50,"G"=>50,"B"=>50,"Alpha"=>20));

$myPicture->setFontProperties(array("FontName"=>PCHART_PATH."fonts/Forgotte.ttf","FontSize"=>14));$TextSettings = array("Align"=>TEXT_ALIGN_MIDDLEMIDDLE, "R"=>59, "G"=>59, "B"=>59);$myPicture->drawText(350,25,GRAPHIC_TITLE,$TextSettings);

$myPicture->setShadow(FALSE);$myPicture->setGraphArea(50,50,675,290);$myPicture->setFontProperties(array("R"=>0,"G"=>0,"B"=>0,"FontName"=>PCHART_PATH."fonts/pf_arma_five.ttf","FontSize"=>6));

$Settings = array("Pos"=>SCALE_POS_LEFTRIGHT, "Mode"=>SCALE_MODE_FLOATING, "LabelingMethod"=>LABELING_ALL, "GridR"=>0, "GridG"=>0, "GridB"=>0, "GridAlpha"=>50, "TickR"=>0, "TickG"=>0, "TickB"=>0, "TickAlpha"=>50, "LabelRotation"=>0, "CycleBackground"=>1, "DrawArrows"=>1, "DrawXLines"=>1, "DrawSubTicks"=>1, "SubTickR"=>255, "SubTickG"=>0, "SubTickB"=>0, "SubTickAlpha"=>50, "DrawYLines"=>ALL);$myPicture->drawScale($Settings);

$myPicture->setShadow(TRUE,array("X"=>1,"Y"=>1,"R"=>50,"G"=>50,"B"=>50,"Alpha"=>10));

$Config = "";$myPicture->drawSplineChart($Config);

$Config = array("FontR"=>0, "FontG"=>0, "FontB"=>0, "FontName"=>PCHART_PATH."fonts/pf_arma_five.ttf", "FontSize"=>6, "Margin"=>6, "Alpha"=>30, "BoxSize"=>5, "Style"=>LEGEND_NOBORDER, "Mode"=>LEGEND_HORIZONTAL);$myPicture->drawLegend(646,16,$Config);

$myPicture->stroke();?>

graph_page.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?></head><body><?php include("../menu.php"); ?><div class="container"><h1>Python Graph <small><?php echo( READ ); ?></small></h1><img src="graph_image.php" title="graph image" alt="graph image" border="0" /></div>


</body></html>



graph_page_dynamic.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?><script type='text/javascript' src='../js/jquery.js'></script>

<script type="text/javascript"> var chart; // global /** * Request data from the server, add it to the graph and set a timeout to request again */ function requestData() { $.ajax({ <?php if (isset($_SESSION['OS']) && $_SESSION['OS']=="LINUX"){ ?> url: '../cgi-bin/recibir_linux_json.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>',<?php } ?><?php if (isset($_SESSION['OS']) && $_SESSION['OS']=="WINDOWS"){ ?> url: '../cgi-bin/recibir_windows_json.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>', /*url: 'json_data.php',*/<?php } ?><?php if (!isset($_SESSION['OS'])){ echo ERROR_OSNOT_DETECTED_MESSAGE2;}?> success: function(point) { var series = chart.series[0], shift = series.data.length > 20; // shift if the series is longer than 20 // add the point chart.series[0].addPoint(eval(point[0]), true, shift);

var series = chart.series[1], shift = series.data.length > 20; // shift if the series is longer than 20 // add the point chart.series[1].addPoint(eval(point[1]), true, shift); var series = chart.series[2], shift = series.data.length > 20; // shift if the series is longer than 20 // add the point chart.series[2].addPoint(eval(point[2]), true, shift); // call it again after (1000 = one second) setTimeout(requestData, 1000); }, cache: false }); } $(document).ready(function() { chart = new Highcharts.Chart({ credits: { enabled: false }, chart: { renderTo: 'container', defaultSeriesType: 'spline', events: { load: requestData } }, title: { text: 'Live data from AP' }, xAxis: { type: 'datetime', tickPixelInterval: 150, maxZoom: 20 * 1000 },



yAxis: [{ // Primary yAxis labels: { formatter: function() { return this.value +'°C'; }, style: { color: '#4572A7' } }, minPadding: 0.2, maxPadding: 0.2, title: { text: 'Temperature', style: { color: '#4572A7' } } }, { // Secondary yAxis minPadding: 0.2, maxPadding: 0.2, title: { text: 'Battery', style: { color: '#AA4643' } }, labels: { formatter: function() { return this.value +' V'; }, style: { color: '#AA4643' } }, opposite: true }, { // Tertiary yAxis gridLineWidth: 0, minPadding: 0.2, maxPadding: 0.2, title: { text: 'RSSI', style: { color: '#89A54E' } }, labels: { formatter: function() { return this.value +' %'; }, style: { color: '#89A54E' } }, opposite: true }], tooltip: { formatter: function() { var unit = { 'Battery': 'V', 'Temperature': '°C', 'RSSI': '%' }[this.series.name]; return ''+ '<b>' + this.series.name + ' ' + this.y + ' ' + unit + '</b>' + '<br>@' + Highcharts.dateFormat('%H:%M:%S', this.x) + 'h'; } }, series: [{ name: 'Temperature', data: [] }, { name: 'Battery', color: '#AA4643', yAxis: 1, data: [] }, { name: 'RSSI', color: '#89A54E', yAxis: 2, data: [], dashStyle: 'shortdot' }] });



}); </script></head><body><?php include("../menu.php"); ?><div class="container"><h1>Access Point Graph <small><?php echo( READ ); ?></small></h1><script src="../js/highcharts.js"></script><script src="../js/exporting.js"></script><div id="container" style="min-width: 400px; height: 400px; margin: 0 auto"></div></div>


</body></html>

graphpage_dynamic_AP.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?><?php if ( isset($_SESSION['velocidad']) && $_SESSION['velocidad']!="" && isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!="" && (writable_port($_SESSION['puerto'])==1) ){?><script type='text/javascript' src='../js/jquery.js'></script>

<script type="text/javascript"> var chart; // global /** * Request data from the server, add it to the graph and set a timeout to request again */ function requestData() { $.ajax({ <?php if (isset($_SESSION['OS']) && $_SESSION['OS']=="LINUX"){ ?> url: '../cgi-bin/recibir_linux_json.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&header=A',<?php } ?><?php if (isset($_SESSION['OS']) && $_SESSION['OS']=="WINDOWS"){ ?> url: '../cgi-bin/recibir_windows_json.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&header=A', /*url: 'json_data.php',*/<?php } ?> success: function(point) { var series = chart.series[0], shift = series.data.length > 20; // shift if the series is longer than 20 // add the point chart.series[0].addPoint(eval(point[0]), true, shift);

var series = chart.series[1], shift = series.data.length > 20; // shift if the series is longer than 20 // add the point chart.series[1].addPoint(eval(point[1]), true, shift); var series = chart.series[2], shift = series.data.length > 20; // shift if the series is longer than 20 // add the point chart.series[2].addPoint(eval(point[2]), true, shift); // call it again after (1000 = one second) setTimeout(requestData, 1000); }, cache: false }); } $(document).ready(function() { chart = new Highcharts.Chart({



credits: { enabled: false }, chart: { renderTo: 'container', defaultSeriesType: 'spline', events: { load: requestData } }, title: { text: 'Live data from AP' }, xAxis: { type: 'datetime', tickPixelInterval: 150, maxZoom: 20 * 1000 }, yAxis: [{ // Primary yAxis labels: { formatter: function() { return this.value +'°C'; }, style: { color: '#4572A7' } }, minPadding: 0.2, maxPadding: 0.2, title: { text: 'Temperature', style: { color: '#4572A7' } } }, { // Secondary yAxis minPadding: 0.2, maxPadding: 0.2, title: { text: 'Battery', style: { color: '#AA4643' } }, labels: { formatter: function() { return this.value +' V'; }, style: { color: '#AA4643' } }, opposite: true }, { // Tertiary yAxis gridLineWidth: 0, minPadding: 0.2, maxPadding: 0.2, title: { text: 'RSSI', style: { color: '#89A54E' } }, labels: { formatter: function() { return this.value +' %'; }, style: { color: '#89A54E' } }, opposite: true }], tooltip: { formatter: function() { var unit = { 'Battery': 'V', 'Temperature': '°C', 'RSSI': '%' }[this.series.name]; return ''+ '<b>' + this.series.name + ' ' + this.y + ' ' + unit + '</b>' + '<br>@' + Highcharts.dateFormat('%H:%M:%S', this.x) + 'h';

} }, series: [{ name: 'Temperature', data: [] }, { name: 'Battery', color: '#AA4643', yAxis: 1, data: [] }, { name: 'RSSI', color: '#89A54E', yAxis: 2, data: [], dashStyle: 'shortdot' }] }); });</script><?php } ?></head><body><?php include("../menu.php"); ?><div class="container"><h1><?php echo( READ ); ?> <small><?php echo( GRAPHAP_MSG ); ?></small></h1><?php if ( isset($_SESSION['velocidad']) && $_SESSION['velocidad']!="" && isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!="" && (writable_port($_SESSION['puerto'])==1) ){?><script src="../js/highcharts.js"></script><script src="../js/exporting.js"></script><div id="container" style="min-width: 400px; height: 400px; margin: 0 auto"></div></div><?php} else { ?> <div class="alert alert-block alert-error fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading">ERROR</h4> <p><?php echo ERROR_BEFOREWRITE_MESSAGE; ?></p> <p> <?php if (!isset($_SESSION['OS']) || $_SESSION['OS']=="") { ?> <a class="btn btn-primary" href="../configuracion/osinfo.php"><?php echo( DETECT_OS_MESSAGE );?></a> <?php } elseif (!isset($_SESSION['puerto']) || $_SESSION['puerto']=="") { ?> <a class="btn btn-primary" href="../configuracion/detectar_port.php"><?php echo( DETECT_PORT_MESSAGE );?></a> <?php } elseif (!isset($_SESSION['velocidad']) || $_SESSION['velocidad']=="") { ?> <a class="btn btn-primary" href="../configuracion/configuracio.php"><?php echo( CONFIG_PORT_MESSAGE );?></a> <?php } elseif (writable_port($_SESSION['puerto'])==0) { ?> <?php echo( CHECKNOK_MESSAGE );?> <br><br> <a class="btn btn-info" href="../configuracion/check_port.php"><i class="icon-pencil icon-white"></i> <?php echo( CHECK_MESSAGE );?></a> <?php } ?> </p> </div> <a class="btn" href="javascript:history.back(1)"><i class="icon-chevron-left"></i> <?php echo( GOBACK_MESSAGE );?></a> <a class="btn" href="../"><i class="icon-home"></i> <?php echo( GOHOME_MESSAGE );?></a><?php } ?></div>  <?php include("../javascript.php"); ?>

</body></html>

graphpage_dynamic_ED.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?><?php if ( isset($_SESSION['velocidad']) && $_SESSION['velocidad']!="" && isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!="" && (writable_port($_SESSION['puerto'])==1) ){?><script type='text/javascript' src='../js/jquery.js'></script>



maxPadding: 0.2, title: { text: 'Battery', style: { color: '#AA4643' } }, labels: { formatter: function() { return this.value +' V'; }, style: { color: '#AA4643' } }, opposite: true }, { // Tertiary yAxis gridLineWidth: 0, minPadding: 0.2, maxPadding: 0.2, title: { text: 'RSSI', style: { color: '#89A54E' } }, labels: { formatter: function() { return this.value +' %'; }, style: { color: '#89A54E' } }, opposite: true }], tooltip: { formatter: function() { var unit = { 'Battery': 'V', 'Temperature': '°C', 'RSSI': '%' }[this.series.name]; return ''+ '<b>' + this.series.name + ' ' + this.y + ' ' + unit + '</b>' + '<br>@' + Highcharts.dateFormat('%H:%M:%S', this.x) + 'h'; } }, series: [{ name: 'Temperature', data: [] }, { name: 'Battery', color: '#AA4643', yAxis: 1, data: [] }, { name: 'RSSI', color: '#89A54E', yAxis: 2, data: [], dashStyle: 'shortdot' }] }); });</script><?php } ?></head><body><?php include("../menu.php"); ?><div class="container"><h1><?php echo( READ ); ?> <small><?php echo( GRAPHED_MSG ); ?></small></h1><?php if ( isset($_SESSION['velocidad']) && $_SESSION['velocidad']!="" && isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!="" && (writable_port($_SESSION['puerto'])==1) ){?><script src="../js/highcharts.js"></script><script src="../js/exporting.js"></script><div id="container" style="min-width: 400px; height: 400px; margin: 0 auto"></div></div><?php} else { ?> <div class="alert alert-block alert-error fade in">

<button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading">ERROR</h4> <p><?php echo ERROR_BEFOREWRITE_MESSAGE; ?></p> <p> <?php if (!isset($_SESSION['OS']) || $_SESSION['OS']=="") { ?> <a class="btn btn-primary" href="../configuracion/osinfo.php"><?php echo( DETECT_OS_MESSAGE );?></a> <?php } elseif (!isset($_SESSION['puerto']) || $_SESSION['puerto']=="") { ?> <a class="btn btn-primary" href="../configuracion/detectar_port.php"><?php echo( DETECT_PORT_MESSAGE );?></a> <?php } elseif (!isset($_SESSION['velocidad']) || $_SESSION['velocidad']=="") { ?> <a class="btn btn-primary" href="../configuracion/configuracio.php"><?php echo( CONFIG_PORT_MESSAGE );?></a> <?php } elseif (writable_port($_SESSION['puerto'])==0) { ?> <?php echo( CHECKNOK_MESSAGE );?> <br><br> <a class="btn btn-info" href="../configuracion/check_port.php"><i class="icon-pencil icon-white"></i> <?php echo( CHECK_MESSAGE );?></a> <?php } ?> </p> </div> <a class="btn" href="javascript:history.back(1)"><i class="icon-chevron-left"></i> <?php echo( GOBACK_MESSAGE );?></a> <a class="btn" href="../"><i class="icon-home"></i> <?php echo( GOHOME_MESSAGE );?></a><?php } ?></div>  <?php include("../javascript.php"); ?>

</body></html>

index.php

<?phpif (!isset($_SESSION)) { session_start();}include("init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?><script>function config_ajax(query){ var xmlhttp; if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmlhttp=new XMLHttpRequest(); } else {// code for IE6, IE5 xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); } xmlhttp.onreadystatechange=function() { if (xmlhttp.readyState==4 && xmlhttp.status==200) { document.getElementById("myConfig").innerHTML=xmlhttp.responseText; } } xmlhttp.open("GET","configuracion/config_ajax.php?q="+query,true); xmlhttp.send();}function check_port(query){ var xmlhttp; if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmlhttp=new XMLHttpRequest(); } else {// code for IE6, IE5 xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); } xmlhttp.onreadystatechange=function() { if (xmlhttp.readyState==4 && xmlhttp.status==200) { document.getElementById("infoCheckPort").innerHTML=xmlhttp.responseText; } } xmlhttp.open("GET","configuracion/check_port_ajax.php?q="+query,true); xmlhttp.send();}</script>

</head> <body> <?php include("menu.php"); ?> <div class="container"> <div class="row-fluid">  <div class="hero-unit"> <div class="row"> <div class="span6"> <h1><?php echo( WELCOME_MESSAGE ); ?></h1> <p><?php echo( INTRO_MESSAGE ); ?></p> <div id="myConfig"><?phpif ( !isset($_SESSION['OS']) ){ ?> <h2><?php echo( INFOOS_QUESTION ); ?></h2><p><a class="btn btn-primary btn-large" href="javascript:config_ajax('os');" title="<?php echo DETECT_OS_MESSAGE;?>"><?php echo( DETECT_OS_MESSAGE );?> »</a></p><?php} else {?> <h2><?php echo( CONFIGURACION_MESSAGE ); ?>:</h2><p> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['OS']; ?></a><?phpif ( isset($_SESSION['puerto']) && isset($_SESSION['OS']) ){ ?> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['puerto']; ?></a><?php} elseif ( isset($_SESSION['OS']) ) { ?> <a class="btn btn-primary btn-large" href="javascript:config_ajax('port');" title="<?php echo "Auto ".strtolower( DETECT_PORT_MESSAGE );?>"><?php echo "Auto ".strtolower( DETECT_PORT_MESSAGE );?> »</a><?php } ?><?php if ( isset($_SESSION['velocidad']) && isset($_SESSION['puerto']) && isset($_SESSION['OS']) && isset($_SESSION['databit']) && isset($_SESSION['paridad']) && isset($_SESSION['stopbit']) && isset($_SESSION['control']) ){ ?> <a class="btn btn-large btn-primary disabled" href="#"><?php echo $_SESSION['velocidad'] . " " . $_SESSION['databit'] . " " . $_SESSION['paridad'] . " " . $_SESSION['stopbit'] . " " . $_SESSION['control']; ?></a><?php} elseif ( isset($_SESSION['puerto']) && isset($_SESSION['OS']) ) { ?> <a class="btn btn-primary btn-large" href="javascript:config_ajax('velocidad');" title="<?php echo "Auto ".strtolower( CONFIG_PORT_MESSAGE );?>"><?php echo "Auto ".strtolower( CONFIG_PORT_MESSAGE );?> »</a><?php }}?><?phpif ( isset($_SESSION['OS']) && (isset($_SESSION['puerto']) && isset($_SESSION['velocidad'])) ){ ?> <a class="btn btn-info btn-large" href="javascript:check_port2('<?php echo $_SESSION['puerto']; ?>');" title="<?php echo CHECK_PORT_MESSAGE;?>"><i class="icon-pencil icon-white"></i> <?php echo( CHECK_MESSAGE );?></a><?php}?><?phpif ( isset($_SESSION['OS']) ){ ?> </p> <p> <a class="btn" href="configuracion/configuracio.php" title="<?php echo ( MANUAL_MESSAGE );?>"><?php echo ( MANUAL_MESSAGE );?></a> <a class="btn btn-danger" href="configuracion/quita.php" title="<?php echo DELETE_MESSAGE . " " . strtolower(CONFIGURACION_MESSAGE); ?>"><i class="icon-trash icon-white"></i> <?php echo DELETE_MESSAGE;?></a> </p><?php}?> </div> <div id="infoCheckPort"> </div> </div>  <div class="span6"><?php// get contents of a image file (SVG) into a string$filename = "imagen/portada_web.svg";$handle = fopen($filename, "r");

// eliminar 114 bytes inicialesfseek($handle, 114);

$contents = fread($handle, filesize($filename));fclose($handle);echo $contents;?> </div>  </div>  </div>  </div>  </div>



<?php include("javascript.php"); ?><script type="text/javascript" charset="utf-8">function check_port2(query){ $.ajaxSetup ({ cache: false });

var jsonUrl = "cgi-bin/check_port_<?php echo strtolower(giveme_os()); ?>.py?port="+query; $.getJSON( jsonUrl, function(json) { if (json==1) { var result = '<div class="alert alert-success"><a class="close" data-dismiss="alert" href="#">×</a><strong><?php echo OK_MESSAGE; ?></strong> <?php echo CHECKOK_MESSAGE; ?></div>'; } else { var result = '<div class="alert alert-error"><a class="close" data-dismiss="alert" href="#">×</a><?php echo CHECKNOK_MESSAGE; ?> <a class="btn btn-mini" href="configuracion/check_port.php"><?php echo INFORMATION_MESSAGE; ?></a></div>'; } $("#infoCheckPort").html(result); } );}</script> </body></html>

init.php

<?php

define('ENABLE_LOCAL_WEB',1); // 0=online 1=local/* * Esto se debe a que en local uso: 127.0.0.1/proyectoweb y en online proyectoweb.com entonces en online "subo" 0 directorios y en local 1.*/

// language code// NOTA: para los idiomas también mirar el languages.php$valid_langs = array('en','es','ca');if (!empty($_GET['lang'])){ // primarily look for the lang parameter $lang = $_GET['lang'];}elseif (!empty($_SESSION['lang'])){ // if not look for the session lang $lang = $_SESSION['lang'];}// check if $lang is set and validif (isset($lang) && in_array($lang, $valid_langs)){ include __path(ENABLE_LOCAL_WEB).'lang/' . $lang . '/index.php';

// set session lang for later $_SESSION['lang'] = $lang;}else{ // else use default: ES $lang="es"; include __path(ENABLE_LOCAL_WEB).'lang/' . $lang . '/index.php'; $_SESSION['lang'] = $lang;}?><?php //enlace dinámico function __path($localdir = 0) { //el valor inicial de $rp era: $rp='./' pero esto generaba un warning en la validacion del HTML5 $rp = ''; $s = explode(basename($_SERVER['PHP_SELF']), $_SERVER['PHP_SELF'], 2); $n = trim($s[0], '/') ? count(explode('/', trim($s[0], '/'))) - $localdir : 0; for ($i = 0; $i < $n; $i++) $rp .= '../'; return $rp; } //funcion para el enlace de los idiomas function enlaceidioma($idiomas,$idiomadestino,$entorno) { //ENTORNO: 0=internet 1=local $array1 = $idiomas;

$array2 = array($idiomadestino); $result = array_diff($array1, $array2); $final=""; $encontrado=0; foreach ($result as $value) { $pos = strpos($_SERVER['REQUEST_URI'],"/".$value."/"); if($pos === false) { // no encontrado, mirar entorno if ($entorno) { //local //$final = str_replace("qrcode","qrcode/".$idiomadestino,$_SERVER['REQUEST_URI']); $pos2 = strpos(substr($_SERVER['REQUEST_URI'],1),"/")+1; $final = substr($_SERVER['REQUEST_URI'],0,$pos2+1) . $idiomadestino . substr($_SERVER['REQUEST_URI'],$pos2); } else { //internet $final = "/".$idiomadestino.$_SERVER['REQUEST_URI']; } } else { // encontrado $valor=$value; $encontrado=1; } } $pos = strpos($_SERVER['REQUEST_URI'],"/".$idiomadestino."/"); if($pos === false) { // no encontrado } else { // encontrado $final = ""; $encontrado=0; } if ($encontrado) { $final = str_replace("/".$valor."/","/".$idiomadestino."/",$_SERVER['REQUEST_URI']); } return $final; }?><?phpfunction writeheader($description, $keywords) {?><!DOCTYPE HTML><html lang="<?php echo $_SESSION['lang']; ?>"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title><?php echo title(); ?> - UPC</title> <meta name="author" content="Fran Quinto" > <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta name="description" content="<?=$description?>" /> <meta name="keywords" content="<?=$keywords?>" /> <meta name="geo.region" content="ES-CT" /> <meta name="geo.placename" content="UPC, Barcelona" /> <meta name="geo.position" content="41.388714;2.111907" /> <meta name="ICBM" content="41.388714, 2.111907" />

 <link rel="stylesheet" href="<?php echo __path(ENABLE_LOCAL_WEB); ?>css/bootstrap.css"> <link href="<?php echo __path(ENABLE_LOCAL_WEB); ?>css/bootstrap-responsive.css" rel="stylesheet">

 

 <link rel="shortcut icon" href="<?php echo __path(ENABLE_LOCAL_WEB); ?>imagen/favicon.ico" type="image/x-icon"> <link rel="apple-touch-icon-precomposed" sizes="144x144" href="<?php echo __path(ENABLE_LOCAL_WEB); ?>imagen/apple-touch-icon-144-precomposed.png"> <link rel="apple-touch-icon-precomposed" sizes="114x114" href="<?php echo __path(ENABLE_LOCAL_WEB); ?>imagen/apple-touch-icon-114-precomposed.png"> <link rel="apple-touch-icon-precomposed" sizes="72x72" href="<?php echo __path(ENABLE_LOCAL_WEB); ?>imagen/apple-touch-icon-72-precomposed.png"> <link rel="apple-touch-icon-precomposed" href="<?php echo __path(ENABLE_LOCAL_WEB); ?>imagen/apple-touch-icon-57-precomposed.png"><?php} // end writeheader?><?php

function title() { $x = (explode('/', $_SERVER['PHP_SELF']));



array_pop ($x); $estado_menu = array_pop ($x); switch ($estado_menu) { case 'configuracion': $titulo = CONFIGURACION_MESSAGE; ; break; case 'comunicacion': $titulo = COMUNICACION_MESSAGE; ; break; case 'monitorizacion': $titulo = MONITORIZATION_MESSAGE; ; break; case 'info': $titulo = 'Info'; ; break; case 'about': $titulo = ABOUT_MESSAGE; ; break; case 'contact': $titulo = CONTACT_MESSAGE; ; break; case 'cgi-bin': $titulo = 'cgi-bin'; ; break; default: $titulo = 'Home'; ; break; } return $titulo;}

function giveme_os() { $OS = "UNKNOW_OS"; if (strtoupper(substr(PHP_OS, 0, 3)) === "WIN") { $OS="WINDOWS"; } if (strtoupper(substr(PHP_OS, 0, 3)) === "LIN") { $OS="LINUX"; } return $OS;}

function giveme_port($OS) { $port = "UNKNOW_PORT"; if ($OS=="LINUX") { //prog. per Linux $texto = exec("dmesg | grep tty"); //$texto = "[ 1.215306] 00:09: ttyS0 at I/O 0x3f8 (irq = 4) is a 16550A"; // FOR DEBUG //$texto = "[10619.182208] usb 2-1.3: FTDI USB Serial Device converter now attached to ttyUSB0"; // FOR DEBUG $h1count = preg_match_all('/ (tty(S|USB|ACM)[0-9])/',$texto,$patterns); //echo $texto . "<br><br>"; // FOR DEBUG //var_dump($patterns); // FOR DEBUG //echo "<br><br>[1][0]=###".$patterns[1][0] . "###<br><br>"; // FOR DEBUG if(isset($patterns[1][0])){ $port = "/dev/".$patterns[1][0]; } else { $port = "ERROR"; } } if ($OS=="WINDOWS") { //prog. per Windows $osys = strtolower($OS); $jsonurl = url_completa('../cgi-bin/givemeports_'.$osys.'.py?id=1'); $json = file_get_contents($jsonurl,0,null,null); $json_output = json_decode($json,true); if ($json_output != "") { $port = $json_output[0]['optionValue']; // el primero del array if ($port == "") { $port = "COM1"; } } else { $port = "COM1"; } } if ($OS=="UNKNOW_OS") { $port = $OS; // $port = UNKNOW_OS



}return $port;}

function writable_port($port) { // return 1 when writable, return 0 when error or not writable $devuelve = 0; $os = strtolower(giveme_os()); $jsonurl = url_completa('../cgi-bin/check_port_'.$os.'.py?port='.$port); //$PATH=http://127.0.0.1/serie/cgi-bin/check_port_linux.py $json = file_get_contents($jsonurl,0,null,null); $json_output = json_decode($json); $devuelve = $json_output[0]; return $devuelve;}

function check_if_exist_port($port) { // return 1 when exits, return 0 when no exists serial port // solo para WINDOWS!! $devuelve = 0; $os = strtolower(giveme_os()); $jsonurl = url_completa('../cgi-bin/portsnobusy_'.$os.'.py?id=1'); $json = file_get_contents($jsonurl,0,null,null); $json_output = json_decode($json,true); foreach($json_output as $puertos) { if ( $puertos['optionValue'] == $port) { $devuelve=1; } } return $devuelve;}

/** Function strallpos* Returns all positions of the search term in the* string as an array*/function strallpos($haystack,$needle,$offset = 0) { $result = array(); // Loop through the $haystack/string starting at offset for($i = $offset; $i<strlen($haystack); $i++){ $pos = strpos($haystack,$needle,$i); if($pos !== FALSE){ $offset = $pos; if($offset >= $i){ $i = $offset; // Add found results to return array $result[] = $offset; } } } return count($result);}

/* * Function url_completa * Return all complete URL link, like: http://127.0.0.1/serie/cgi-bin/lectura_graph.py * If you use ../ you can move inside path and this functions returns correct position */function url_completa ($rel_path) { $abs_path = substr($_SERVER['PHP_SELF'],0,strrpos($_SERVER['PHP_SELF'],"/")); //if(substr($abs_path,-1) != '/') $abs_path .= '/'; //siempre acabará con barra / $searching = "../"; //num. veces que hemos encontrado '../' en $rel_path $veces = strallpos($rel_path,$searching); $rel_path=substr($rel_path,($veces*strlen($searching))); for ($i = 0; $i < $veces; $i++) { $abs_path = substr($abs_path,0,strrpos($abs_path,"/")); } return 'http://'.$_SERVER['HTTP_HOST'].$abs_path.'/'.$rel_path;}?>

javascript.php

<?phpif (!isset($_SESSION)) { session_start();}?>   <script src="<?php echo __path(ENABLE_LOCAL_WEB); ?>js/jquery.js"></script> <script src="<?php echo __path(ENABLE_LOCAL_WEB); ?>js/bootstrap.min.js"></script> <script src="<?php echo __path(ENABLE_LOCAL_WEB); ?>js/application.js"></script>

languages.php

<?php// NOTA: para los idiomas también mirar el init.php$valid_langs = array('en','es','ca');?> <ul class="nav pull-right"> <li class="divider-vertical .pull-right"></li> <li><a href="<?php echo enlaceidioma($valid_langs,'en',ENABLE_LOCAL_WEB);?>"><img src="<?php echo __path(ENABLE_LOCAL_WEB); ?>imagen/flags/en.png" title="English" alt="English" /> English </a></li> <li><a href="<?php echo enlaceidioma($valid_langs,'es',ENABLE_LOCAL_WEB);?>"><img src="<?php echo __path(ENABLE_LOCAL_WEB); ?>imagen/flags/es.png" title="Español" alt="Español" /> Español </a></li> <li><a href="<?php echo enlaceidioma($valid_langs,'ca',ENABLE_LOCAL_WEB);?>"><img src="<?php echo __path(ENABLE_LOCAL_WEB); ?>imagen/flags/catalonia.png" title="Català" alt="Català" /> Català </a></li> </ul>

led_mouse.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?><script type="text/javascript">function led(header,address,data){if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmlhttp=new XMLHttpRequest(); }else {// code for IE6, IE5 xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); }<?php if (isset($_SESSION['OS']) && $_SESSION['OS']!=""){ if ( $_SESSION['OS']=="LINUX" ) {?>xmlhttp.open("GET","../cgi-bin/enviar_linux.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&destino_msg="+header+"&rw=W&address="+address+"&data="+data+"&lang=<?php echo (isset($_SESSION['lang'])) ? $_SESSION['lang'] : 'es'; ?>",true);<?php }?><?php if ( $_SESSION['OS']=="WINDOWS" ) {?>xmlhttp.open("GET","../cgi-bin/enviar_windows.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&destino_msg="+header+"&rw=W&address="+address+"&data="+data+"&lang=<?php echo (isset($_SESSION['lang'])) ? $_SESSION['lang'] : 'es'; ?>",true);<?php }}?>

xmlhttp.send();}</script></head><body><?php include("../menu.php"); ?><div class="container"> <h1><?php echo( READWRITE_MESSAGE ); ?> <small>AJAX <?php echo IMAGECONTROL_MSG; ?></small></h1><?php if ( isset($_SESSION['velocidad']) && $_SESSION['velocidad']!="" && isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!="" && (writable_port($_SESSION['puerto'])==1) ){ ?> <div class="span7"> <h2>Control <small><?php echo INFOOS_MESSAGE; ?>:<strong> <?php echo $_SESSION['OS'];?></strong> · <?php echo PORT_SELECTED_MESSAGE; ?> <strong><?php echo $_SESSION['puerto'];?></strong></small></h2> <br><br> <img src="../imagen/led.png" alt="led image" width="400" height="200" border="0" usemap="#led"> <map name="led"> <area shape="circle" alt="AP LED1 ON" href="#" coords="50,50,50" onmouseover="led('AP','11','000')"/> <area shape="circle" alt="AP LED2 ON" href="#" coords="150,50,50" onmouseover="led('AP','10','000')"/> <area shape="circle" alt="ED LED1 ON" href="#" coords="250,50,50" onmouseover="led('ED','11','000')"/> <area shape="circle" alt="ED LED2 ON" href="#" coords="350,50,50" onmouseover="led('ED','10','000')"/> <area shape="circle" alt="AP LED1 OFF" href="#" coords="50,150,50" onmouseover="led('AP','11','001')"/> <area shape="circle" alt="AP LED2 OFF" href="#" coords="150,150,50" onmouseover="led('AP','10','001')"/> <area shape="circle" alt="ED LED1 OFF" href="#" coords="250,150,50" onmouseover="led('ED','11','001')"/> <area shape="circle" alt="ED LED2 OFF" href="#" coords="350,150,50" onmouseover="led('ED','10','001')"/> </map> </div><?php} else { ?> <div class="alert alert-block alert-error fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading">ERROR</h4> <p><?php echo ERROR_BEFOREWRITE_MESSAGE; ?></p> <p> <?php if (!isset($_SESSION['OS']) || $_SESSION['OS']=="") { ?> <a class="btn btn-primary" href="../configuracion/osinfo.php"><?php echo( DETECT_OS_MESSAGE );?></a> <?php } elseif (!isset($_SESSION['puerto']) || $_SESSION['puerto']=="") { ?> <a class="btn btn-primary" href="../configuracion/detectar_port.php"><?php echo( DETECT_PORT_MESSAGE );?></a> <?php } elseif (!isset($_SESSION['velocidad']) || $_SESSION['velocidad']=="") { ?> <a class="btn btn-primary" href="../configuracion/configuracio.php"><?php echo( CONFIG_PORT_MESSAGE );?></a> <?php } elseif (writable_port($_SESSION['puerto'])==0) { ?> <?php echo( CHECKNOK_MESSAGE );?> <br><br> <a class="btn btn-info" href="../configuracion/check_port.php"><i class="icon-pencil icon-white"></i> <?php echo( CHECK_MESSAGE );?></a> <?php } ?> </p> </div> <a class="btn" href="javascript:history.back(1)"><i class="icon-chevron-left"></i> <?php echo( GOBACK_MESSAGE );?></a> <a class="btn" href="../"><i class="icon-home"></i> <?php echo( GOHOME_MESSAGE );?></a><?php } ?></div> 


</body></html>

menu.php

<?phpif (!isset($_SESSION)) { session_start();}require_once("init.php");?><?php //para indicar con CSS dónde estamos $x = (explode('/', $_SERVER['PHP_SELF'])); array_pop ($x); $estado_menu = array_pop ($x); if (($estado_menu!="configuracion") && ($estado_menu!="comunicacion") && ($estado_menu!="monitorizacion") && ($estado_menu!="info") && ($estado_menu!="cgi-bin") && ($estado_menu!="about") && ($estado_menu!="contact") ) { $estado_menu="home"; }?> <style type="text/css"> body { padding-top: 60px; /* 60px to make the container go all the way to the bottom of the topbar */ }

</style> <div class="navbar navbar-fixed-top"> <div class="navbar-inner"> <div class="container">

 <a class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse"> <span class="icon-bar"></span> <span class="icon-bar"></span> <span class="icon-bar"></span> </a>

 <a class="brand" href="<?php echo ($estado_menu=="home")? '.' : '../'; ?>">WSN</a>

 <div class="nav-collapse"> <ul class="nav">

<li<?php echo ($estado_menu=="home")? ' class="active"' : ''; ?>><a href="<?php echo ($estado_menu=="home")? '.' : '../'; ?>"><?php echo( HOME_MESSAGE ); ?></a></li>

<li class="dropdown<?php echo ($estado_menu=="configuracion")? ' active' : ''; ?>" id="menu1"> <a class="dropdown-toggle" data-toggle="dropdown" href="#menu1"> <?php echo( CONFIGURACION_MESSAGE ); ?> <b class="caret"></b> </a> <ul class="dropdown-menu"> <li class="nav-header"><?php echo( MANUAL_MESSAGE ); ?></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>configuracion/osinfo.php"><?php echo( DETECT_OS_MESSAGE ); ?></a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>configuracion/detectar_port.php"><?php echo( DETECT_PORT_MESSAGE ); ?></a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>configuracion/configuracio.php"><?php echo( CONFIGURACION_MESSAGE ); ?></a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>configuracion/check_port.php"><?php echo( CHECK_PORT_MESSAGE ); ?></a></li> <li class="divider"></li> <li class="nav-header"><?php echo( AUTO_MESSAGE ); ?></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>configuracion/detectar_tot.php"><?php echo( AUTODETECALL_MESSAGE ); ?></a></li> </ul> </li>

<li class="dropdown<?php echo ($estado_menu=="comunicacion")? ' active' : ''; ?>" id="menu2"> <a class="dropdown-toggle" data-toggle="dropdown" href="#menu2"> <?php echo( COMUNICACION_MESSAGE ); ?> <b class="caret"></b> </a> <ul class="dropdown-menu"> <li class="nav-header"><?php echo( READWRITE_MESSAGE ); ?></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>comunicacion/setup_AP.php"><?php echo CONFIGURACION_MESSAGE; ?> AP</a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>comunicacion/python_ajax.php">AJAX Python</a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>comunicacion/led_mouse.php">AJAX <?php echo IMAGECONTROL_MSG; ?></a></li> </ul> </li>

<li class="dropdown<?php echo ($estado_menu=="monitorizacion")? ' active' : ''; ?>" id="menu3"> <a class="dropdown-toggle" data-toggle="dropdown" href="#menu3"> <?php echo( MONITORIZATION_MESSAGE ); ?> <b class="caret"></b> </a> <ul class="dropdown-menu"> <li class="nav-header"><?php echo( READ ); ?></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>monitorizacion/graphpage_dynamic_AP.php"><?php echo( GRAPHAP_MSG ); ?></a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>monitorizacion/graphpage_dynamic_ED.php"><?php echo( GRAPHED_MSG ); ?></a></li> </ul> </li>

<li class="dropdown<?php echo ($estado_menu=="info")? ' active' : ''; ?>" id="menu4"> <a class="dropdown-toggle" data-toggle="dropdown" href="#menu4"> <?php echo( INFORMATION_MESSAGE ); ?> <b class="caret"></b> </a> <ul class="dropdown-menu"> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>info/system.php"><?php echo( INFOOSALL_MESSAGE ); ?></a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>info/osinfo.php"><?php echo( INFOOS_MESSAGE ); ?></a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>info/apacheinfo.php"><?php echo( WEBSERVER_MSG ); ?></a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>info/mysqlinfo.php"><?php echo( MYSQLSERVER_MSG ); ?></a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>info/phpinfo_server.php"><?php echo( PHPSERVER_MSG ); ?

></a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>info/phpinfo.php">PHP ALL info</a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>cgi-bin/test_cgi_python.php">Python test CGI</a></li> <li><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>cgi-bin/version.php">Python <?php echo VERSION_MESSAGE; ?></a></li> </ul> </li>

<li<?php echo ($estado_menu=="about")? ' class="active"' : ''; ?>><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>about/"><?php echo( ABOUT_MESSAGE ); ?></a></li>

<li<?php echo ($estado_menu=="contact")? ' class="active"' : ''; ?>><a href="<?php echo __path(ENABLE_LOCAL_WEB); ?>contact/"><?php echo( CONTACT_MESSAGE ); ?></a></li>

</ul> <?php include(__path(ENABLE_LOCAL_WEB)."languages.php"); ?> </div> </div> </div> </div>

python_ajax.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?><script> function foco(){ document.enviar.data.focus() document.enviar.data.select() lectura_serie() }

function getValueFromName(name){ var radioButtons = document.getElementsByName(name); for (var x = 0; x < radioButtons.length; x ++) { if (radioButtons[x].checked) { return radioButtons[x].value; } }}

function lectura_serie(veces){if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmllectura=new XMLHttpRequest(); }else {// code for IE6, IE5 xmllectura=new ActiveXObject("Microsoft.XMLHTTP"); }xmllectura.onreadystatechange=function() { document.getElementById("lectura_ajax").innerHTML=xmllectura.responseText; }

<?php if (isset($_SESSION['OS']) && $_SESSION['OS']!=""){ if ( $_SESSION['OS']=="LINUX" ) {?>xmllectura.open("GET","../cgi-bin/recibir_linux.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&veces="+veces+"&lang=<?php echo (isset($_SESSION['lang'])) ? $_SESSION['lang'] : 'es'; ?>",true);<?php }?><?php if ( $_SESSION['OS']=="WINDOWS" ) {?>xmllectura.open("GET","../cgi-bin/recibir_windows.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php



echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&veces="+veces+"&lang=<?php echo (isset($_SESSION['lang'])) ? $_SESSION['lang'] : 'es'; ?>",true);<?php }}?>xmllectura.send();}

function sleep(millisegundos) { var inicio = new Date().getTime(); while ((new Date().getTime() - inicio) < millisegundos){}}

function escritura_serie(rw,address,data){limpia_serie();if (data.length==0) { limpia_serie(); return; }if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmlhttp=new XMLHttpRequest(); }else {// code for IE6, IE5 xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); }xmlhttp.onreadystatechange=function() { if (xmlhttp.readyState==4 && xmlhttp.status==200) { document.getElementById("escritura_ajax").innerHTML=xmlhttp.responseText; } }<?php if (isset($_SESSION['OS']) && $_SESSION['OS']!=""){ if ( $_SESSION['OS']=="LINUX" ) {?>xmlhttp.open("GET","../cgi-bin/com_linux.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&destino_msg="+getValueFromName("destino_msg")+"&rw="+rw+"&address="+address+"&data="+data+"&lang=<?php echo (isset($_SESSION['lang'])) ? $_SESSION['lang'] : 'es'; ?>",true);<?php }?><?php if ( $_SESSION['OS']=="WINDOWS" ) {?>xmlhttp.open("GET","../cgi-bin/com_windows.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&destino_msg="+getValueFromName("destino_msg")+"&rw="+rw+"&address="+address+"&data="+data+"&lang=<?php echo (isset($_SESSION['lang'])) ? $_SESSION['lang'] : 'es'; ?>",true);<?php }}?>xmlhttp.send();document.enviar.data.value="";document.enviar.data.focus();

}

function limpia_serie(){ document.getElementById("escritura_ajax").innerHTML=""; document.getElementById("lectura_ajax").innerHTML="";}</script></head><body><?php include("../menu.php"); ?><div class="container"> <h1><?php echo( READWRITE_MESSAGE ); ?> <small>AJAX Python</small></h1><?php if ( isset($_SESSION['velocidad']) && $_SESSION['velocidad']!="" && isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!="" && (writable_port($_SESSION['puerto'])==1) ){ ?> <div class="row"> <div class="span7"> <h2>Control <small><?php echo INFOOS_MESSAGE; ?>:<strong> <?php echo $_SESSION['OS'];?></strong> · <?php echo PORT_SELECTED_MESSAGE; ?> <strong><?php echo $_SESSION['puerto'];?></strong></small></h2>

<form id="enviar" name="enviar" method="post" action="" class="form-horizontal">



<fielset> <div class="form-actions"><h3><?php echo READ;?></h3> <?php echo TIMESREPEATER; ?> <input name="veces" type="text" id="veces" size="10" maxlength="15" class="span1" value="<?php echo ENDLESS; ?>" /> <button type="button" class="btn btn-small" onclick="lectura_serie(document.enviar.veces.value)"> <i class="icon-play"></i> Play </button>

<button type="button" class="btn btn-small" onclick="limpia_serie()"> <i class="icon-refresh"></i> <?php echo CLEAN; ?> </button> </div>

<div class="control-group"><h3><?php echo WRITE;?></h3>

<label class="control-label"><?php echo TARGET_MESSAGE . ":"; ?></label> <div class="controls"> <label class="radio inline"> <input id="optionsRadiosAP" type="radio" <?php echo (isset($_SESSION['destino_msg']) && $_SESSION['destino_msg']=="AP") ? 'checked=""' : ''; ?> value="AP" name="destino_msg"> AP </label> <label class="radio inline"> <input id="optionsRadiosED" type="radio" <?php echo (isset($_SESSION['destino_msg']) && $_SESSION['destino_msg']=="ED") ? 'checked=""' : ''; ?> value="ED" name="destino_msg"> ED </label> <label class="radio inline"> <input id="optionsRadiosFG" type="radio" <?php echo (isset($_SESSION['destino_msg']) && $_SESSION['destino_msg']=="FG") ? 'checked=""' : ''; ?> value="FG" name="destino_msg"> FPGA </label> </div><br> <label class="control-label"><?php echo READWRITE_MESSAGE . ":"; ?></label> <div class="controls"> <label class="radio inline"> <input id="optionsRadiosREAD" type="radio" checked="" value="R" name="readwrite_msg"> <?php echo READ;?> </label> <label class="radio inline"> <input id="optionsRadiosWRITE" type="radio" value="W" name="readwrite_msg"> <?php echo WRITE;?> </label> </div><br> <label class="control-label"><?php echo ADDRESS_MESSAGE . ":"; ?></label> <div class="controls"> <input name="address" type="text" id="address" size="3" maxlength="2" class="span1" /> <?php echo GRAPHIC_DATA . ":"; ?> <input name="data" type="text" id="data" size="4" maxlength="3" class="span1" /><br><br> <button type="button" class="btn btn-small" onclick="escritura_serie(getValueFromName('readwrite_msg'),document.enviar.address.value,document.enviar.data.value)"> <i class="icon-chevron-right"></i> <?php echo substr(SEND_BUTTON_MESSAGE, 0, -6); ?> </button> </div> <br> <label class="control-label"><?php echo CONTROLS_MESSAGE . ":"; ?></label> <div class="controls"> <button type="button" class="btn btn-small" onclick="escritura_serie('R','50','000')"> <i class="icon-info-sign"></i> Temp </button> <button type="button" class="btn btn-small" onclick="escritura_serie('R','51','000')"> <i class="icon-info-sign"></i> RSSI </button> <button type="button" class="btn btn-small" onclick="escritura_serie('R','52','000')"> <i class="icon-info-sign"></i> Volt </button> <button type="button" class="btn btn-small btn-success" onclick="escritura_serie('W','11','000')"> <i class="icon-asterisk icon-white"></i> led1_on </button> <button type="button" class="btn btn-small" onclick="escritura_serie('W','11','001')"> <i class="icon-asterisk"></i> led1_off </button> <button type="button" class="btn btn-small btn-danger" onclick="escritura_serie('W','10','000')"> <i class="icon-asterisk icon-white"></i> led2_on </button> <button type="button" class="btn btn-small" onclick="escritura_serie('W','10','001')"> <i class="icon-asterisk"></i> led2_off </button> </div>

</div>

</fielset> </form> </div> <div class="span5"> <h2><?php echo CONSOLE_MESSAGE; ?></h2> <br> <span id="escritura_ajax"></span> <span id="lectura_ajax"></span> </div> </div><?php} else { ?> <div class="alert alert-block alert-error fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading">ERROR</h4> <p><?php echo ERROR_BEFOREWRITE_MESSAGE; ?></p> <p> <?php if (!isset($_SESSION['OS']) || $_SESSION['OS']=="") { ?> <a class="btn btn-primary" href="../configuracion/osinfo.php"><?php echo( DETECT_OS_MESSAGE );?></a> <?php } elseif (!isset($_SESSION['puerto']) || $_SESSION['puerto']=="") { ?> <a class="btn btn-primary" href="../configuracion/detectar_port.php"><?php echo( DETECT_PORT_MESSAGE );?></a> <?php } elseif (!isset($_SESSION['velocidad']) || $_SESSION['velocidad']=="") { ?> <a class="btn btn-primary" href="../configuracion/configuracio.php"><?php echo( CONFIG_PORT_MESSAGE );?></a> <?php } elseif (writable_port($_SESSION['puerto'])==0) { ?> <?php echo( CHECKNOK_MESSAGE );?> <br><br> <a class="btn btn-info" href="../configuracion/check_port.php"><i class="icon-pencil icon-white"></i> <?php echo( CHECK_MESSAGE );?></a> <?php } ?> </p> </div> <a class="btn" href="javascript:history.back(1)"><i class="icon-chevron-left"></i> <?php echo( GOBACK_MESSAGE );?></a> <a class="btn" href="../"><i class="icon-home"></i> <?php echo( GOHOME_MESSAGE );?></a><?php } ?></div> 


</body></html>

python_read.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?><script>function lectura_serie(){ if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmllectura=new XMLHttpRequest(); } else {// code for IE6, IE5 xmllectura=new ActiveXObject("Microsoft.XMLHTTP"); } xmllectura.onreadystatechange=function() { document.getElementById("lectura_ajax").innerHTML=xmllectura.responseText; }

<?php if (isset($_SESSION['OS']) && $_SESSION['OS']!=""){ if ( $_SESSION['OS']=="LINUX" ) {?> xmllectura.open("GET","../cgi-bin/recibir_linux.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&veces="+document.enviar.veces.value,true);<?php }?><?php if ( $_SESSION['OS']=="WINDOWS" ) {?>



xmllectura.open("GET","../cgi-bin/recibir_windows.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&veces="+document.enviar.veces.value,true);<?php }}?> xmllectura.send();}function limpia_serie(){ document.getElementById("lectura_ajax").innerHTML="";}</script></head><body onload="lectura_serie();"><?php include("../menu.php"); ?><div class="container"><h1>Python <small><?php echo( READ ); ?></small></h1><?php if (isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!=""){ ?> <?php echo INFOOS_MESSAGE; ?> <strong><?php echo $_SESSION['OS'];?></strong><br> <?php echo PORT_SELECTED_MESSAGE; ?> <strong><?php echo $_SESSION['puerto'];?></strong> <br>

<button type="button" class="btn btn-small" onclick="lectura_serie()"> <i class="icon-play"></i> Play </button> <button type="button" class="btn btn-small" onclick="limpia_serie()"> <i class="icon-refresh"></i> <?php echo CLEAN; ?> </button>

<br> <span id="lectura_ajax"></span><?php} else { echo ERROR_BEFOREWRITE_MESSAGE;} ?></div>


</body></html>

python_write.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?><script> function foco(){ document.enviar.q2.focus() document.enviar.q2.select() }</script><script type="text/javascript">function escritura_serie(str){if (str.length==0) { document.getElementById("txtHint").innerHTML=""; return; }if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmlhttp=new XMLHttpRequest(); }else {// code for IE6, IE5 xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); }xmlhttp.onreadystatechange=function() { if (xmlhttp.readyState==4 && xmlhttp.status==200) {



stopbit = serial.STOPBITS_TWOparidad = form.getvalue('paridad')if (paridad == "none"): paridad = serial.PARITY_NONEif (paridad == "odd"): paridad = serial.PARITY_ODDif (paridad == "even"): paridad = serial.PARITY_EVENcontrol = form.getvalue('control')if (control == "none"): hard=0 soft=0if (control == "rts/cts"): hard=1 soft=0if (control == "xon/xoff"): hard=0 soft=1veces = form.getvalue('veces')



if (lang_msg == "es"): error_msg = "ERROR: no puedo abrir el puerto!" info_msg = "Mensaje recibido: "if (lang_msg == "ca"): error_msg = "ERROR: no puc obrir el port!" info_msg = "Missatge rebut: "if (lang_msg == "en"): error_msg = "ERROR: Could not open port!" info_msg = "Message received: "

print "Content-Type: text/javascript\n"

try: #ser = serial.Serial(port=puerto, baudrate=velocidad, timeout=2, bytesize=databit, stopbits=stopbit, parity=paridad, rtscts=hard, xonxoff=soft) ser = serial.Serial() ser.port = puerto ser.baudrate = velocidad ser.timeout = 2 ser.parity = paridad ser.stopbits = stopbit ser.bytesize = databit ser.rtscts = hard ser.xonxoff = soft ser.open()except: print error_msgelse: if (veces == None): veces = 1

if ((veces == "endless") or (veces == "sin fin") or (veces == "sense fi")): endless = 1 else: endless = 0 veces = int(veces)

while True: data = ser.readline() if (len(data)>0): print "%s\n" % (info_msg+data) print "<br>" break if (endless == 0): if (veces == 1): break veces = veces - 1 sys.stdout.flush() time.sleep(0.5)

#veces = 5#for i in range(0, veces): #print i

#buffer = '' #while True: #time.sleep(1) #buffer += ser.read(ser.inWaiting()) # get remaining buffered chars #print "buffer: %s\n" % (buffer)



#print "<br>" #if '\n' in buffer: #if 'b' in buffer: #lines = buffer.split('b') # Guaranteed to have at least 2 entries #last_received = lines[-2] #If the Arduino sends lots of empty lines, you'll lose the #last filled line, so you could make the above statement conditional #like so: if lines[-2]: last_received = lines[-2] #buffer = lines[-1]

recibir_linux_json.py


# CALL: http://127.0.0.1/serie/cgi-bin/recibir_linux_json.py?puerto=/dev/ttyACM0&velocidad=9600&databit=8&stopbit=1&paridad=none&control=none

import cgi, cgitbimport serialimport sysimport timefrom time import time,sleepimport reimport json


# Create instance of FieldStorageform = cgi.FieldStorage() # instantiate only once!puerto = form.getvalue('puerto')velocidad = form.getvalue('velocidad')databit = form.getvalue('databit')if (databit == "5"): databit = serial.FIVEBITSif (databit == "6"): databit = serial.SIXBITSif (databit == "7"): databit = serial.SEVENBITSif (databit == "8"): databit = serial.EIGHTBITSstopbit = form.getvalue('stopbit')if (stopbit == "1"): stopbit = serial.STOPBITS_ONEif (stopbit == "1.5"): stopbit = serial.STOPBITS_ONE_POINT_FIVEif (stopbit == "2.0"): stopbit = serial.STOPBITS_TWOparidad = form.getvalue('paridad')if (paridad == "none"): paridad = serial.PARITY_NONEif (paridad == "odd"): paridad = serial.PARITY_ODDif (paridad == "even"): paridad = serial.PARITY_EVENcontrol = form.getvalue('control')if (control == "none"): hard=0 soft=0if (control == "rts/cts"): hard=1 soft=0if (control == "xon/xoff"): hard=0 soft=1veces = 1x = time()*1000# DEBUG#puerto = "/dev/ttyS32"#velocidad = "9600"#databit = serial.EIGHTBITS#stopbit = serial.STOPBITS_ONE#paridad = serial.PARITY_NONE#hard=0#soft=0# END DEBUGtry: ser = serial.Serial() ser.port = puerto ser.baudrate = velocidad



ser.timeout = 2 ser.parity = paridad ser.stopbits = stopbit ser.bytesize = databit ser.rtscts = hard ser.xonxoff = soft ser.open()except: print "Content-Type: application/json\n" temp = 0 jsondata = [round(x, 0), temp] print json.dumps( jsondata )else: #ser.write('A') #sleep(0.01) #ser.write('info\r') #s.flushInput() #s.flushOutput() #s.write('hello') #sys.stdout.write('%r\n' % s.read(5)) #sys.stdout.write('%s\n' % s.inWaiting()) #del s header = form.getvalue('header') print "Content-Type: application/json\n" while True: # temp ser.write(header+"R50000\r") sleep(0.15) data = ser.readline() if (len(data) > 0): datamsg = data[4:7] temp = float(datamsg[0]+datamsg[1]+'.'+datamsg[2]) # battery ser.write(header+"R52000\r") sleep(0.15) data = ser.readline() if (len(data) > 0): datamsg = data[4:7] bat = float(datamsg[0]+'.'+datamsg[1]+datamsg[2]) # rssi ser.write(header+"R51000\r") sleep(0.15) data = ser.readline() if (len(data) > 0): datamsg = data[4:7] rssi = float(datamsg[0]+datamsg[1]+'.'+datamsg[2]) #print data #pat = r'DNode:(.*),Temp:(.*)C,Battery:(.*)V,Strength:(.*)%' #r = re.compile(pat) #m = r.match(data) #if m: #temp = float(m.group(2).lstrip()) #bat = float(m.group(3)) #rssi = float(m.group(4)) #else: #temp = 0 #bat = 0 #rssi = 0 sys.stdout.flush() if (veces == 1): break veces = veces - 1 ser.close() jsondata = [[round(x, 0), temp],[round(x, 0), bat],[round(x, 0), rssi]] print json.dumps( jsondata )

recibir_windows.py

#!C:\Python32\python.exe -u#!/usr/bin/env python# Import modules for CGI handlingimport cgi, cgitbimport serialimport sysimport time

# Create instance of FieldStorageform = cgi.FieldStorage() # instantiate only once!puerto = form.getvalue('puerto')



velocidad = form.getvalue('velocidad')databit = form.getvalue('databit')if (databit == "5"): databit = serial.FIVEBITSif (databit == "6"): databit = serial.SIXBITSif (databit == "7"): databit = serial.SEVENBITSif (databit == "8"): databit = serial.EIGHTBITSstopbit = form.getvalue('stopbit')if (stopbit == "1"): stopbit = serial.STOPBITS_ONEif (stopbit == "1.5"): stopbit = serial.STOPBITS_ONE_POINT_FIVEif (stopbit == "2.0"): stopbit = serial.STOPBITS_TWOparidad = form.getvalue('paridad')if (paridad == "none"): paridad = serial.PARITY_NONEif (paridad == "odd"): paridad = serial.PARITY_ODDif (paridad == "even"): paridad = serial.PARITY_EVENcontrol = form.getvalue('control')if (control == "none"): hard=0 soft=0if (control == "rts/cts"): hard=1 soft=0if (control == "xon/xoff"): hard=0 soft=1veces = form.getvalue('veces')



if (lang_msg == "es"): error_msg = "ERROR: no puedo abrir el puerto!" info_msg = "Mensaje recibido: "if (lang_msg == "ca"): error_msg = "ERROR: no puc obrir el port!" info_msg = "Missatge rebut: "if (lang_msg == "en"): error_msg = "ERROR: Could not open port!" info_msg = "Message received: "

print ("Content-Type: text/javascript\n")try: #ser = serial.Serial(port=puerto, baudrate=velocidad, timeout=2, bytesize=databit, stopbits=stopbit, parity=paridad, rtscts=hard, xonxoff=soft) ser = serial.Serial() ser.port = puerto ser.baudrate = velocidad ser.timeout = 2 ser.parity = paridad ser.stopbits = stopbit ser.bytesize = databit ser.rtscts = hard ser.xonxoff = soft ser.open()except: print (error_msg)else: if (veces == None): veces = 1

if ((veces == "endless") or (veces == "sin fin") or (veces == "sense fi")): endless = 1 else: endless = 0 veces = int(veces)

while True: data = ser.readline() if (len(data)>0): print (info_msg+data.decode('utf-8')) print ("<br>") break if (endless == 0):



if (veces == 1): break veces = veces - 1 sys.stdout.flush() time.sleep(0.5)

recibir_windows_json.py

#!C:\Python32\python.exe -u#!/usr/bin/env python# Import modules for CGI handling

# CALL: http://127.0.0.1/serie/cgi-bin/recibir_windows_json.py?puerto=COM3&velocidad=9600&databit=8&stopbit=1&paridad=none&control=none

import cgi, cgitbimport serialimport sysimport timefrom time import time,sleepimport reimport json


# Create instance of FieldStorageform = cgi.FieldStorage() # instantiate only once!puerto = form.getvalue('puerto')velocidad = form.getvalue('velocidad')databit = form.getvalue('databit')if (databit == "5"): databit = serial.FIVEBITSif (databit == "6"): databit = serial.SIXBITSif (databit == "7"): databit = serial.SEVENBITSif (databit == "8"): databit = serial.EIGHTBITSstopbit = form.getvalue('stopbit')if (stopbit == "1"): stopbit = serial.STOPBITS_ONEif (stopbit == "1.5"): stopbit = serial.STOPBITS_ONE_POINT_FIVEif (stopbit == "2.0"): stopbit = serial.STOPBITS_TWOparidad = form.getvalue('paridad')if (paridad == "none"): paridad = serial.PARITY_NONEif (paridad == "odd"): paridad = serial.PARITY_ODDif (paridad == "even"): paridad = serial.PARITY_EVENcontrol = form.getvalue('control')if (control == "none"): hard=0 soft=0if (control == "rts/cts"): hard=1 soft=0if (control == "xon/xoff"): hard=0 soft=1veces = 2x = time()*1000print ("Content-Type: application/json\n")try: ser = serial.Serial() ser.port = puerto ser.baudrate = velocidad ser.timeout = 2 ser.parity = paridad ser.stopbits = stopbit ser.bytesize = databit ser.rtscts = hard ser.xonxoff = soft ser.open()except: temp = 0 jsondata = [round(x, 0), temp] print (json.dumps( jsondata ))



else: #ser.write(b'A') #sleep(0.01) #ser.write(b'info\r') header = form.getvalue('header') while True: # temp envia_msg = header+"R50000\r" ser.write(envia_msg.encode()) sleep(0.15) data = ser.readline() if (len(data) > 0): datamsg = data[4:7].decode('utf-8') temp = float(datamsg[0]+datamsg[1]+'.'+datamsg[2]) # battery envia_msg = header+"R52000\r" ser.write(envia_msg.encode()) sleep(0.15) data = ser.readline() if (len(data) > 0): datamsg = data[4:7].decode('utf-8') bat = float(datamsg[0]+'.'+datamsg[1]+datamsg[2]) # rssi envia_msg = header+"R51000\r" ser.write(envia_msg.encode()) sleep(0.15) data = ser.readline() if (len(data) > 0): datamsg = data[4:7].decode('utf-8') rssi = float(datamsg[0]+datamsg[1]+'.'+datamsg[2]) #print (data) #pat = r'DNode:(.*),Temp:(.*)C,Battery:(.*)V,Strength:(.*)%' #r = re.compile(pat) #m = r.match(data.decode()) #if m: #temp = float(m.group(2).lstrip()) #bat = float(m.group(3)) #rssi = float(m.group(4)) #else: #temp = 0 #bat = 0 #rssi = 0 sys.stdout.flush() if (veces == 1): break veces = veces - 1 ser.close() jsondata = [[round(x, 0), temp],[round(x, 0), bat],[round(x, 0), rssi]] print (json.dumps( jsondata ))

setup_AP.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?><script> function foco(){ document.enviar.adrED.focus() document.enviar.adrED.select() //lectura_serie() }

function getValueFromName(name){ var radioButtons = document.getElementsByName(name); for (var x = 0; x < radioButtons.length; x ++) { if (radioButtons[x].checked) { return radioButtons[x].value; } }}

function lectura_serie(){



if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmllectura=new XMLHttpRequest(); }else {// code for IE6, IE5 xmllectura=new ActiveXObject("Microsoft.XMLHTTP"); }xmllectura.onreadystatechange=function() { document.getElementById("lectura_ajax").innerHTML=xmllectura.responseText; }

<?php if (isset($_SESSION['OS']) && $_SESSION['OS']!=""){ if ( $_SESSION['OS']=="LINUX" ) {?>xmllectura.open("GET","../cgi-bin/recibir_linux.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&veces="+document.enviar.veces.value,true);<?php }?><?php if ( $_SESSION['OS']=="WINDOWS" ) {?>xmllectura.open("GET","../cgi-bin/recibir_windows.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&veces="+document.enviar.veces.value,true);<?php }}?>xmllectura.send();}

function escritura_serie(address,data){if (data.length==0) { document.getElementById("escritura_ajax").innerHTML=""; return; }if (window.XMLHttpRequest) {// code for IE7+, Firefox, Chrome, Opera, Safari xmlhttp=new XMLHttpRequest(); }else {// code for IE6, IE5 xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); }xmlhttp.onreadystatechange=function() { if (xmlhttp.readyState==4 && xmlhttp.status==200) { document.getElementById("escritura_ajax").innerHTML=xmlhttp.responseText; } }<?php if (isset($_SESSION['OS']) && $_SESSION['OS']!=""){ if ( $_SESSION['OS']=="LINUX" ) {?>xmlhttp.open("GET","../cgi-bin/enviar_linux.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&destino_msg=AP&rw=W&address="+address+"&data="+data,true);<?php }?><?php if ( $_SESSION['OS']=="WINDOWS" ) {?>xmlhttp.open("GET","../cgi-bin/enviar_windows.py?puerto=<?php echo $_SESSION['puerto']; ?>&velocidad=<?php echo $_SESSION['velocidad']; ?>&databit=<?php echo $_SESSION['databit']; ?>&stopbit=<?php echo $_SESSION['stopbit']; ?>&paridad=<?php echo $_SESSION['paridad']; ?>&control=<?php echo $_SESSION['control']; ?>&destino_msg=AP&rw=W&address="+address+"&data="+data,true);<?php } ?> if (address=='61') { $.ajax({ url: 'guarda.php?APaddress='+data }); }

if (address=='60') { $.ajax({ url: 'guarda.php?EDaddress='+data }); }<?php}?>xmlhttp.send();}

function limpia_serie(){ document.getElementById("escritura_ajax").innerHTML="";}</script></head><body><?php include("../menu.php"); ?><div class="container"> <h1><?php echo( READWRITE_MESSAGE ); ?> <small><?php echo CONFIGURACION_MESSAGE; ?> AP</small></h1><?php if ( isset($_SESSION['velocidad']) && $_SESSION['velocidad']!="" && isset($_SESSION['puerto']) && $_SESSION['puerto']!="" && isset($_SESSION['OS']) && $_SESSION['OS']!="" && (writable_port($_SESSION['puerto'])==1) ){?> <div class="row"> <div class="span7"> <h2>Control <small><?php echo INFOOS_MESSAGE; ?>:<strong> <?php echo $_SESSION['OS'];?></strong> · <?php echo PORT_SELECTED_MESSAGE; ?> <strong><?php echo $_SESSION['puerto'];?></strong></small></h2>

<form id="enviar" name="enviar" method="post" action="" class="form-horizontal"> <fielset> <div class="form-actions"> <button type="button" class="btn btn-small" onclick="limpia_serie()"> <i class="icon-refresh"></i> <?php echo CLEAN; ?> </button> </div>

<label class="control-label">1.- <?php echo ADDRESS_MESSAGE . " ED:"; ?></label> <div class="controls"> <input name="adrED" type="text" id="adrED" size="10" maxlength="3" class="span1" value="<?php echo (isset($_SESSION['EDaddress']) && $_SESSION['EDaddress']!="") ? $_SESSION['EDaddress'] : "" ?>" /> <button type="button" class="btn btn-small" onclick="escritura_serie('60',document.enviar.adrED.value)"> <i class="icon-chevron-right"></i> <?php echo substr(SEND_BUTTON_MESSAGE, 0, -6) . " " . strtolower(ADDRESS_MESSAGE) . " ED"; ?> </button> </div> <br> <label class="control-label">2.- <?php echo ADDRESS_MESSAGE . " AP:"; ?></label> <div class="controls"> <input name="adrAP" type="text" id="adrAP" size="10" maxlength="3" class="span1" value="<?php echo (isset($_SESSION['APaddress']) && $_SESSION['APaddress']!="") ? $_SESSION['APaddress'] : "" ?>" /> <button type="button" class="btn btn-small" onclick="escritura_serie('61',document.enviar.adrAP.value)"> <i class="icon-chevron-right"></i> <?php echo substr(SEND_BUTTON_MESSAGE, 0, -6) . " " . strtolower(ADDRESS_MESSAGE) . " AP"; ?> </button> </div> <br> <label class="control-label">3.- <?php echo "Control:"; ?></label> <div class="controls"> <button type="button" class="btn btn-small" onclick="escritura_serie('62','001')"> <i class="icon-cog"></i><?php echo CONFIGURACION_MESSAGE; ?> AP </button> </div>

</fielset> </form> </div> <div class="span5"> <h2><?php echo CONSOLE_MESSAGE; ?></h2> <br> <span id="escritura_ajax"></span> </div> </div><?php} else { ?> <div class="alert alert-block alert-error fade in"> <button type="button" class="close" data-dismiss="alert">×</button> <h4 class="alert-heading">ERROR</h4> <p><?php echo ERROR_BEFOREWRITE_MESSAGE; ?></p> <p> <?php if (!isset($_SESSION['OS']) || $_SESSION['OS']=="") { ?> <a class="btn btn-primary" href="../configuracion/osinfo.php"><?php echo( DETECT_OS_MESSAGE );?></a>

<?php } elseif (!isset($_SESSION['puerto']) || $_SESSION['puerto']=="") { ?> <a class="btn btn-primary" href="../configuracion/detectar_port.php"><?php echo( DETECT_PORT_MESSAGE );?></a> <?php } elseif (!isset($_SESSION['velocidad']) || $_SESSION['velocidad']=="") { ?> <a class="btn btn-primary" href="../configuracion/configuracio.php"><?php echo( CONFIG_PORT_MESSAGE );?></a> <?php } elseif (writable_port($_SESSION['puerto'])==0) { ?> <?php echo( CHECKNOK_MESSAGE );?> <br><br> <a class="btn btn-info" href="../configuracion/check_port.php"><i class="icon-pencil icon-white"></i> <?php echo( CHECK_MESSAGE );?></a> <?php } ?> </p> </div> <a class="btn" href="javascript:history.back(1)"><i class="icon-chevron-left"></i> <?php echo( GOBACK_MESSAGE );?></a> <a class="btn" href="../"><i class="icon-home"></i> <?php echo( GOHOME_MESSAGE );?></a><?php } ?>

</div> 


</body></html>

system.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");?><?phpwriteheader(HOME_DESCRIP,KEYWORDS_MESSAGE);?></head><body><?php include("../menu.php"); ?><div class="container"><div class="row"><div class="span8"><h1><?php echo INFOOSALL_MESSAGE; ?> <small><?php echo DETECTED_MSG; ?></small></h1><br>

<embed id="system_image" src="system_image_svg.php" width="915" height="256" />

</div></div>


</body></html>

system_image_svg.php

<?phpif (!isset($_SESSION)) { session_start();}include("../init.php");

header('Content-Encoding: gzip', true);header ("content-type: image/svg+xml", true);?><?php// get contents of a image file (SVG) into a string$filename = "../imagen/esquema_mensajeria.svg";$handle = fopen($filename, "r");

// eliminar 114 bytes iniciales//fseek($handle, 114);

// leer contenido$contents = fread($handle, filesize($filename));

// set sistema operativoif (!isset($_SESSION['OS'])) { $os = "UNDEFINED";



} else { $os = $_SESSION['OS'];}$contents = str_replace ( "#SISTEMAOPERATIVO#" , $os , $contents );

// set apache versionif (!isset($_SERVER['SERVER_SOFTWARE'])) { $apache_version = "UNDEFINED";} else { $apache_version = $_SERVER['SERVER_SOFTWARE'];}$contents = str_replace ( "#APACHE_VERSION#" , $apache_version , $contents );

// set php version$contents = str_replace ( "#PHP_VERSION#" , phpversion() , $contents );

// set python versionif (isset($_SESSION['OS']) && $_SESSION['OS']=="LINUX"){ $PATH = url_completa('../cgi-bin/version_linux_installed.py');}if (isset($_SESSION['OS']) && $_SESSION['OS']=="WINDOWS"){ $PATH = url_completa('../cgi-bin/version_windows_installed.py');}$version_python = @stripslashes( @join( @file( $PATH ),"" ) );if ($version_python==NULL) { $version_python = "UNDEFINED";}$contents = str_replace ( "#PYTHON_VERSION#" , $version_python , $contents );

// set serial port selectedif (!isset($_SESSION['puerto'])) { $serialport_selected = "UNDEFINED";} else { $serialport_selected = $_SESSION['puerto'];}$contents = str_replace ( "#SERIAL_PORT_SELECTED#" , $serialport_selected , $contents );

// set serial port configurationif (!isset($_SESSION['velocidad'])) { $config = "UNDEFINED";} else { $config = $_SESSION['velocidad'] . " " . $_SESSION['databit'] . " " . $_SESSION['paridad'] . " " . $_SESSION['stopbit'] . " " . $_SESSION['control'];}$contents = str_replace ( "#CONFIGURATION_SERIAL_PORT#" , $config , $contents );

fclose($handle);echo gzencode($contents, 9);?>



21 Anexo B: TutorialVersión Fecha

1.0 03/10/2012 Primera versión

1.1 11/10/2012 Ampliación para Windows 7

Manual de instalación y preparación del entorno

1.-Requisitos del sistema operativo

Partimos de un sistema operativo Microsoft Windows XP SP3 de 32 bits.

Espacio libre en disco duro de aproximadamente 5GB.

Mínimo de 1GB de RAM



2.-Instalación del aplicativo web

2.1.-Instalación de WAMP Server

Instalación de Microsoft Visual C++ 2010 SP1 Redistributable Package (x86):

FICHERO: vcredist_x86.exe

MD5SUM: cede02d7af62449a2c38c49abecc0cd3

ENLACE: http://www.microsoft.com/download/en/details.aspx?id=8328

Instalación de WAMP Server (32 bits & PHP 5.4) 2.2E:

FICHERO: wampserver2.2e-php5.4.3-httpd2.2.22-mysql5.5.24-32b.exe

MD5SUM: 22ed48e6d994baf6c439e85caff20f49

ENLACE: http://sourceforge.net/projects/wampserver/files/WampServer%202/WampServer

%202.2/wampserver2.2e/wampserver2.2e-php5.4.3-httpd2.2.22-mysql5.5.24-

32b.exe/download

http://sourceforge.net/projects/wampserver/files/WampServer%202/WampServer%202.2/wampserver2.2e/wampserver2.2e-php5.4.3-httpd2.2.22-mysql5.5.24-32b.exe/download



http://www.microsoft.com/download/en/details.aspx?id=8328



Instalación en la c:\wamp (configuración por defecto).

SMTP: localhost y Email: you@yourdomain (configuración por defecto).

Permitir al firewall que el servidor Apache se ejecute sin problemas, pulsando “Desbloquear”

para ello:

Si el servidor WAMP se ha instalado correctamente abajo a la derecha aparecerá un icono de

color verde con el símbolo de una letra W, cómo se muestra:

mailto:you@yourdomain



2.2.-Windows 7

Para este sistema operativo Windows 7:



Al principio nos pedirá algunos permisos para la instalación:

Si por algún motivo no arrancara el WAMP Server podríamos ver el log del servidor web Apache

para obtener más información de lo que sucede:

Click con botón izquierdo del ratón sobre el icono WAMP > Apache > Apache error log



Y se nos abrirá una ventana del bloc de notas con la información sobre el servidor web:

Una de las cosas que puede impedir el arranque del servidor web Apache podría ser que exista

en el sistema un programa que esté a la escucha del mismo puerto de red que el servidor

web, que es el puerto 80. Para comprobar que este no sea el problema podemos ver si existe

algún otro programa a la escucha sobre ese puerto.

Inicio > Ejecutar > cmd

Con ello se abrirá la consola tipo MS-DOS, pero para indicarle el comando siguiente, antes

debemos ejecutarla en modo administrador de la siguiente forma:



De esta forma se nos mostrará un mensaje de advertencia:

y se nos volverá a abrir la ventana tipo MS-DOS, allí escribiremos el siguiente comando:

netstat -bap tcp

El comando nos mostrará todos los puertos a la escucha en el sistema, trataremos de buscar

en la dirección local el puerto 80 TCP y si está funcionando bien debería indicar que está a la

escucha y el proceso del sistema del servidor web Apache: httpd.exe

Existe literatura en Internet que habla de un posible problema generalizado cuando se está

ejecutando antes del WAMP el programa de comunicación Skype. Ya que Skype parece que

estaría usando el mismo puerto 80. Información:

http://forum.wampserver.com/read.php?2,36489

http://stackoverflow.com/questions/4705005/how-to-solve-wamp-and-skype-conflict-on-

windows-7

Por lo que recomendaríamos desactivarlo mientras se ejecuta Skype.

http://stackoverflow.com/questions/4705005/how-to-solve-wamp-and-skype-conflict-on-windows-7

http://stackoverflow.com/questions/4705005/how-to-solve-wamp-and-skype-conflict-on-windows-7

http://forum.wampserver.com/read.php?2,36489



2.3.-Configuración WAMP Server

Pensamos en qué directorio queremos colocar la web en nuestro disco duro, en el ejemplo:

C:\Datos\Proyecto\web

Se recomienda usar un directorio libre de espacios, caracteres raros, accentos, etc.

Descomprimir el archivo web.zip (MD5SUM: ef81004fd903b60cf0803f2416ab72b0) en el

directorio escogido. Dentro de este directorio deberíamos visualizar el archivo index.php en

la raíz del mismo.



Usando el botón de la derecha del ratón pulsamos sobre el icono verde del servidor WAMP

para escoger el idioma Spanish:

Ahora agregaremos un alias que apunte al directorio en dónde hemos colocado la web. Para

ello usaremos el botón de la izquierda del ratón pulsando sobre el icono verde del servidor

WAMP. Seleccionar Apache > Directorios Alias > + Agregar un alias:



Se nos mostrará una ventana con estilo MS-DOS, introduciremos el nombre del alias en

nuestro caso es: “serie”

...y pulsaremos enter.

A continuación se nos pedirá la ruta (el directorio) dónde está ubicada la web.

En nuestro caso era: C:\Datos\Proyecto\web pero atención escribiremos:

C:/Datos/Proyecto/web/

¡¡Mucha atención en cómo se ha escrito la ubicación!! hemos usado “/” y también al final

del directorio. Respetar también el tema de las mayúsculas y minúsculas.

Pulsamos enter para confirmar y otro enter para salir tal cómo se nos informará.

Observaríamos que el icono verde de WAMP se pone de color rojo, luego naranja y finalmente

otra vez de color verde. Esto se debe a que el servidor WAMP se ha reiniciado al establecer un

alias.



Ahora activaremos el módulo de Apache llamado “rewrite_module”.

Click izquierdo del ratón > Apache > Módulos de Apache > activar “rewrite_module”

Veremos cómo vuelve a reiniciarse el servidor.

Configuración del alias: Apache > Directorios Alias > seleccionar el “http://localhost/serie/” >

“Edit alias”:

http://localhost/serie/



El contenido debería ser muy parecido o idéntico a:

Deberemos agregar el siguiente texto a continuación:

<Directory "c:/Datos/Proyecto/web/cgi-bin/">

AllowOverride None

Options Indexes FollowSymLinks Includes

Order allow,deny

Allow from all

Options +ExecCGI

</Directory>

AddHandler cgi-script .cgi .py



y quedará:

Saldremos guardando los cambios efectuados.

2.4.-Instalación de Python

Instalación de Python version 3.2.2 Windows x86 MSI Installer:

FICHERO: python-3.2.2.msi

MD5SUM: 8afb1b01e8fab738e7b234eb4fe3955c

ENLACE: http://www.python.org/ftp/python/3.3.0/python-3.3.0.msi

Realizaremos la instalación en: C:\Python32\

http://www.python.org/ftp/python/3.3.0/python-3.3.0.msi



Una vez instalado deberemos añadir al path del sistema allí dónde está instalado Python:

Ir a Mi PC > Propiedades > Configuración avanzada del sistema (pestaña Opciones avanzadas) >

botón Variables de entorno… > Variables del sistema > seleccionar Path > botón Editar… y

agregar:

;C:\Python32

Convendría reiniciar el sistema para que se establezca la variable de entorno del sistema. A

veces se establece si finalizamos el proceso Explorer y lo volvemos a inicializar o cerramos la

sesión de Windows.

Una vez reiniciado. Verificar que en la variable de entorno de sistema Path se haya creado el

camino de instalación de Python, Windows: Inicio > Ejecutar > cmd > escribir

echo %path%

si aparece algo como

[...];C:\Python32[...]

indicará que está correctamente puesto en el PATH.

2.5.-Instalación de la librería Python Serial

Instalación de la librería Python Serial 2.6

FICHERO: pyserial-2.6.tar.gz

MD5SUM: cde799970b7c1ce1f7d6e9ceebe64c98

ENLACE: http://pypi.python.org/packages/source/p/pyserial/pyserial-

2.6.tar.gz#md5=cde799970b7c1ce1f7d6e9ceebe64c98

Descomprimimos el archivo de tal manera que por ejemplo quede así:

http://pypi.python.org/packages/source/p/pyserial/pyserial-2.6.tar.gz#md5=cde799970b7c1ce1f7d6e9ceebe64c98

http://pypi.python.org/packages/source/p/pyserial/pyserial-2.6.tar.gz#md5=cde799970b7c1ce1f7d6e9ceebe64c98



Vamos a abrir una consola MS-DOS: Inicio > Ejecutar > cmd

Ahora vamos al directorio dónde hemos descomprimido los archivos:

y ejecutamos allí la orden: python setup.py install

de esta forma hemos instalado la librería de control serie para Python.

En la siguiente pantalla vemos la instalación de la librería:



2.6.-Comprobación de la instalación del entorno web

Ir a la web local instalada abriendo un navegador web (recomendado Mozilla Firefox)

escribiendo la siguiente dirección:

http://127.0.0.1/serie/

Se deberá visualizar algo similar a lo siguiente:

Pulsaremos el botón azul “Detectar S.O.” cómo primer paso.

Verificar versión de Apache instalado:

Menú Información > Servidor web > comprobar que en letras grandes ponga:

Apache/2.2.22 (Win32) PHP/5.4.3

Verificar versión de PHP instalado:

Menú Información > Servidor PHP > comprobar que en letras grandes ponga:

PHP 5.4.3

http://127.0.0.1/serie/



Verificar versión de Python instalado:

Menú Información > Python Versión > Verificaremos que ponga:

Version Python Windows

Testeado en: 3.2.2 (default, Sep 4 2011, 09:51:08) [MSC v.1500 32 bit (Intel)]

Instalada: 3.2.2 (default, Sep 4 2011, 09:51:08) [MSC v.1500 32 bit (Intel)]

Comprobar funcionamiento de la conexión con Python:

Menú Información > Python test CGI > aparecerá una ventana con un formulario:

Escribiremos alguna palabra para probar (test en el ejemplo) y pulsaremos enter. El texto (no

message) deberá cambiar por la palabra escrita:

De esta manera habremos comprobado que funciona correctamente y toda la parte web está

correctamente instalada.



3.-Instalación del Access Point

3.1.-Instalación del driver para el dispositivo AP (MSP430)

Primero descomprimiremos el driver en algún lugar del disco duro.

Instalación del driver que está dentro del archivo de Texas Instruments fabricante del MSP430:

FICHERO: slac219a.zip

MD5SUM: 1b32b9b91a7d0f90fb29d3e9f36e28ea

ENLACE: http://www.ti.com/lit/zip/slac219

Este archivo tiene más programas y por ello pesa 5.2MB así que recomendamos usar el

siguiente archivo preparado únicamente con la parte del driver:

Instalación del driver del dispositivo USB del MSP430 llamado Access Point:

FICHERO: driversMSP430.zip

MD5SUM: bc4fbb284b157051415d4fbf44842901

Insertaremos el USB con el MSP430 que hará de Access Point (AP). Se nos mostrará el asistente

de hardware nuevo:

http://www.ti.com/lit/zip/slac219



Comprobaremos que esté correctamente instalado visualizando el hardware de nuestro

equipo:



3.2.-Instalación del software Code Composer Studio Version 4

Instalación del IDE de programación para el MSP430:

FICHERO: setup_CCS_MC_Core_4.2.4.00033.exe

MD5SUM: ccfd6fa0e55436ca82d38ec6f1b42b1c

ENLACE: http://software-dl.ti.com/dsps/forms/self_cert_export.html?

prod_no=setup_CCS_MC_Core_4.2.4.00033.zip&ref_url=http://software-

dl.ti.com/dsps/dsps_public_sw/sdo_ccstudio/CCSv4/CCS_4_2_4/

Descarga directa: http://software-

dl.ti.com/download/dsps/4CJ3DP2JSD5MVN5SQCBQNX3A4IZAISF_/setup_CCS_MC_Core_4.2.4.

00033.zip

Versión: 4.2.4.00033

WEB de información: http://processors.wiki.ti.com/index.php/Download_CCS

Aproximadamente esta instalación ocupará unos 370MB de espacio en disco. Lo instalaremos

en su sitio por defecto:

http://processors.wiki.ti.com/index.php/Download_CCS

http://software-dl.ti.com/download/dsps/4CJ3DP2JSD5MVN5SQCBQNX3A4IZAISF_/setup_CCS_MC_Core_4.2.4.00033.zip



http://software-dl.ti.com/dsps/forms/self_cert_export.html?prod_no=setup_CCS_MC_Core_4.2.4.00033.zip&ref_url=http://software-dl.ti.com/dsps/dsps_public_sw/sdo_ccstudio/CCSv4/CCS_4_2_4/





Escogeremos sólo la opción de MSP430-only Core Tools:

Selección por defecto de los componentes a instalar:



Instalación:

Creación del workspace:

Primer arranque:



Instalación de actualizaciones:

Selección de actualizaciones:



Selección de componentes a instalar:

Verfificamos e instalamos:



3.3.-Instalación de Grace

Instalación de GRACE-CCSV4: Grace 1.0 Plugin for Code Composer Studio 4.2

FICHERO: slac486.zip

MD5SUM: d4bd016c52120783134d88985078edf6

ENLACE: http://www.ti.com/tool/Grace

Descarga directa: http://www.ti.com/lit/sw/slac486/slac486.zip

Una vez descomprimimos el fichero, ejecutamos el archivo de instalación, llamado:

grace_setupwin32_1_00_01_83.exe

http://www.ti.com/lit/sw/slac486/slac486.zip

http://www.ti.com/tool/Grace



3.4.-Configuración del proyecto MSP430

Instalación del fichero del proyecto descomprimiendo el mismo en el directorio:

C:\Datos\Proyecto\workspace

FICHERO: MSP430_CCS_Source_20121007_C.zip

MD5SUM: d941dcdaab016146412fcc7c9fe85a30

Debería verse así:

Pasos para cargar el proyecto: File > Import > Existing Projects into Workspace



Seleccionamos dónde se encuentra el proyecto, en nuestro caso, en:

C:\Datos\Proyecto\workspace\CCS_Source



Ajuste de la variable de entorno para el proyecto:

Seleccionar: Window > Preferences... > General > Workspace > Linked Resources > New... para

crear una nueva variable:

a. Nombre de la variable: eZ430_WSM_ROOT

b. Click en el directorio (botón “Folder...”) y seleccionar el siguiente:

C:\Datos\Proyecto\workspace\CCS_Source



Cuando compilemos el proyecto no debería dar ningún problema.

Para compilar: Project > Build Active Project

Y para grabarlo en el MSP430 es: Target > Debug Active Project



4.-Configuración de la placa de Avnet

Instalación de Xilinx Platform Studio requerida:

4.1.-Configuración del XPS EDK

Instalación del fichero del proyecto descomprimiendo el mismo en el directorio que se desee.

FICHERO: Avnet_UPC_20121001.zip

MD5SUM: 87c59a805b837659cc9c8e222e4a51b3

Este fichero contiene todo el proyecto de Xilinx Platform Studio (XPS)



Configuración del hardware:

Volcado del system.ucf:

# Spartan-3A Evaluation Board (3S400A)Net fpga_0_USB_UART_RX_pin LOC=A3 | IOSTANDARD = LVCMOS33;Net fpga_0_USB_UART_TX_pin LOC=B3 | IOSTANDARD = LVCMOS33;Net fpga_0_MSP430_UART_RX_pin LOC=M1 | IOSTANDARD = LVCMOS33;Net fpga_0_MSP430_UART_TX_pin LOC=N1 | IOSTANDARD = LVCMOS33;Net fpga_0_LEDS_4BIT_GPIO_IO_pin<0> LOC=B15 | IOSTANDARD = LVCMOS33;Net fpga_0_LEDS_4BIT_GPIO_IO_pin<1> LOC=C15 | IOSTANDARD = LVCMOS33;Net fpga_0_LEDS_4BIT_GPIO_IO_pin<2> LOC=C16 | IOSTANDARD = LVCMOS33;Net fpga_0_LEDS_4BIT_GPIO_IO_pin<3> LOC=D14 | IOSTANDARD = LVCMOS33;Net fpga_0_CS_PUSH_3BIT_GPIO_IO_I_pin<0> LOC=L3 | IOSTANDARD = LVCMOS33;Net fpga_0_CS_PUSH_3BIT_GPIO_IO_I_pin<1> LOC=H5 | IOSTANDARD = LVCMOS33;Net fpga_0_CS_PUSH_3BIT_GPIO_IO_I_pin<2> LOC=K3 | IOSTANDARD = LVCMOS33;Net fpga_0_TEMP_SENSOR_Sda_pin LOC=M13 | IOSTANDARD = LVCMOS33;Net fpga_0_TEMP_SENSOR_Scl_pin LOC=M14 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<30> LOC=N16 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<29> LOC=L13 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<28> LOC=K13 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<27> LOC=M15 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<26> LOC=M16 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<25> LOC=L14 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<24> LOC=L16 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<23> LOC=J12 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<22> LOC=J13 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<21> LOC=G16 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<20> LOC=F16 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<19> LOC=H13 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<18> LOC=G14 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<17> LOC=E16 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<16> LOC=F15 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<15> LOC=G13 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<14> LOC=F14 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<13> LOC=E14 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<12> LOC=F13 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<11> LOC=D16 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_A_pin<10> LOC=D15 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_RPN_pin LOC=T10 | IOSTANDARD = LVCMOS33;



Net fpga_0_FLASH_2Mx16_Mem_CEN_pin LOC=P15 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_OEN_pin LOC=R15 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_WEN_pin LOC=N13 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<15> LOC=T14 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<14> LOC=R13 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<13> LOC=T13 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<12> LOC=P12 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<11> LOC=N8 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<10> LOC=P7 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<9> LOC=T6 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<8> LOC=T5 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<7> LOC=P11 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<6> LOC=R3 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<5> LOC=N11 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<4> LOC=N7 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<3> LOC=R5 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<2> LOC=T4 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<1> LOC=P6 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_Mem_DQ_pin<0> LOC=P16 | IOSTANDARD = LVCMOS33;Net fpga_0_FLASH_2Mx16_MEM_BYTEn_pin LOC=N14 | IOSTANDARD = LVCMOS33;Net fpga_0_clk_1_sys_clk_pin TNM_NET = sys_clk_pin;TIMESPEC TS_sys_clk_pin = PERIOD sys_clk_pin 16000 kHz;Net fpga_0_clk_1_sys_clk_pin LOC=C10 | IOSTANDARD = LVCMOS33;Net fpga_0_rst_1_sys_rst_pin TIG;Net fpga_0_rst_1_sys_rst_pin LOC=H4 | IOSTANDARD = LVCMOS33;

###### microblaze_0### Set Vccaux for 3S400A Eval board to 3.3V ###CONFIG VCCAUX = "3.3" ;

Imagen de las interrupciones de las UART's:



Diagrama de bloques:

implementación de un sistema de comunicaciones inalámbrico

Documents