Login| Sign Up| Help| Contact|

Patent Searching and Data


Title:
RADIOVISION DEVICE
Document Type and Number:
WIPO Patent Application WO/2018/112675
Kind Code:
A1
Abstract:
The present patent relates to a compact, portable system that allows the real-time detection and location of electromagnetic emissions in the spectrum used by mobile devices (mobile phones and Wi-Fi/Bluetooth devices). The detection and location principle is based on phase-adjustment technology, which allows the synthesis of a directive beam of radiation, the shape and direction of which can be controlled electrically. This technology is used mainly in military and astronomical applications. The device also includes location and control algorithms. This device allows the detection and location of electromagnetic emissions by the antenna beam sweeping in a field of vision of 80x80 degrees. Once the detection and location have taken place, it is superimposed on a visual image collected by a video camera.

Inventors:
FINGER RICARDO (CL)
MONASTERIO DAVID (CL)
MUÑOZ CHRISTOPHER (CL)
FUENTES ROBERTO (CL)
REYES NICOLÁS (CL)
BRONFMAN LEONARDO (CL)
MENA PATRICIO (CL)
Application Number:
PCT/CL2017/050081
Publication Date:
June 28, 2018
Filing Date:
December 21, 2017
Export Citation:
Click for automatic bibliography generation   Help
Assignee:
UNIV CHILE (CL)
International Classes:
G01S3/72
Domestic Patent References:
WO2016007457A12016-01-14
WO2017004689A12017-01-12
WO2016089464A12016-06-09
WO2011148248A22011-12-01
WO2008082917A22008-07-10
Foreign References:
EP2246934A12010-11-03
EP0938156A11999-08-25
EP0144867A21985-06-19
US20150022421A12015-01-22
EP0887879A11998-12-30
EP1921709A12008-05-14
US7602337B22009-10-13
EP2100347A22009-09-16
EP2463958A12012-06-13
US6504510B22003-01-07
EP1294163A22003-03-19
US6693590B12004-02-17
EP1195017A22002-04-10
FI2014050067W2014-01-28
EP2951884A12015-12-09
US20090102716A12009-04-23
US20090027267A12009-01-29
US20160087349A12016-03-24
US20080106467A12008-05-08
US20150316641A12015-11-05
EP2246934A12010-11-03
Attorney, Agent or Firm:
BEUCHAT, BARROS & PFENNIGER ABOGADOS LIMITADA (CL)
Download PDF:
Claims:
REIVINDICACIONES

1 . Un dispositivo de detección de emisiones electromagnéticas y visibles, CARACTERIZADO porque comprende un arreglo de fases (1 ) para generar una imagen de radiofrecuencia (RF), electrónica de alta frecuencia (2), cámara de video (13), un microcomputador (6), un suministro de poder (7) y una carcasa que envuelve todas las piezas (9) y un algoritmo, donde se busca que la imagen de radiofrecuencia sea superpuesta con una imagen óptica, donde el dispositivo es compacto y portable.

2. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 1 , CARACTERIZADO porque el arreglo de fases (1 ) es compacto y portable y comprende un arreglo de antenas (10) de entre 64 a 4 antenas, de preferencia 16 elementos radiantes ordenados de forma matricial, que además son capaces de detectar múltiples bandas en el rango de frecuencia de emisión de dispositivos móviles, en el rango de frecuencia de los dispositivos móviles y/o Wifi, tal como las bandas de entre los 700-900MHz, 1700-2100 MHz, 2400-2700 MHz y 5000 MHz.

3. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con las reivindicaciones 1 y 2, CARACTERIZADO porque la electrónica de alta frecuencia (2) está dispuesta como una placa que puede sintetizar un haz de radiación en una dirección arbitraria mediante del arreglo de fases (1 ), donde la dirección está acotada a 90x90 grados, y donde la placa además envía una señal digital con la información de la señal electromagnética detectada.

4. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 3, CARACTERIZADO porque la placa de electrónica de alta frecuencia comprende los elementos de: desfasadores (3), los cuales son directamente proporcionales a la cantidad de antenas, y cambian la fase relativa de dichas señales; combinador (14) capaz de combinar para generar una señal única con la información de haz sintetizado; amplificador (1 1 ) capaz de amplificar la señal; un filtrador (12) capaz de restringir y purificar la señal; un detector de potencia total (4) capaz de convertir la señal de RF en una señal de voltaje analógico; y un converso análogo digital (5) capaz de convertir el voltaje analógico a una señal digital.

5. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 1 , CARACTERIZADO porque la cámara de video (13), es digital y muestra el área en la cual se desea detectar señales electromagnéticas.

6. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 1 , CARACTERIZADO porque el microcomputador (6) opera a través de algoritmos capaces de generar señales de control para la placa electrónica de alta frecuencia (2) y de recibir, procesar y pos procesar las señales provenientes de la placa, la cámara de video (13) y una pantalla (8) que actúa de interfaz con el usuario.

7. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 6, CARACTERIZADO porque el microcomputador (6) envía señales de control que permiten cambiar la fase de cada uno de los desfasadores (3) de la placa de electrónica de alta frecuencia (2), donde es capaz de sincronizar la adquisición de datos con dichas señales de control.

8. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 6, CARACTERIZADO porque utiliza algoritmos de detección de múltiples gaussianas los cuales determinan el número de emisores y localizan las emisiones electromagnéticas en la imagen RF.

Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 6, CARACTERIZADO porque superponen la imagen visual con la detección RF y ponen marcadores en los lugares de emisión.

REIVINDICACIONES MODIFICADAS recibidas por la oficina Internacional el 30 de mayo de 2018 (30.05.2018)

Un dispositivo de detección de emisiones electromagnéticas y visibles, CARACTERIZADO porque comprende un arreglo plano de antenas (10) que se presentan como un arreglo de fases (1 ) dispuestas en el frente superior del dispositivo, que a través de un barrido de haz de alta velocidad captura las señales de radiofrecuencia (RF) de las superficies de escaneo, donde el arreglo de fases (1 ) es capaz de sintetizar un haz de radiación directivo, al que se le puede controlar su forma y dirección de manera eléctrica; donde cada antena es capaz de cambiar la amplitud y fase cooperando para generar el haz de radiación directivo; donde la señal de radiofrecuencia capturada es procesada por la electrónica de alta frecuencia (2), que comprende en una tarjeta de circuitos impresos (PCB) o placa: N x N desfasadores (3) conectados a las antenas que cambian la fase relativa de las ondas electromagnéticas recibidas, tales como las señales de radiofrecuencia (RF), donde la salida de cada uno de los N x N desfasadores (3) es combinada (14) en fase generando una salida única del haz sintetizado, esta señal es amplificada (1 1 ) y filtrada (12), restringiendo y purificando la señal, para llegar a un detector de potencial total (4) donde se detecta la potencia total de la señal de radio frecuencia (RF) como un voltaje analógico, la cual es a su vez convertida en una señal digital por medio de un conversor análogo digital (5); además sobre el arreglo de fases (1 ) se ubica con la misma dirección focal una cámara de video (13) que obtiene una imagen visual; también el dispositivo presenta un microcomputador (6) que: por una primera parte se encarga del control y sincronización del arreglo de antenas, desfasadores, amplificadores y filtros para construir la imagen de radiofrecuencia (RF), que se post-procesa ubicando la localización de las emisiones de radiofrecuencia (RF), por una segunda parte, se encarga de superponer las imágenes obtenidas por la cámara con las imágenes de radiofrecuencia (RF) y mostrarlas en la pantalla (8) y por una tercera parte, se encarga ejecutar el algoritmo que permite la interfaz del dispositivo con el usuario; un suministro de poder (7) autónomo para energizar todas las piezas mencionadas previamente; y una carcasa que envuelve todas las piezas (9), para que el dispositivo sea compacto y portable.

2. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 1 , CARACTERIZADO porque el arreglo de antenas (10) comprende entre 64 a 4 antenas, de preferencia 16 antenas o elementos radiantes ordenados de forma matricial, que además son capaces de detectar múltiples bandas en el rango de frecuencia de emisión de dispositivos móviles, en el rango de frecuencia de los dispositivos móviles y/o Wifi, tal como las bandas de entre los 700-900MHz, 1700-2100 MHz, 2400- 2700 MHz y 5000 MHz.

3. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con las reivindicaciones 1 y 2, CARACTERIZADO donde la síntesis de un haz de radiación en una dirección arbitraria mediante del arreglo de fases (1 ), está acotada a 90x90 grados.

4. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 1 , CARACTERIZADO porque la cámara de video (13), es digital y muestra el área en la cual se desea detectar señales de radiofrecuencia (RF).

5. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 1 , CARACTERIZADO porque el microcomputador (6) envía señales de control que permiten cambiar la fase de cada uno de los desfasadores (3) comprendidos en la placa de electrónica de alta frecuencia (2), donde además es capaz de sincronizar la adquisición de las imágenes ópticas y de radiofrecuencia con dichas señales de control. Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 1 , CARACTERIZADO porque el minicomputador (6) en su post procesamiento para ubicar la localización de las emisiones de radiofrecuencia (RF), utiliza algoritmos de detección de múltiples gaussianas los cuales determinan el número de emisores y localizan las emisiones electromagnéticas en la imagen de radiofrecuencia (RF).

Un dispositivo de detección de emisiones electromagnéticas y visibles, de acuerdo con la reivindicación 1 , CARACTERIZADO porque superponen la imagen visual captada por la cámara de video con la detección de la radiofrecuencia (RF) y ponen marcadores en los lugares de captura de la radiofrecuencia (RF).

Description:
DISPOSITIVO DE RADIOVISIÓN

Campo de aplicación

El campo de aplicación del presente dispositivo, comprende aplicaciones industriales en el rescate de personas atrapadas en avalanchas de nieve o edificios colapsados y la detección y medición de emisiones electromagnéticas de fuentes eléctricas o dispositivos móviles en lugares donde no está permitido su uso, como cárceles o aviones. Por otro lado, esta invención está relacionada con la detección y localización de fuentes RF (Radio Frecuencias) en el rango de telefonía celular y la superposición en una imagen visual en tiempo real.

Descripción del estado del arte previo

En general el estado del arte menciona en particular varias patentes que protegen no un sistema físico particular sino un conjunto de dispositivos y métodos que permiten una funcionalidad particular.

Existen una serie de documentos los cuales caen dentro del campo general de las antenas tales como: EP 0 938 156, EP 0 144 867, US 2015/0022421 , WO 2016/089464, WO 201 11\ 48248.

Por otro lado, existen una serie de patentes relacionadas del campo del presente desarrollo mencionadas a continuación:

EP 0 887 879: Esta patente cae dentro del campo del presente desarrollo y pretende disminuir el tamaño total de una disposición en fase de alta ganancia. Esto se logra utilizando una estructura multicapa donde los desfasadores son acoplados a las antenas, eliminando el ruteo a ellas. Este dispositivo da una nueva morfología de la disposición en fase.

EP 1 921 709: Esta patente corresponde a un sistema capaz de generar un haz doble sin lóbulos de rejilla (grating lobes). También da hincapié a que es un módulo compacto y completo para sintetizar hazes.

US 7,602,337 B2 (EP2100347): Esta patente corresponde a un disposición en fases emisoras, y los algoritmos que la controlan. Este dispositivo centra su inventiva en su morfología, pero además en sus algoritmos y software.

EP 2 463 958: Esta patente corresponde a un arreglo compacto de antenas multi-hazes que optimiza las conexiones sin cable dentro de un recinto cerrado. El arreglo en sí la innovación pues optimiza un diseño antiguo llamado "Van-Atta".

US 6,504,510, EP1294163, US2015/0022421 : Esta patente corresponde a una disposición de fases para telecomunicaciones móviles. El arreglo es de M x N, pero solo necesita M+N desfasadores para su funcionamiento, pues utiliza además divisores selectivos de potencia. Con esto es capaz de hacer "el control de tres caminos de hazes" (Mover el haz en el azimuth y la elevación).

US 6,693,590 B1 , EP1 195017: Esta patente corresponde a una disposición de fases que utiliza ADCs para implementar desfasadores digitales. Para esto utilizan una conversión reductora a IF. Después la señal es combinada digitalmente. Esto es muy poco eficiente para grandes anchos de banda.

PCT/FI2014/050067, EP2951 1884: Esta patente está ligada integración de un arreglo de antenas con sistemas de telecomunicaciones actuales minimizando recursos (cableado) y tamaño. Además de optimizar la recolección de "signal data".

WO 2008/082917: Esta patente corresponde a una serie de métodos y dispositivos para optimizar o mejorar la formación del haz sintetizado por una disposición de fases.

US 2009/0102716: Esta patente corresponde a un sistema con aplicaciones para radares y telecomunicaciones que utiliza un haz para entregar potencia y datos de control.

US 2009/0027267: Esta patente corresponde a un reflector de fase variable, la idea es que iluminar el reflector con una bocina y a través de control de fase del reflector cambiar la dirección del haz. El reflector está compuesto por un arreglo de elementos que incluyen entre otros elementos varactores.

US 2016/0087349: Esta patente corresponde a un método para controlar el ancho del haz para una banda específica y también para multibanda. El diseño utiliza un prototipo de antena de 4x4 donde antenas de banda simple y multibanda fueron colocadas en ubicaciones específicas dentro del arreglo.

US2008/0106467: Esta patente corresponde a una disposición de fases montada completamente sobre un sustrato multicapa, con toda la electrónica correspondiente en él, a su parte trasera. Todo esto de forma compacta donde el tamaño del dispositivo solo queda limitado por el tamaño del sustrato. Este sistema funciona en ambas direcciones. US 2015/0316641 : Esta patente corresponde a un trasmisor para radares con múltiples salidas, las cuales se puede controlar en fase. Este transmisor está integrado en un solo chip. Además posee un generador RF.

El dispositivo más cercano del estado del arte al presente desarrollo, es la patente EP 2 246 934 A1 . Esta patente cae dentro del campo técnico del presente desarrollo y es capaz de detectar y seguir con emisiones activas la dirección de movimiento de paquetes (objetos movibles) utilizando una etiqueta RFID en ellos. Utilizan un arreglo de 2 x 2 elementos, además aseguran que es compacto. Su aplicación está centrada en manejo de inventario mediante tag RF. Requiere de un computador externo para operar. Se protege el dispositivo y los métodos asociados.

Problemas técnicos que resuelve la presente invención

Como poder generar una imagen integrada en tiempo real basadas en longitudes de ondas de la radiofrecuencia y en el campo del visible, sin excluir otros campos, tales como: el infrarrojo cercano y lejano, el ultravioleta cercano y lejano.

Como poder generar un dispositivo manual, auto-sustentado y portátil que posea la capacidad de generar las imágenes previamente mencionadas.

Como poder localizar las fuentes de emisión de radiación de forma pasiva.

Para poder responder a los problemas técnicos previamente planteados, en general, el presente desarrollo incluye: • La generación de una imagen RF a tiempo real.

• La utilización de algoritmos de detección de curvas gaussianas para localizar la dirección de las fuentes de radiación.

• La utilización de una imagen de video óptica para posicionar la fuente de la radicación en el campo visual mediante la superposición de marcadores que identifican los máximos de radiación de radio.

• El conjunto de dispositivos y métodos que permite la operación de forma portable y autónoma.

Descripción general de la invención

El presente desarrollo corresponde a un sistema, auto-energizado, compacto y portable que permite la detección y localización de emisiones electromagnéticas en el espectro utilizado por dispositivos móviles (teléfonos celulares y dispositivos Wi-Fi/Bluetooth) a tiempo real. El principio de detección y localización está basado en la tecnología de arreglos de fase, la cual permite la síntesis de un haz de radiación directivo, al que se le puede controlar su forma y dirección de manera eléctrica, por lo que no posee elementos móviles mecánicos. Estos mecanismos son usados principalmente en aplicaciones militares y astronómicas. El dispositivo incluye además algoritmos de localización y control. Este dispositivo permitirá la detección y localización de emisiones electromagnéticas mediante un barrido del haz de la antena en un campo de visión de 80 x 80 grados. Una vez ocurrida la detección y localización, esta es superpuesta en una imagen visual captada por una cámara de video.

El dispositivo es completamente pasivo, no emite radiación electromagnética en la bandas de detección para su funcionamiento.

Debe entenderse que la presente invención no está limitada a la metodología particular, compuestos, materiales, técnicas de manufactura, usos y aplicaciones aquí descritas, pues éstas pueden variar. También debe entenderse que la terminología empleada aquí es usada con el solo propósito de describir una representación particular, y no intenta limitar la perspectiva y el potencial del presente invento.

Debe notarse que el uso y método, aquí, en el pliego de reivindicaciones y en todo el texto que el singular no excluye el plural, salvo que en el contexto claramente lo implique. Entonces, por ejemplo, la referencia a un "uso o método", es una referencia a uno o más usos o métodos e incluye equivalentes conocidos por quienes conocen de la materia (el arte). Similarmente, como otro ejemplo, la referencia a "un paso", "una etapa" o a "un modo", es una referencia a uno o más pasos, etapas o modos y que puede incluir sub pasos, etapas o modos, implícitos y/o sobrevinientes.

Todas las conjunciones usadas han de entenderse en su sentido menos restrictivo y más inclusivo posible. Así, por ejemplo, la conjunción "o" debe entenderse en su sentido lógico ortodoxo, y no como un "o excluyente", salvo que el contexto o el texto expresamente lo necesite o indique. Las estructuras, materiales y/o elementos descritos han de entenderse que también se refieren a aquellos equivalentes funcionalmente y así evitar enumeraciones taxativas interminables. Las expresiones usadas para indicar aproximaciones o conceptualizaciones deben entenderse así, salvo que el contexto mande una interpretación distinta.

Todos los nombres y términos técnicos y/o científicos aquí empleados tienen el significado común que le otorga una persona común, calificada en estas materias, salvo indicación expresa, distinta.

Los métodos, técnicas, elementos, compuestos y composiciones son descritos aunque métodos, técnicas, compuestos y composiciones similares y/o equivalentes a los descritos pueden ser usados o preferidos en la práctica y/o pruebas de la presente invención.

Se incorporan todas las patentes y otras publicaciones como referencias, con el propósito de describir y/o informar, por ejemplo, las metodologías descritas en dichas publicaciones, que puedan resultar útiles en relación con el presente invento.

Se incluyen estas publicaciones sólo por su información previa a la fecha de registro de la presente solicitud de patente.

A este respecto nada debe considerarse como una admisión o aceptación, rechazo o exclusión, de que los autores y/o inventores no estén legitimados de serlo, o de estar ante-fechadas dichas publicaciones en virtud de otras anteriores, o por cualquier otra razón. Para aportar claridad al presente desarrollo se definirán los siguientes conceptos:

Antenas: Son elementos capaces de emitir o recibir radiación electromagnética.

Radiación direccional: Una antena no siempre emite o recibe en todas las direcciones. Existen varios tipos de antenas donde es posible concentrar la potencia irradiada en una dirección privilegiada. El parámetro que mide esto es conocido como la ganancia de antena.

Arreglos de fase: Corresponde a un arreglo de antenas distribuidas espacialmente sobre un plano. Cambiando la amplitud y fase de cada una de las antenas que conforman es posible sintetizar un haz de radiación directivo en una dirección específica.

Electrónica de alta frecuencia: Son elementos eléctricos que funcionan en frecuencia de microondas. Estos elementos difieren de los elementos electrónicos convencionales debido a que ya no se tratan como elementos de parámetros concentrados, sino que con parámetros distribuidos, es decir la posición y distancia entre ellos afecta su comportamiento final.

Señal de radio frecuencia: Es una señal que posee una frecuencia en el espectro de radio y microondas. Para el presente desarrollo se trabaja en señales del orden de Gigahertz. Barrido del haz a alta velocidad: Corresponde al barrido realizado por al arreglo de fase, el cual se realiza sobre toda las superficie de escaneo y en donde se captura la señal de radio frecuencias. Un equivalente general de este barrido es el funcionamiento de las televisiones de rayos catódicos.

Señal de voltaje analógico: Son señales del voltaje continuas que pueden tomar cualquier valor dentro de su rango de funcionamiento. En las señales digitales en cambio existen solamente dos niveles de voltaje para representar 0 y i -

Antenas de microcinta: Es un tipo de antena de microondas que puede ser montada sobre una superficie plana. Estas antenas son de fácil construcción y en un rectángulo plano de metal montado sobre un plano a tierra separado por una capa de un material dieléctrico.

Descripción detallada de la invención

El dispositivo corresponde a un sistema de detección y localización que se basa en el principio de funcionamiento de la tecnología de arreglos de fase. Esta tecnología permite poder sintetizar un haz de radiación direccional a través de múltiples elementos radiantes (antenas) no direccionales. Este haz de radiación es capaz de recibir y emitir radiación electromagnética. El ancho del haz sintetizado está definido por la separación que existe entre los elementos radiantes individuales. Es posible cambiar la dirección del haz mediante un cambio en la fase de cada uno de los elementos individuales. Para un arreglo lineal de antenas, el cambio de fase entre cada uno de los elementos contiguos del arreglo va dado por la por la ecuación 1 . Donde d es la distancia entre los elementos, λ es la longitud de onda de la señal electromagnética y e 0 es el Angulo que se desea girar el haz. El cambio en la dirección del haz se muestra en la figura 1 /10?. Ecuación 1

Si las antenas se ordenan en un arreglo bi-dimensional, sin restringir otro tipo de ordenamientos, es posible controlar la dirección del haz en dos dimensiones. El cambio en la dirección del haz estará regido ahora por dos ángulos y su cambio de fase está dado por la superposición en dos ejes.

La presente solicitud puede usar un amplio rango de arreglos de antenas, sin excluir ninguna cantidad, un rango de preferencia es el rango de las 64 antenas a un mínimo de 4 antenas, de preferencia 16 antenas. Un arreglo de 4 antenas permite imágenes bidimensionales. En general la variación en el número de elementos afectara la calidad de haz sintetizado, un número mayor de elementos produce una disminución en los lóbulos laterales del haz y la separación entre ellos afecta el ancho del mismo haz.

Para realizar la detección se realiza un barrido del haz a alta velocidad del área que se desea observar, esto permite la creación de una imagen de emisiones electromagnéticas, de preferencia en el rango de los dispositivos móviles y Wifi (fidelidad inalámbrica), específicamente en las bandas 700- 900MHz, 1700-2100 MHz, 2400-2700 MHz y 5000 MHz, las cuales posteriormente son superpuestas con una imagen visual digital obtenida mediante una cámara de video. El campo de visión máximo que se pretende observar con esta invención es de 90 x 90 grados.

Dada la naturaleza de la tecnología y la incertidumbre en la intensidad de potencia de la fuente a detectar y localizar, no es posible medir la distancia que existe al objeto emitido, por lo que la detección solo se puede realizar en dos dimensiones en forma instantánea, lo cual significa que la detección se hace sobre la imagen 2D en el plano XY, donde Z seria la profundidad. Es posible hacer una estimación de la distancia máxima de la fuente, más no una medición de la distancia absoluta.

El esquema mostrado en la figura 2/10 muestra los diferentes componentes del dispositivo, descritos a continuación:

(1 ) Arreglo plano de antenas: El arreglo de antenas corresponde a un rango entre los 64 y los 4 elementos radiantes individuales, estos elementos tiene la capacidad de recibir la emisión electromagnética de todas las bandas que se desean detectar (antenas multi-banda, de manera similar a los celulares). Estos elementos están posicionados en diferentes formas con el fin de mejorar la calidad del haz sintetizado, de preferencia se utiliza una distribución regular de elementos equidistantes, tal como en una forma matricial, en una forma circular, entre otras, como se muestra en la figura 3/10. El arreglo de antenas es lo suficientemente compacto para ser parte de un dispositivo portable.

(2) Electrónica de alta frecuencia: La electrónica de alta frecuencia está integrada en una serie de PCBs (Printed Circuit Board). La figura 4/10 detalla la electrónica incluida en el dispositivo.

A continuación se detalla cada grupo de elementos:

Los desfasadores (3) que están en la misma relación a la cantidad de arreglos planos de antenas, van conectados con cada uno de los elementos radiantes del arreglo de antenas (1 ). Estos se encargaran de cambiar la fase relativa de las ondas electromagnéticas recibidas.

A la salida de cada uno de los desfasadores (3) es combinada (14) en fase para generar una salida única con la información del haz sintetizado. La señal después es amplificada análogamente (1 1 ) con un amplificador de bajo ruido y es filtrada opcionalmente de forma análogacon filtros para esa banda (12), para llegar a un detector de potencia total (4), el cual convierte la señal de radio frecuencia en un una señal de corriente directa (DC), esta última es convertida en una señal digital mediante un A/DC (5) (Conversor análogo digital).

La cámara de video (13) se encarga de captar la imagen óptica en la cual se muestran las fuente de radiación electromagnética detectadas. La cámara es de preferencia, una cámara digital con una resolución superior a 640x480 pixeles.

La posición de esta cámara de video puede ser superior a la zona donde están las antenas, puede estar colocado de manera inferior o colocada en el centro entre las antenas, donde al estar en el mismo eje de simetría del arreglo de antenas, simplifica el algoritmo que superpone la imagen de radio sobre la imagen óptica.

(6) El microcomputador: cumple una serie de funciones importantes, donde la primera es el control y sincronización del arreglo (1 ), enviando señales eléctricas a cada uno de los desfasadores (3) y de esta manera se puede sintetizar el haz de radiación en la dirección deseada. El microcomputador (6) se encarga de recibir y procesar la señal que viene del detector (4) y de esta forma se construye la imagen RF. Esta imagen es posteriormente post procesada para encontrar la localización de las emisiones de radiofrecuencias. El algoritmo de post procesamiento incluye un detector de gaussianas. Las detecciones son después superpuestas con la imagen proveniente de la cámara de video y son mostradas en la pantalla. El microcomputador (6) se encarga además de ejecutar el programa que permite la interfaz con el usuario.

(7) El suministro de poder: permite que el sistema tenga autonomía propia, energizando la electrónica de radiofrecuencias, la cámara y el microcomputador con su pantalla (8).

(9) Cascara de protección del sistema: todo el sistema está envuelto en un formato tipo cascara que contiene todos los componentes antes

mencionados.

El algoritmo mencionado previamente presenta el siguiente código fuente:

from rv.core ¡m port Core

¡f ñame == ' main ' :

logg¡ng.bas¡cConf¡g(f¡lename=' radiovision.log', format='%(asct¡me)s:%(levelname)s:%(message)s' ,level=logg¡ng. lNFO, datefmt='%m/%d/%Y%l:%M :%S%p')

Core().stuff()

This class ¡nitializae the GUI and controls the aqusition of f rames class Core(object):

def ¡nit (self):

self .cam = camera. Camera().start()

# Load markers ¡mages

¡m port os # th¡s allows to lunch t he project from any where

current_path = os.path .dlrname( file ) # and access the data

self .marker 1 = ¡m read(current_path + 7 markers/ marker_1 .png' , -1 ) self.marker_2 = ¡mread(current_path + 7markers/marker_2.png', -1)

self.marker_3 = imread(current_path + 7markers/marker_3.png', -1)

self .markers = [self .marker l , self .marker_2, self .marker_3]

# Rrst frame

# ¡mshow('Rad¡oV¡s¡on', self .cam .read())

# sync elements

# self.marker posltlon = Array('¡',2* number_of_gausslans_toJlt)

self.marker queue = JoinableQueue(l)

self.rf scan queue = JoinableQueue(IO)

self.new accjen = Value('¡',10)

self.rf scan = rv.array.Array(31 , 31 , self .rf scan queue, self .new accjen)

self.marker flt = rv.detectlon.detect.Detect(31 , 31 , self.marker queue, self.rf scan queue)

# mlnlmun amplitud valué

self.amp error =1e-6

# capture plctures loop

self. capture = True

self .vldeo_thread = threadlng.Thread(target=self .start_all)

self.add_plp = False

#GUI3uff

self Job = None

self.root = tklnter.Tk()

self. root.geometry(" 400x225")

self. rool. prolocol(" WMJDELETE J/VINDOW", self .on closlng)

self .button frame = tklnter.Frame(self .root, wldth=100)

self. button frame. pack propagate(O)

self. button frame. pack(flll='y', slde=tklnter.LEFT)

self .video frame = tklnter.Frame(self.root)

self .video frame. pack(flll=tk¡ nter.BOTH, slde=tklnter.LEFT)

self .vldeo_dlsplay = tklnter.l_abel(self .vldeoJrame)#, helght=225, wldth=300)

self .vldeo dlsplay.pack(flll=tklnter.BOTH, s¡de=tk¡nter.LEFT)

self.button plp = tklnter. Button (self. button frame, text=' PIPOFF, command=self.button_p¡p_act¡on_on, helght=3) self.button_plp.pack(flll='x')

self.button_acc_reset = tklnter. Button(self. button frame, text='Reset AOC,helght=3,command=self.reset_acc) self.button_acc_reset.pack(flll='x')

tklnter.l_abel(self. button Jrame,text="AccSze").pack() self .acc length = tklnter.£cale(self.button frame, from_=1 , to=100, or¡ent=tk¡nter. HORIZONTAL, command=self.updateValue) self.acc_length.pack(fill='x')

self.acc_length.set (10)

self.root.bind("«close_m e»",self.last_close)

self.plcture_scalej_w = 640/480.0

self.close_mutex = threading.Lock()

self .close_cond = threading.Condition()

self.maln loop_closed = False

def get_picture_size(self):

wldth O = self.root.wlnfo_wldth() - self.button acc reset.wlnfo_wldth()

helgth O = wldth O / self.plcture_scalej_w

helgth 1 = self.root.wlnfo helght()

wldth 1 = heigth_1*self.picture_scale_h_w

# pr¡nt('s',w¡dth_0, heigth O)

# pr¡nt('e',w¡dth_1 , heigth l)

if heigth O <= heigth l :

return int(width O), int(heigth O)

return ¡nt(w¡dth_1 ), int(heigth_1 )

def reset_acc(self):

logging.debug('reset')

self.rf_scan.new_acc()

def updateValue(self, event):

if self.Job:

self. root.after cancel (self. Job)

self.Job = self.root.after(500, self._do_somethlng)

def _do_somethlng(self):

self.Job = None

logglng.debug("new valué:" + str(self.accjength.get()))

self.new accjen.value = self.accjength.get()

se I f . r f sean . n ew accj e n ( )

def button plp actlon on(self):

self.add_plp = True

self. button_plp.conflgure(text=' PIPON')

self.button_plp.conflgure(command=self.button_plp_actlon_off )

def button plp actlon off(self): self.add_p¡p = False

self.button_p¡p.conf¡gure(text='PIPOFF)

self.button_pip.configure(command=self.button_pip_actlon_on) def on closlng(self):

self. capture = False

def stuff(self):

self.v¡deo_thread.start()

self.root.mainloopO

def start_all(self):

# start array data and fit

self.rf_scan.start()

# self.marker_fit.act¡vate_plot()

self.marker_fit.start()

#the rest of the programm

# initial valuesfor the positionsof the markers

markers coords = None

update_counter = 0

dlsplay_color_map = None

import cv2

picture_wide = 300

picture_heigth = int(picture_wide * self.plcture_scale_h_w) time.sleep(l)

while self. capture:

frame = self.cam.read()

# draw a rectangle over the ¡mage

drawrect(frame, (100, 20), (540, 460), (0, 0, 0), 3, style='else') drawrect(frame, (100, 20), (540, 460), (0, 255, 255), 1 , style='else')

# if queue hastask

while not self.marker_queue.empty():

[markers, data] = numpy.array( self.marker queue.getO) self.marker_queue.task_done()

# extend the data

y = numpy.arange(0, 31 , 1)

x = numpy.arange(0, 31 , 1)

f = interpólate. interp2d(x, y, data, kind='cublc') d¡splay_color_map = f (num py.arange(0, 30, 0.3),num py.arange(0, 30, 0.3)) # Update markers

markers coords = stretch_coords(markers, self .markers)

¡f markers coords ¡s not None and len(markers coords) > 0:

self .pa¡nt_markers(frame, markers_coords ,markers[2])

¡f d¡splay_color_map ¡s not None and self .add_p¡p:

frame = self .add_p¡cturejn_p¡cture(frame, d¡splay_color_map) frame aux = ¡m ut¡ls.res¡ze(frame, w¡dth=p¡cture_w¡de, helght=p¡cture helgth) p¡cture_w¡de,p¡cture_he¡gth = self .get_p¡cture_s¡ze()

¡mage = cv2.cvtColor(frame_aux, cv2.COLOR_BGR2RGB)

¡mage = Image.fromarray(image)

try:

¡mage = ImageTk.Photolmage(image)

except Runt imeError as e:

break

self . v¡deo_d¡splay.conf¡gure(¡mage=¡m age)

self .v¡deo_d¡splay.¡mage = ¡mage

# ¡f update_counter > 1000:

# print('none')

# markers_coords = None

# update_counter = 0

# d¡splay_color_map = None

# update_counter += 1

logg¡ng.¡nfo('core closing')

self .clos¡ng()

def add_plcturejn_p¡cture(self , frame, data):

# convert the data to uint scale from 0 to 255

# as ¡f ¡t was a gray scale ¡mage

max_value = num py.max(data)

data /= max_value

# th¡s ¡s have a better dlstribut ion of colors

data * = 255

data = data.astype(num py.ulnt8)

# genérate the color ¡mage # ¡t must be u¡nt8 data type to work

data_colormap = cv2.applyColorMap(data, cv2.COLORMAP_JET)

[frame_x, frame_y, a] = frame.shape

[p¡p_x, p¡p_y, a] = data_colormap.shape

frame[frame_x - p¡p_x:frame_x,frame_y-p¡p_y:frame_y,:] = data_colormap

return frame

def closing(self):

logg¡ng.¡nfo('Clos¡ng objects...')

self.cam.stopO

self.rf_scan.shutdown()

self .marker f¡t.shutdown()

t¡me.sleep(5)

while self.cam.thread_update.¡sAI¡ve():

pass

self.root.event_generate("«close_me>>", when="ta¡l")

logg¡ng.¡nfo('** Camera Closed **')

def last_close(self, *args):

self.root.destroy()

def pa¡nt_markers(self, frame, marker cords, markers_amp):

# pr¡nt('detected amplitudes: ', markers_amp)

max_amp = max(markers_amp)

max_ampl¡tud_rat¡on = 0.1

font = cv2.FONT HERSHEY PI_AIN

constante= 1.0

d¡stance_funt¡on = lambda power: str(power) + 'APU'

draw distance = lambda_ampl¡tud, Mx, My: cv2.putText(frame, d¡stance_funt¡on(_ampl¡tud), (Mx, My), font, 1 , (0, 255, 255),)

draw_d¡stance_back = lambda_ampl¡tud, Mx, My: cv2.putText (frame, d¡stance_funt¡on(_ampl¡tud), (Mx, My), font, 1 , (0, 0,),2)

ampl cont = 0

for M 1 y,M 1 x ¡n marker cords:

for c ¡n range(0, 3):

# paint the markers

¡f markers_amp[0] < max_ampl¡tud_rat¡on* max_amp:

pass

else: try:

frame[M 1 y:M 1 y + self .markers[2].shape[0], M 1 x:M 1 x + self .markers[2].shape[1 ], c] = \ self.markers[2][:, :, c] * (self.markers[2][:, :, 3] / 255.0) + frame[M 1 y:M 1 y + self.markers[2].shape[0],

M1x:M1x + self.markers[2].shape[1],c] * (1.0 - self .markers[2][:, :,3]/ 255.0)

draw_distance_back(markers_amp[ampl_cont],M 1x,int(M 1y+self.markers[2].shape[0]/3))

draw_dlstance(markers_amp[ampl_cont],M 1 x,int(M 1 y+self .markers[2].shape[0]/3))

except Exception ase:

pass#prlnt('marker 1 error' + str(e))

ampl cont += 1

class Camera:

def init (self, src=0):

# USB camera handler

self.stream = cv2.V¡deoCapture(src) # Don't leave VideoCapture argument empty

self.grabbed, self. frame = self.stream.read() # Read flrst frame

# Data flow control variables

self.stopped = False

# Thread handler

self .thread_update = threadlng.Thread(target=self. update, args=())

# self.thread_dlsplay = threadlng.Thread(target=self.dlsplay, args=()) # Commented due to welrd behavior def start(self):

self.thread_update.start()

# self .thread_dlsplay.start()

return self

def update(self):

whlle self.stream.lsOpened():

¡f self.stopped:

return

self.grabbed, self. frame = self.stream.read()

self.stream.release()

def dlsplay(self): # Currently not ¡n use

cv2.lm show ('Radiovisión', self .frame)

whlle True:

¡f self.stopped:

return

cv2.lm show ('Radiovisión', self .frame)

def read(self): return self.frame

def stop(self):

self.stopped = True

class Array(Process):

def init (self, size_x,size_y, queue, accjen):

super(Array, self). init ()

x = numpy.linspace(0, slze x-1 , slze x)

y = numpy.linspace(0, size_y-1 , size_y)

self.domain = numpy.meshgrld(x, y)

self .Power = [] # the vector versión of the measuremente self .Z= [] # the matrix versión of the measuremente

# sincronize elements

self. queue = queue # passthe markersto the other process self.stop_event = Event()

self .new acc event = Event()

self .new acc len event = Event()

self . M Y SOCK PATH = "/home/pl/comunicatlon" self.sock = socket. socket(socket.AF UNIX, socket. SOCK STREAM) self.max hold = numpy.zeros((slze_x,s¡ze_y))

self.number acc = 10

self.current_acc = 0

self .new acc Index = 0

self. accjen = accjen

self .max hold = numpy.zeros((self.number_acc, slze x, slze y)) try:

self. sock.connect (self. MY SOCK PATH )

except socket. error asmsg:

sys.stderr.wrlte("bad conectlon")

#sys.exlt(1)

def change_accjength(self, new accjength):

¡f new acc length > 0:

self.number acc = new accjength

def reset_acc(self):

a,b,c = self.max_hold.shape

self.max_hold = numpy.zeros((self.number_acc, b, c)) self.new_acc_event.clear()

def change_acc_len(self):

# pr¡nt(self.max_hold.shape, self.new accjndex)

length, b, c = self.maxjiold.shape

new a = self.accjen.value

new max hold = numpy.zeros((new a, b, c))

if self.number acc >= new a:

backjndex = self.new accjndex - new a

¡f backjndex < 0:

tmp = backjndex

backjndex = 0

new_max_hold[0:abs(tmp),:,:] = self .max_hold[length + tmp:length,:,:]

new_max hold[abs(tmp):new a,:,:] = self .max hold[back I ndex:self.new acc Index,:,:] else:

new_max hold[0:new a, :, :] = self .max hold[back lndex:self.new_acc Index, :, :] self .new acc Index = 0

else:

new_max hold[0:(length - self .new acc Index),:,:] = self .max hold[self .new acc Jndex:length,:,:] new_max hold[(length - self.new acc ¡ndex):length, :, :] = self .max hold[0:self.new acc Index, :, :] self .new acc Index = length

self .max hold = new_max hold.copy()

self.number acc = new a

# prlnt(self.max_hold.shape)

# prlnt(self.new accjndex)

self . n ew accj en event . el ear ()

def get_scann(self):

self.sock.sendall(b'scann\n')

n = 0

recleve_data = b"

whlle n < 31*31*8:

recleve_data_aux = self.sock.recv(31*31*8)

recleve_data += recleve_data_aux

n += len(recleve_data_aux)

recleve_data = unpack('<' + str(31*31) + 'd', recleve_data)

recleve_data = array(recleve_data) return numpy.reshape(rec¡eve_data,(31 ,31))

def sweep_once(self):

self.logging_info( 'New measure...')

t = time.time()

magnitudeMat = self.get_scann()

tf = time.time()

self.loggingJnfo('Elapsed : ' + str(tf - 1) + ' seconds')

# magnitudeMat = 10** (magnitudeMat/ 10.0)

self .max_hold[self .new accjndex,:,:] = magnitudeMat self .new accjndex = (self. new acc Índex + 1) %self.number_acc self.current_acc+= 1

self. Power = numpy.max(self.max_hold, axis=0)

def shutdown(self):

self. stop_event. set()

def new acc(self):

se I f . n ew_acc_even t . set ( )

def new accjen(self):

self.new_accjen_event.set()

def logglngJnfo(self, msg):

logging.info('[Array] ' + msg)

def run(self):

self.logglng Jnfo('3art array.')

while 1 :

if self.stop_event.is_set():

self.logglng Jnfo('3opping array.')

return

# do one scann

if self.new_acc_event.ls_set():

self.reset_acc()

if self .new accjen event.¡s set():

self.change_acc_len()

self.sweep_once()

try:

# passthe sean to flt gaussians

self. queue.put (self. Power, block=True,t¡meout=0.5) except Ful I :

# the queue is full

self.loggingJnfo('&an drop.')

def drawl¡ne(¡mg, pt1 , pt2, color, thlckness=1 , style='dotted', gap=20): dlst = ((pt1[0] - pt2[0]) ** 2 + (pt1[1] - pt2[1]) ** 2) ** .5 pts=[]

for I ln np.arange(0, dlst, gap):

r = I / dlst

x = int((pt1 [0] * (1 - r) + pt2[0] * r) + .5)

y = int((pt1[1] * (1 - r) + pl2[1] * r) + .5)

p = (x. y)

pts.append(p)

lf style == 'dotted':

for p ln pts:

cv2.clrcle(lmg, p, thlckness, color, -1)

else:

e = pts[0]

I = 0

for p ln pts:

s = e

e = p

¡f I %2 == 1:

cv2.llne(lmg, s, e, color, thlckness)

I += 1

def drawpoly(lmg, pts, color, thlckness=1 , style='dotted', ):

e = pts[0]

pts.append(pts.pop(0))

for p ¡n pts:

s = e

e = p

drawllne(lmg, s, e, color, thlckness, style)

def drawrect(lmg, pt 1 , pt2, color, thlckness=1 , style='dotted'): pts= [pt1, (pt2[0], pt1[1]), pt2, (pt1[0], pt2[1])]

drawpoly(lmg, pts, color, thlckness, style)

def stretch_coords(fltted_coords, punteros): This functions handles the coordínate

transmfrmation to fit the image

new_coordlnates = []

# return new coordinates

# px = [-0.00000970378811294236, 0.00208172113150949, -0.153201441654720, 8.43103861597864, 118.848944819314]

# py = [-0.0000442788139443627, 0.00320074167604714,0.104246823935828, -6.04649560143571 , 199.899107062199] #ypix[0] = np.polyval(py, fitted_coords[1][0]*3)

#ypix[1] = np.polyval(py, fitted_coords[1][1]*3)

#ypix[2] = np.polyval(py, fltted_coords[1][2]*3)

#xpix[0] = np.polyval(px, fitted_coords[0][0]*3)

#xpix[1] = np.polyval(px, fitted_coords[0][1]*3)

#xpix[2] = np.polyval(px, fltted_coords[0][2]*3)

x_offset = 20

x_scale_factor = int(440/31)

y_offset = 100

y_scale_factor = int(440 / 31)

punterol =punteros[0]

for cont in range(len(fitted_coords[0])):

xp = int(fitted_coords[0][cont] * x_scale_factor + x offset)

xp -= int(puntero1.shape[0] / 2)

yp = int(fitted_coords[1][cont] * y_scale_factor + y offset)

yp -=int(puntero1.shape[1] / 2)

new_coordinates.append((xp,yp))

return new coordinates

class DetectGaussias(object):

def init (self, number_sample_po¡nts=150, alfa = 0.05):

This class detectsan unknow number of gausslans.

Keyword arguments:

number_sample_po¡nts - number of samplingsto get form the data (default 200) self.sample_data = ResampleData()

self.get_covar_mean = EstimateMeanCovariance(alfa)

self.number_sample_polnts = number_sample_polnts

self .density_threshold = 0.6 # 0.05and aporiximatlon considering 20 points ¡n a circunsfere wiht a radius of 20 with no p¡ self. mínimum área = 7 self.alfa = alfa

def sample_from_data(self, data):

samplejndex = numpy.zeros([self.number_sample_polnts, 2]) for cont ¡n range(self.number_sample_polnts):

¡ndy, ¡ndx = self.sample_data.sample_data(data) sample_lndex[cont, 0] = ¡ndy

sample_¡ndex[cont, 1] = ¡ndx

cont += 1

¡f cont == self.number_sample_polnts:

break

return samplejndex

def get_b¡c(self, cluster, means=[], covars=[]):

Thisfunctions calculates the bayeslan ¡nformatlo crlterlon for a set of set of polnts

cluster -- set of polnts

(d,) = cluster[0].shape

mean = numpy.zeros((d,))

total = 0

# for cluster ¡n clusters:

for polnt ¡n cluster:

mean += polnt

total += 1

mean /= total

covar = numpy.zeros([d,d])

# for cluster ¡n clusters:

for polnt ¡n cluster:

val = polnt - mean

covar += numpy.dot(val[None,:].T,val[None,:]) covar /= total

u,s,v = numpy.llnalg.svd(covar)

área = 1

chl_square_alfa = ch¡2._ppf(1 - 0.05, 2)

for cont ¡n range(d):

área * = s[cont] * chl_square_alfa área = sqrt(area)

# pr¡nt(area, 'área')

density = total / área

# pr¡nt(dens¡ty, 'density')

¡f density >= self .denslty threshold:

means.append(mean)

covars.append(covar)

return True

return False

def detect_num ber_of_clusters(self , data_set):#, m near = 18):

this functiona applays a preprocessing of the data

to try to est ímate the num ber of clusters available.

Keyword arguments:

data_set -- a two dlmentlonal array that contalns the coordlnates of the clusters m near -- the num ber of neiborhood that are consldered to rank the ponts (default 15) alfa - the confldence ¡nterval, (1 - alfa) * 100 % (default 0.05) alfa = self .alfa

reamalnlng polnts = data_set .copy()

detected_clusters = []

cont_flg = 3

plot_all = False

m near = 10

whlle 1 :

polnts_slze, dlmentlon = reamalnlng polnts.shape

real near = m near ¡f m near < polnts slze else polnts slze - 1

near dlstance = num py.ones([polnts_slze, real_near]) * 100

near dlstancejndex = num py.zeros([polnts_slze, real_near])

¡f real_near < 2:

logglng.warnlng('pos¡ble_problem')

# Estímate the ranks from the polnts

cont_maln = 0

for y_p, x_p ¡n reamalnlng polnts:

cont_aux = 0

for y aux, x_aux ¡n reamalnlng polnts: # pr¡nt(cont_aux)

¡f cont main == cont aux:

cont_aux += 1

continué

distance = sqrt((y_p - y_aux) ** 2 + (x_p - x aux) ** 2)

for cont ¡n range(¡nt(real_near)):

¡f near_dlstance[cont_maln, cont] > distance:

¡f cont != real_near - 1 :

# pr¡nt('¡n_me')

near_d¡stance[cont_ma¡n, cont + 1 :real_near] = near_dlstance[cont_maln, cont:real_near - 1] near_d¡stance_¡ndex[cont_ma¡n, cont + 1 :real_near] = near_dlstanceJndex[cont_maln, cont:real_near - 1]

# else :

# pr¡nt('to long')

near_dlstance[cont_maln, cont] = distance

near_d¡stance_¡ndex[cont_ma¡n, cont] = cont_aux

break

cont_aux += 1

cont main += 1

ranks = numpy.sum(near_dlstance, ax¡s=1)

we¡ghts= 1 / ranks

we¡ghts/= numpy.sum(weights)

unlform dlst value = 1 / (1.0 * weights.size)

# sample one point to star the cluster detection

xj = self.sample_data.sample_data_gen_1d(we¡ghts, unlform_dlst_value)

total = numpy.sum(data_set)

dlst_data = data_set / total

# add the point ¡tself

¡ndex_to_conslder = numpy.concatenate([ near_d¡stancejndex[x_¡], numpy.array([x_¡,])])

covar, mean = self.get_covar_mean.estlmate_mean_varlance(reamalnlng_polnts , ¡ndex_to_conslder) new cluster polntsjndex = []

chl_p_alpha = ch¡2._ppf(1 - alfa, 2)

alfa_confldence_covar = chl p alpha * covar

for cont ¡n range(polnts_slze):

choosen polnt = reamalnlng_po¡nts[cont, :].copy()

choosen polnt -= mean # check if point is inside hyper-cube

points_ = choosen_polnt[:,None]

evalueate_ellipsoid = numpy.dot(numpy.dot(points_.T, numpy.linalg.inv(alfa_confidence_covar)), polntsj if evalueate_ellipsoid <= 1 :

new cluster polntsjndex.append(cont)

# remove the points from the cluster

# ¡nvert array to avoid having problemswith the change ¡n size and

# new indexing of the array

new_cluster_polntsJndex.sort(reverse=True)

new cluster points = []

for Índex ¡n new cluster polntsjndex:

# delete one polnt at a time

new_cluster_polnts.append(reamalnlng_polnts[ Index, :])

reamalnlng polnts = numpy.concatenate((reama¡n¡ng_po¡nts[0:¡ndex, :], reama¡n¡ng_po¡nts[¡ndex+1 :, :])) po¡nts_s¡ze, dimention = reamalnlng polnts.shape

# self .plot_po¡nts(reama¡n¡ng_po¡nts, new cluster points, cont_f¡g)

cont_flg += 1

detected_clusters.append(new_cluster_polnts)

# ¡f the are enought point do one more iteration

# print(points_size)

¡f points size <= m near :

break

cluster amount = 0

means = []

covars = []

for cont ¡n range(len(detected_clusters)):#range(len(detected_clusters), 1,-1):

¡f self. get_b¡c(detected_clusters[ cont], means, covars):

cluster amount += 1

# prlnt('yes')

return self .fusse_near_clusters(means, covars)

def make_markers(self, mean, data):

markers= [[],[],[]]

for x,y ¡n mean:

markers[0].append(x)

markers[1].append(y) markers[2].append(data[¡nt(x),¡nt(y)])

return markers

def plot_po¡nts(self, samplejndex, delated, cont):

polnts= numpy.zeros((31 , 31))

for ¡ndy, ¡ndx ¡n samplejndex:

polnts[lnt(lndy), ¡nt(lndx)] = 1

for ¡ndy, ¡ndx ¡n delated:

po¡nts[¡nt(¡ndy), ¡nt(indx)] = 0.5

pyplot.flgure(cont)

pyplot.claO

pyplot.clf()

pyplot.lmshow(polnts)

pyplot.draw()

# pyplot.show(block=False)

def fusse_near_clusters(self, means, covars):

NN = len(means)

mm = means.copy()

meged = []

flnal_means= []

# prlnt('ln')

cont = 0

whlle cont < NN:

¡f cont ¡n meged:

cont += 1

continué

# prlnt('flrst thlng, mean')

# prlnt(means[cont])

merge_count = 1

mean = means[cont].copy()

for contl ¡n range(cont + 1 ,NN):

¡f contl ¡n meged:

continué

covar sum = covars[cont] + covars[ contl] distance = means[cont] - means[ contl]

distance = numpy.dot(distance[:,None].T,distance[:,None]) sum dlstribution = mult¡var¡ate_normal(means[cont], covar sum)

evala = sum_distribiition.pdf(means[cont1])

# pr¡nt('gauss¡an dlst'.evala)

# print(means[cont1])

#

# print('distance', distance)

if distance <= 40:

# print('merge')

mean += means[cont].copy()

merge_count += 1

meged.append(cont1 )

final_m eans.append(mean/merge_count)

cont += 1

# print('out')

return final means

class Detect(Process):

def init (self, size_x, size_y, queue_markers, queue_scan, number_of_gauss=3):

super(Detect, self). init ()

# Data & Domain arrays needed for performing the fit

self. domain = meshgrid(iinspace(0, size_x-1 , size_x), iinspace(0, size_y-1 , size_y))

self .data = zeros((slze_x * size_y, 0))

#Outputs

self.markers= [zeros((number_of_gauss, 1)), zeros((number_of_gauss, 1)), zeros((number_of_gauss, 1))] self.time_elapsed = 0.

self.queue_scan = queue_scan

self.queue_markers= queue_markers

self.stop_event = Event()

self.display_rf_scan = False

def actlvate_plot(self):

self.dlsplay_rf_scan = True

def deactlvate_plot(self):

self.dlsplay_rf_scan = False

#def fit(self, data):

# it = tlme.timeO

# #print('fit') # [χ1 , χ2, χ3, y1 , y2, y3, a1 , a2, a3, s1 , s2, s3] = Rt(data, self.domain)

# tf = time.time()

#

# Amps = array([a1,a2,a3])

#

# Xpos = array([(x1), (x2), (x3)])

# Ypos = array([(y1), (y2), (y3)])

# orden = Amps.argsort()

#

# self.markers[0] = [Xpos[orden[2]], Xpos[orden[1]], Xpos[orden[0]]]

# self.markers[1] = [Ypos[orden[2]], Ypos[orden[1 ]] , Ypos[orden[0]]]

# self.markers[2] = [Amps[orden[2]], Amps[orden[1]], Amps[orden[0]]] #

# self.t¡me_elapsed = tf - it

#

# return self .markers.copy()

def log_function_info(self, msg):

logging.info('[Detect] ' + msg)

def run(self):

self.log_functlonJnfo('3art detect.')

from matplotlib ¡mport use

use('TkAgg')

from matplotlib ¡mport pyplot

pyplot.lon()

detect = DetectGausslas()

whlle 1 :

¡f self.stop_event.ls_set():

self.log_functlonJnfo('Stopp¡ng detect.')

return

data = self .queue_scan.get()

self.queue_scan.task_done()

self.log_functlonJnfo( 'Data recleve.')

#the medum fllter needs

mask = data

mask = mask.astype(numpy.float32) data = cv2.med¡anBlur(mask, 5)#* numpy.max(data) /255.0/256

# add watershed

watershed_data = data/ numpy.max(data) * 255

watershed_data = watershed_data.astype(numpy.uint8)

ret, thresh = cv2.threshold(watershed_data, 0, 255, cv2.THRESH_BINARYJNV + cv2.THRESH_0TSU)

Index O = (thresh == 0)

¡ndex_255 = (thresh == 255)

mask[¡ndex_0] = 255

mask[¡ndex_255] = 0

#data[lndex_0] =255

#data[lndex_255] =0

# end watershed

resampling = detect.sample_from_data(data)

means = detect.detect_number_of_clusters(resampling)

markers = detect.make_markers(means, data)

if len(markers[2]) > 0:

max_amplitud = max(markers[2]) * 1.2

maxjndex = mask > max amplltud

mask[max_¡ndex] = max amplitud

self .log functlonJnfo( 'Markers ready.')

try:

self.queue_markers.put([markers, data] ,block=True,tlmeout =0.5)

except:

self.log functlonJnfo('M arkers drop.')

lf self.dlsplay_rf_scan:

flg = pyplot.flgure(42)

ax = flg.add_subplot(1 , 1, 1)

pyplot.cla()

clrd = pyplot.Circle((markers[0][0], markers[1][0]), 2.0, color="whlte")

clrc2 = pyplot.Clrcle((markers[0][1], markers[1][1]), 1.0, color="whlte")

clrc3 = pyplot.Clrcle((markers[0][2], markers[1][2]), 0.5, color="whlte")

pyplot.lmshow(data)

ax.add_patch(clrc1)

ax.add_patch(clrc2)

ax.add_patch(clrc3) pyplot.draw()

pyplot.show()

pyplot.pause(O.I)

def shutdown(self):

self.stop_event.set()

def pos¡c¡ones(m¡n¡ma, máxima):

x1 =0

x2 = 0

x3 = 0

y1 =0

y2 = 0

y3 = 0

distl =0

d¡st2 = 0

d¡st3 = 0

whiledistl <m¡n¡maord¡st2<m¡n¡maord¡st3<m¡n¡maord¡st3 >max¡maord¡st1 >max¡maord¡st2>max¡ma: x1 = rand¡nt(0, 89)

x2 = rand¡nt(0, 89)

x3 = rand¡nt(0, 89)

y1 = rand¡nt(0, 89)

y2 = rand¡nt(0, 89)

y3 = rand¡nt(0, 89)

distl = math.sqrt((x1-x2)**2+(y1-y2)**2)

dist2 = math.sqrt((x3-x2)**2+(y3-y2)**2)

dist3 = math.sqrt((x1-x3)**2+(y1-y3)**2)

return x1 , y1 , x2, y2, x3, y3

def maxarg(data):

# Busca máximos y su posición en los datos

x = 0

y = 0

maxi = 0.

i = 0

j =0

aux = data.reshape(90, 90)

whlle i < 89: while j < 89:

if aux[i][j] > maxi:

x = i

y = i

maxi = aux[i][j]

j += 1

j =0

i += 1

return maxi, y, x # data.reshape seemsto flip axis def arg sort (valúes):

Índex = list(range(len(values)))

for cont ¡n range(len(values)-1 ):

change = False

forcontl in range(len(values)-1 ):

if values[cont1] <values[ cont 1+1]:

tmp = values[cont1]

values[cont1] =values[ cont 1+1] values[cont1 + 1] =tmp

tmp = index[cont1]

¡ndex[cont1] = index[cont1 + 1] index[cont1 + 1] =tmp

change = True

if not change:

break

return Índex

class EstlmateMeanCovariance(object):

def ¡nit (self, alfa = 0.05):

self alfa = alfa

def getjambda_2(self, lambdaj, lambda_s, radío): err = 1e-2

Iambda_s1 = 0

Iambda_s0 = lambda_t * 0.1

try:

cont = 0

while 1 : ratio = radio/ sqrt(lambda_sO)

upper = (ratio*norm.pdf(ratio))

lower = norm.cdf(ratio) - 0.5

Iambda_s1 =lambda_t/(1 - upper/lower )

if Iambda_s1 < 0 or Iambda_s1 > 1e5:

# print('reset')

Iambda_s1 = lambda_t * 0.1

radio = radio * 1.5

if abs(lambda_sO -Iambda_s1) < err:

return Iambda_s1

Iambda_s0 = Iambda_s1

cont += 1

# if (cont %1000) == 999:

# print('*',)

# print('end')

except Exception ase:

raise e

def estimate_mean_covar_u_s_v(self, data, dimention, pointsjndex): x center = numpy.zeros((dimention,))

covar matrix = numpy.zeros((dimention, dimention,)) for index p in pointsjndex:

# print(data[index_p, :])

x_center += data[int(index_p), :]

# initial mean estimation

x_center /= len(pointsjndex)

for index p in pointsjndex:

x i = x center - data[int(index_p), :]

x i = x _ [:, None]

covar matrix += numpy.dot(x i, x J.T)

# initial estimation covar matrix

covar_matrix/= len(pointsjndex)

U, s, V = numpy.linalg.svd(covar matrix)

s = numpy.diag(s)

return x center, covar matrix, U, s, V

def estimate_mean_variance(self, data, initial_pointsJndex): po¡nts_s¡ze, dimention = data.shape

x_center, covar matrix, U, s, V = self .estimate_mean_covar_u_s_v(data, dimention, initial_points_index) radio = 0

# print('start mean estimation')/

for cont in initial points index:

aux = data[int(cont)] - x_center

r = sqrt(numpy.dot(aux[:, None].T, aux[:, None]))

if radio < r:

radio = r

# initial estimation lambda square

lambda_0 = numpy.ones((dimention,))*radio

sqrt_chl_p_alpha = sqrt(ch¡2._ppf(1-self.alfa,2))

for cont in range(dimention):

iambda_0[cont] /= sqrt_chl_p_alpha

# calcúlate initial hyperrectanble axes

hyper_rectangle_thlng = numpy.zeros((dlmention, dimention,))

previus_covariance = covar_matrix.copy()

prev error = 0

for watch dog ¡n range(150):

for cont in range(dlmention):

hyper_rectangle_thing[cont, :] = sqrt_chi_p_alpha * lambda_0[cont]* U[cont,:]

polntsjn = []

# get the polntsthat are inside the hyper rectangle

for cont in range(polnts_size):

choosen polnt =data[cont, :].copy()

choosen polnt -= x_center

# check if point ¡s inside hyper-cube

¡s in = True

for contl ¡n range(dimentlon):

# print(cont,cont1 ,'a')

vector magnltud = sqrt(numpy.dot(hyper_rectangle_thlng[cont1 , :].T,hyper_rectangle_thlng[cont1 , :])) unltar vector = hyper_rectangle_thlng[cont1 , :]/vector_magnltud

projection = numpy.dot(choosen_polnt, unltar vector)

¡f not (projection <= vector magnltud and projection >= -vector magnitud):

isjn = False break

if isjn:

pointsjn.append(cont)

# read the documentaron on numpy linalg svd

x_center, covar matrix, U, s, V = self .estimate_mean_covar_u_s_v(data, dimention, pointsjn)

# estímate the valúes of the norma dlstrlbutlon usln

# a truncated dlstrlbutlon , see result 2.2 and 2.1

radlo_= numpy.zeros((dlmentlon,))

for cont ¡n range(dlmentlon):

radlo_aux = hyper_rectangle_thlng[cont,:]

radlo_[cont] = sqrt(numpy.dot(radlo_aux,radlo_aux))

o.ss.oo = numpy. llnalg.svd(prevlus_covar¡ance)

for cont ¡n range(dlmentlon):

¡f ¡snan(s[ cont, cont]):

logglng.ERROR('NaN')

¡f s[cont, cont] == 0:

logglng.ERROR('by zero')

lambda_2 = self. get_lambda_2(s[ cont, cont], ss[ cont], radlo_[ cont])

s[ cont, cont] = (lambda_2)

# estímate the reglón of 1 -alfa confldence

radlo_constant = ch¡2._ppf(1 - self .alfa, 2) / dimention

# se the polntsthat are ¡nslde thls last reglón

reglon_b = []

A matrix = numpy. dot(numpy.dot(U, s* radlo_constant), V.T)

for cont ¡n range(polnts_slze):

choosen polnt =data[cont, :].copy()

choosen polnt -= x_center

# check ¡f polnt ¡s ¡nslde hyper-cube

¡s in = True

polnts_ = choosen_polnt[:,None]

evalueate_elllpsold = numpy. dot(numpy.dot(polnts_.T, numpy. llnalg.¡nv(A_matrix)), polntsj ¡f evalueate_elllpsold <= 1 :

reglon b.append(cont)

x_center, covar matrix, U, s, V = self .estimate_mean_covar_u_s_v(data, dimention, region b) error = numpy. sum(numpy.abs(covar_matr¡x - previus_covarlance)) ¡f error < 0.1 :

break

¡f abs(error - prev error) < 1e-6:

break

prev error = error

U, s, V = numpy.llnalg.svd(covar_matrlx)

for cont ¡n range(dimention):

lambda_0[cont] = sqrt(s[cont])

prev¡us_covar¡ance = covar_matrlx.copy()

#pr¡nt('end mean estimation')

return covar matrlx, x center

class ResampleData(object):

def ¡nterpol_data(self, data, yjndex, xjndex):

lower x = ¡nt(xjndex)

lower y = ¡nt(yjndex)

upper x = ¡nt(x Index + 1 )

upper y = ¡nt (yjndex + 1)

valué = data[upper_y, upper_x]*sqrt((yjndex - upper_y)**2 + (xjndex - upper_x)**2) valué += data[lower y, lower x]*sqrt((y Index - lower y)**2 + (xjndex - lower x)**2) valué /= sqrt((upper_y - lower_y)**2 + (upper x - lower_x)**2)

return valué

def sample_data(self, data):

return self.sample_data_gen(data, 0.005)

def sample_data_gen(self, data, dlst_val, slze_x = 30, slze_y =30):

máximum =dlst_val

total = numpy.sum(data)

sample_data_ = data/total

whlle 1 :

[ldx_x, ¡dx_y] = [self.float_random(slze_x),self.float_random(slze_y)] offset = self.float random(maxlmum)

¡f offset <= self.¡nterpol_data(sample_data_,¡dx_y,¡dx_x):

return ¡dx y.ldx x

def sample_data_gen_1d(self, data, dlst_val):

whlle 1 :

¡dx_y = random ¡ntegers(0, data.slze - 1 ) ADS_4096 =0x0200

ADS_2048 =0x0400

ADSJ024 =0x0600

ADS_0512 =0x0800

ADSJ256 =0x0A00

ADSJvl ODE =0x0100

ADS_CONT CONV = 0x0000

ADS_SING_CONV =0x0100

ADS_DATA_RATE = OxEO

ADS_8SPS = 0x00

ADSJ 6SPS = 0x20

ADS_32SPS = 0x40

ADS_64SPS = 0x60

ADSJ 28SPS = 0x80

ADS_250SPS = OxAO

ADS_475SPS = OxCO

ADS_860SPS = OxEO

ADS_COM P_MODE = 0x10

ADS_COM P TRAD =0x00

ADS_COMP_WIND =0x10

ADS_COM P_POL = 0x08

ADS_COM P_LOW =0x00

ADS_COMP_HIGH =0x08

ADS_COM P_LAT = 0x04

ADS_COM P NLATCH =0x00

ADS_OOM P LATCH =0x04

ADS_COM P_QUE = 0x03

ADS_COM P_ONEC = 0x00

ADS_COM P_TWOC = 0x01

ADS_COM P_FOURC = 0x02

ADS_COM P DISABLE = 0x03

// Código en C, implementacion del servidor local

/* A simple server ¡n the Internet domain using TCP

The port number is passed as an argument * / #¡nclude <stdlo.h> #¡nclude <stdl¡b.h>

#¡nclude <std¡nt.h>

#¡nclude <str¡ng.h>

#¡nclude <fcntl.h>

#¡nclude <un¡std.h>

#¡nclude <sys/types.h>

#¡nclude <sys/socket.h>

#¡nclude <sys/mman.h>

#¡nclude <sys/stat.h>

#¡nclude <sys/un.h>

#¡nclude <net¡net/¡n.h>

#¡nclude <un¡std.h>

#¡nclude <math.h>

#¡nclude <w¡r¡ngP¡l2C.h>

#¡nclude "cnpy.h"

#¡nclude"ADS1115.h"

#¡nclude <¡ostream>

#¡nclude <t¡me.h>

/*socket related define*/

#def¡ne M Y SOCK PATH "/home/p¡/comun¡cat¡on"

#def¡ne LISTEN BACKLOG 50

#def¡ne handle error(msg) do { perror(msg); exit(EXIT FAILURE); } while (0)

/*scann related define*/

#def ine PAGE_3ZE (4* 1024)

#def ine BLOCK_SIZE (4* 1024)

#define 3ZE_N 31

#define MIN_ANG-30

#deflne M AX ANG 30

#define STEP ANG (M AX ANG-M IN_ANG)/(SIZE_N - 1.0)

#deflne MEANJTER2

#defineWAIT_T3000

#deflne BCM 2708 PERI BASE 0x3F000000

#define GPIO_BASE (BCM 2708_PERI_BASE+ 0x200000) /* GPIO controller */

#deflne WAIT_ADC 500000

using nam espace std; ¡nt mem fd;

void *gpio_map;

struct timespectim, tim2;

/ / 1/ O access

volatile unsigned *gpio;

// GPIO setup macros. Always use INP_GPIO(x) before using OUT_GPIO(x) or SET_GPIO_ALT(x,y) #def¡ne INP_GPIO(g) *(gp¡o+((g)/10)) &= ~(7«(((g)%10)*3))

#defineOUT_GPIO(g) *(gpio+((g)/10)) | = (1 «(((g)%10)* 3))

#def ine SET_GPIO_ALT(g,a) * (gpio+(((g)/ 10))) | = (((a)<=3?(a)+4:(a)==4?3:2)«(((g)%10)* 3)) #define GPIO_SET* (gpio+7) // sets bitswhich are 1 ignores bits which are 0

#define GPIO_CLR* (gpio+10) // clears bitswhich are 1 ignores bitswhich are 0

#define GET_GPIO(g) (* (gpio+13)& (1 «g)) // 0 if LOW, (1«g) if HIGH

#defineGPIO_PULL*(gpio+37) // Pulí up/pull down

#defineGPIO_PULLCLK0*(gP¡o+38)// Pulí up/pull down dock

/*functoins*/

void setup_io();

void send_data(double* val, unsigned char addr);

void read_from_plpe (int file);

void write_to_pipe (int file);

int do_scan(doubledata[], double angle[SIZE_N][3ZE_N][16], double theta_array[], int fd);

/'Global variable*/

double angle[aZE_N][SIZE_N][16];

double theta_array[SIZE_N];

int fd;

void error(const char *msg)

{

perror(msg);

exit(1);

¡nt handleClientRequest(int clientFD)

{

char buffer[256];

¡nt n;

/*&ancconflgureations*/

double data[SIZE_N*3ZE_N]; * You are about to change the GPIO settings of your computer.

* Messthisup and ¡t will stop working!

* It might be a good ¡deato 'sync' before running this program

* so at least you still have your code changeswritten to the SD-card!

............................................................ .

// Set GPIOp¡ns18, 23 and 24 to output

// must use INP GPIO before we can use OUT GPIO

/* End scann configurations*/

wh¡le(0==0)

{

bzero(buffer,256);/*clear¡ng the buffer*/

n = read(cl¡entFD, buffer ,255);/* reading from the client connectin*/

¡f (n < 0) /*error cheking*/ error(" ERFOR reading from socket");

/* recieve a cióse socket message*/

¡f(strcmp(buffer,"close\n") == 0 | | strcmp(buffer,"") == 0)

{

return 0;

¡f(strcmp(buffer,"scann\n") == 0)

{

¡f(do_scan(data,angle, theta_array, fd)==0)

{

n = wrlte(cl¡entFD,(char*)data,SIZE_N*3ZE_N*8);/*s¡ze of array* number of char per data*/

return 0;

/*scan functlond*/ void setup_¡o();

void send_data(float angle, unsigned char addr);

/* main function, here the socket is configured and start to

* run, waiting a request.*/

int main(int argc, char *argv[])

{

int sockfd, newsockfd;

socklen t clientLen;

struct sockaddr un serv addr, client_addr;

/* Initialize the socket configuration*/

sockfd = socket (AFJ_OCAL, SOCK STREAM , 0);

if (sockfd < 0)

{

errorf ERRORopening socket");

/'initialize address structure*/

memset(&serv_addr, 0, sizeof(struct sockaddr un)); /* Clear structure */ serv addr.sun family = AF LOCAL;

strncpy(serv_addr.sun_path, M Y SOCK PATH, sizeof(serv addr.sun path) u ni ink(se rv_addr.su n path);

/*start bind*/

if (bind(sockfd, (struct sockaddr *) Sserv addr, sizeof(struct sockaddr un)) {

handle_error("bind");

/*set the number of ¡ncomming connections*/

if (listen(sockfd, LISTEN BACKLOG) == -1)

{

handle_error(" listen"); clientLen = sizeof(struct sockaddr un);

/'Configure Pl ports and phase shlfter valúes*/

// Set up gpi pointer for direct register access

setup_¡o();

fd =wirlngPil2CSetup(0x54); /*w¡r¡ngP¡l2CWr¡teReg16(fd, 0x02, 0x20); * /

w¡r¡ngP¡l2CWr¡teReg16(fd, 0x02, 0x20);

INP_GPIO(18);

INP_GPIO(23);

INP_GPIO(24);

INP_GPIO(17);

INP_GPIO(27);

INP_GPIO(22);

INP_GPIO(5);

INP_GPIO(6);

INP_GPIO(13);

INP_GPIO(26);

OUT_GPIO(18);

OUTJ3PIO(23);

OUT_GPIO(24);

OUT_GPIO(17);

OUT_GPIO(27);

OUT_GPIO(22);

OUTJ3PIO(5);

OUT_GPIO(6);

OUT_GPIO(13);

OUT_GPIO(26);

GPIO_SET= 1«18;

GPIO_CLR= (1«24)| (1«23)| (1«17)| (1«27)| (1«22)| (1«5)| (1«6)| (1«13)| (1«26); doubledt = 0;

double dp = 0;

doubledt2 = 0;

double dp2 = 0;

double dt3 = 0;

double dp3 = 0;

for(lnt I = 0; I <3ZE_N; ¡++) theta_array[¡] = 180.0* sln((M IN_ANG + STEP_ANG*¡)* M_PI/ 180.0); for(lnt I = 0; I <3ZE_N; ¡++) for(lnt j =0;j <aZE_N;j++)

{ dt = theta_array[i];

dp = theta_array[j];

dt2 = 2 * dt;

dp2 = 2*dp;

dt3 = 3*dt;

dp3 = 3 * dp;

angle[i][j][0] = (int(360 + 360 + 360 - dt3)%360) * 255.0/360; angle[i][j][1] = (int(360 + 360 + 360 - dt2)%360) * 255.0/360; angle[i][j][2] = (int(360 + 360 + 360 - dt)%360) * 255.0/360; angle[i][j][3] = (int(360 + 360 + 360 + 0)%360)*255.0/360;

angle[i][j][4] = (int(360 + 360 + 360 - dt3 + dp2)%360)* 255.0/360; angle[i][j][5] = (int(360 + 360 + 360 - dt2 + dp2)%360) * 255.0/360; angle[i][j][6] = (int(360 + 360 + 360 - dt + dp2)%360) * 255.0/360; angle[i][j][7] = (int(360 + 360 + 360 + 0 + dp2)%360) * 255.0/360; angle[i][j][8] = (int(360 + 360 + 360 - dt3 + dp)%360) * 255.0/360; angle[i][j][9] = (int(360 + 360 + 360 - dt2 + dp)%360) * 255.0/360; angle[i][j][10] = (int(360 + 360 + 360 - dt + dp)%360) * 255.0/360; angle[i][j][11] = (int(360 + 360 + 360 + 0 + dp)%360) * 255.0/360; angle[i][j][12] = (int(360 + 360 + 360 - dt3 + dp3)%360)* 255.0/360; angle[i][j][13] = (int(360 + 360 + 360 - dt2 + dp3)%360)* 255.0/360; angle[i][j][14] = (int(360 + 360 + 360 - dt + dp3)%360) * 255.0/360; angle[i][j][15] = (int(360 + 360 + 360 + 0 + dp3)%360) * 255.0/360;

/*change the permissions on the unix socket, to allow accesswithout sudo*/

ch m od (M Y_SOCK_PATH , 0666) ;

while (true)

{

printf ("Waiting request...\n");

newsockfd = accept(sockfd, (struct sockaddr *) &client_addr, SclientLen);

if (newsockfd == -1 ) handle_error("accept "); ¡f (handleClientRequest(newsockfd) == 1)

{

break; }

printf("by\n");

unl¡nk(M Y SOCK PATH);

return 0; int do_scan(doubledata[],doubleangle[SIZE_N][3ZE_N][16],doubleth eta_array[], int fd) clock_ttStart = clock();

int conv reg;

int result;

double mean = 0.0;

doubleval [8] ={0,0,0,0,0,0,0,0};

uint8_t buf 1 =0;

uint8_t buf2 = 0;

printf ("M ¡nimum angle = %d\n", M IN ANG);

pr¡ntf("Max¡mum angle = %d\n", MAX ANG);

pr¡ntf("Step angle = %f \ n " , STEP ANG) ;

for(¡nt ¡ = 0; ¡ < SIZE N; ¡++) for(¡nt j = 0; j < SIZE N; j++) val[0] = angle[i][j][0];

val[1] = angle[i][j][1];

val[2] = angle[i][j][2];

val[3] = angle[i][j][3];

val[4] = angle[i][j][4];

val[5] = angle[i][j][5];

val[6] = angle[i][j][6];

val[7] = angle[i][j][7];

send_data(val, 0);

val[0] = angle[i][j][8]; val[1] = angle[l][j][9];

val[2] = angle[l][j][10];

val[3] = angle[i][j][11];

val[4] = angle[i][j][12];

val[5] =angle[i][j][13];

val[6] = angle[i][j][14];

val[7] = angle[i][j][15];

send_data(val, 1);

mean = 0.0;

result = wiring I2CWriteReg16(fd, 0x07, 0); for(inl z = 0;z<WAIT_ADC;z++) ((void)O); result = wiringRI2CReadReg16(fd, 0x07); if (result < 0) pr¡ntf(" Error at %d,%d\n", i, j); bufl = (result » 10) & 0x3F;

buf2 = result & OxOF;

conv reg = (buf2 « 6) + buf 1 ;

mean = (conv_reg* 3.3/1024 - 1 5269)/0.0174; data[j*SIZE_N + (SIZE N - 1 - 1)] = mean; }

prlntf("Tlmetaken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC); //const unslgned ¡nt shape[] = {3ZE_N, 3ZE N};

//cnpy::npy_save("arr1.npy", data, shape, 2, "w");

//prlntf("saved\n");

printf("Time taken: %.2fs\n", (double)(clock() - tStart)/CLOCKS_PER_SEC); return 0;

//

// Set up a memory reglonsto access GPIO

// setupjo

vold setupJo()

{

/* open /dev/mem * /

lf ((mem jd = open("/dev/mem", 0_RDWR| 0_SYNC) ) < 0)

{ pr¡ntf("can't open /dev/mem \n");

ex¡t(-1);

/* mmap GPIO*/

gp¡o_map = mmap(

NULL, //Any adddress ¡n our space will do

BLOCK SIZE, //Map length

PROT READI PROT W RITE,/ / Enable reading & wrlttlng to mapped memory M AP SHARED, //Shared wlth other processes

mem fd, //Rleto map

GPIO_BASE //Offset to GPIO perlpheral

);

close(mem fd); //No need to keep mem fd open after mmap

¡f (gplo_map == M AP FAILED) {

pr¡ntf("mmap error %d\n", (¡nt)gplo_map);//errno also set! ex¡t(-1);

// Always use volatile pointer!

gpio = (volatile unslgned *)gplo_map;

}

vold send_data(double* val, unslgned char addr)

{

// unslgned char opt = (¡nt) 0;

ulnt8_t data[8];

data[0] = (ulnt8_t) val[0];

data[1] = (ulnt8_t) val[1];

data[2] = (ulnt8_t) val[2];

data[3] = (ulnt8_t) val[3];

data[4] = (ulnt8_t) val[4];

data[5] = (ulnt8_t) val[5];

data[6] = (ulnt8_t) val[6];

data[7] = (ulnt8_t) val[7];

for(lnt j = 0; j < WAIT_T; j++) ((vo¡d)0);

GPIO_CLR= (1«18);

// float angle = strtof(argv[1], NULL, 0); for(¡nt i = 0; i < 8; i++)

{

for(¡nt j = 0; j < WAIT T; j++) ((void)0);

GPIO_CLR= 1«24;

¡f ((data[0] » i) & 0x01) GPIO_SB " = 1«23;

elseGPIO_CLR= 1«23;

¡f ((data[1] » i) & 0x01) GPIO_SB " = 1«17;

elseGPIO_CLR= 1«17;

¡f ((data[2] » i) & 0x01) GPIO_SB " = 1«27;

elseGPIO_CLR= 1«27;

¡f ((data[3] » i) & 0x01) GPIO_SB " = 1«22;

elseGPIO_CLR= 1«22;

¡f ((data[4] » i) & 0x01) GPIO_SB " = 1«5;

elseGPIO_CLR= 1«5;

¡f ((data[5] » i) & 0x01) GPIO_SB " = 1«6;

elseGPIO_CLR= 1«6;

¡f ((data[6] » i) & 0x01 ) GPIO_SB " = 1 «13;

elseGPIO_CLR= 1«13;

¡f ((data[7] » i) & 0x01) GPIO_SB " = 1«26;

elseGPIO_CLR= 1«26;

for(¡nt j = 0; j < WAIT T; j++) ((void)0);

GPIO_SET= 1«24; for(¡nt j = 0; j < WAIT_T; j++) ((void)0);

// OPTbit

GPIO_CLR= 1«24;

GPIO_CLR= (1«23)| (1«17)| (1«27)| (1«22)| (1«5)| (1«6)| (1«13)| (1«26);

for(¡nt j = 0; j < WAIT_T; j++) ((void)0);

GPIO_SET= 1«24;

for(¡nt j = 0; j < WAIT_T; j++) ((void)0);

// Addressbit 0

GPIO_CLR= 1«24;

¡f (addr == 0) GPIO_CLR= (1«23)| (1«17)| (1«27)| (1«22)| (1«5)| (1«6)| (1«13)| (1«26); else ¡f (addr == 1) GPIO_SET= (1«23)| (1«17)| (1«27)| (1«22)| (1«5)| (1«6)| (1«13)| (1«26); for(¡nt j = 0; j < WAIT_T; j++) ((void)O); GPIO_SET = 1«24;

for(int j = 0; j < WAIT_T; j++) ((void)0);

// Addressbit 1

GPIO_CLR = (1 «24)| (1«23)| (1«17)| (1«27)| (1«22);

GPIO_SET = (1«5)| (1«6)| (1«13)| (1«26);

for(int j = 0; j < WAIT_T; j++) ((void)O);

GPIO_SET= 1«24;

for(int j = 0; j < WAIT_T; j++) ((void)O);

// Addressbit 2

GPIO_CLR = (1 «24)| (1«23)| (1«5)| (1«27)| (1 «13);

GPIO_SET = ( 1 « 17) | ( 1 «6) | ( 1 «22) | ( 1 «26) ;

for(int j = 0; j < WAIT_T; j++) ((void)O);

GPIO_SET= 1«24;

for(int j = 0; j < WAIT_T; j++) ((void)O);

// Addressbit 3

GPIO_CLR = (1 «24)| (1«23)| (1«17)| (1«5)| (1«6);

GPIO_SET= (1 «27)| (1«22)| (1«13)| (1«26);

for(int j = 0; j < WAIT_T; j++) ((void)O);

GPIO_SET= 1«24;

for(int j = 0; j < WAIT_T; j++) ((void)O);

// Last sequence

GPIO_CLR = (1 «23)| (1«24)| (1«17)| (1«27)| (1«22)| (1«5)| (1«6)| (1«13)| (1«26);

for(int j = 0; j < WAIT_T; j++) ((void)O);

GPIO_SET= 1«18;

}

Descripción breve de las figuras

Figura 1/10

Esta figura describe el patrón de radiación sintetizado proveniente de 4 elementos radiantes (antenas). El patrón se encuentra con una inclinación de 16 grados proveniente de los desfases relativos entre las antenas. (I ) Arreglo plano de antenas.

(I I ) Antena o elemento radiante Figura 2/10

Esta figura presenta un diagrama de bloques general de la invención.

(I ) Arreglo plano de antenas.

(2) Electrónica de alta frecuencia

(3) Desfasadores

(4) Detector de potencia total

(5) Conversor análogo digital (A/DC)

(6) Microcomputador

(7) Suministro de Poder

(8) Pantalla

(9) Carcasa de Protección del dispositivo

(10) Antena o elemento radiante

( ) Amplificador

(12) Filtrador

(13) Cámara de video.

(14) Combinador Figura 3/10

Esta figura representa la disposición geométrica de los elementos radiantes, ordenados en forma matricial, sin excluir otras disposiciones.

(10) Antena o elemento radiante

Figura 4/10

Esta figura presenta un diagrama de bloques general de la placa con la electrónica de alta frecuencia.

(I ) Arreglo plano de antenas. (3) Desfasadores (10) Antena o elemento radiante

(I I ) Amplificador (12) Filtrador (14) Combinador

Figura 5/10

Esta figura presenta un modelo de un arreglo de antenas de 4x4 implementado en antenas de microcinta para la banda de telefonía PCS. (Escala en mm) (1 ) Arreglo plano de antenas. (10) Antena o elemento radiante

Figura 6/10

Esta figura presenta el ejemplo de aplicación de 16 antenas, con amplificadores y salidas, además cuenta con su modelo de placa de electrónica de alta frecuencia usando componentes comerciales, sin ser restrictiva a solo este tipo de componentes.

(1 ) Arreglo plano de antenas.

(2) Electrónica de alta frecuencia

(3) Desfasadores

(4) Detector de potencia total (5) Conversor análogo digital (A/DC)

(6) Microcomputador

(7) Suministro de Poder

(10) Antena o elemento radiante

(1 1 ) Amplificador (12) Filtrador, opcional (14) Combinador

Figura 7/10 Esta figura presenta específicamente, el esquema de las antenas del ejemplo de aplicación 1 a 4 usando componentes comerciales, sin ser restrictiva a solo este tipo de componentes. (Los esquemas de las antenas 5 a 8, 9 a 13 y 14 a 16, son similares en su distribución)

(3) Desfasadores

(7) Suministro de Poder

(10) Antena o elemento radiante

(14) Combinador

Figura 8/10

Esta figura presenta el esquema de una segunda placa usada para convertir la potencia medida en voltaje analógico.

(4) Detector de potencia total (7) Suministro de Poder

Figura 9/10

Esta figura presenta el diagrama de conexión del microcomputador con la cámara, la pantalla, los desfasadores y el A/DC.

(3) Desfasadores (5) Conversor análogo digital (A/DC)

(6) Microcomputador (8) Pantalla

(13) Cámara de video.

Figura 10/10

Esta figura presenta en su parte superior un modelo del sistema implementado.

(1 ) Arreglo plano de antenas. (7) Suministro de Poder

(8) Pantalla

(9) Carcasa de Protección del dispositivo

(10) Antena o elemento radiante (13) Cámara de video.

El esquema inferior presenta un despiece del sistema donde se incluyen el arreglo de antenas, la cámara óptica, la carcasa de protección, la pantalla, entre otros elementos.

Ejemplo de aplicación

Un ejemplo de aplicación de este dispositivo sin restringir sus

componentes, se implementa utilizando un arreglo de 16 antenas en

microcinta, dos placas de electrónica de alta frecuencia con componentes comerciales y un microcomputador comercial. Imágenes del diseño de este dispositivo se muestran en las figuras 6/10 ,7/10 y 8/10.

Las antenas de microcinta corresponden a antenas rectangulares sintonizadas a 1 ,88 GHz y con un ancho de banda aproximado de 50 MHz. (Figura 5/10)

La primera placa electrónica de alta frecuencia posee 16 módulos vectoriales HMC631 LP3 de Analog®, los cuales permiten cambiar la fase y amplitud de la señal recibida por cada una de las antenas. Estos moduladores son controlados con potenciómetros digitales DS3930 de Maxim®, lo cuales se comunican con un bus I2c. La señal es después combinada en fase mediante 14 combinadores de potencia TCP-2-272 de Minicircuits®. La señal posteriormente es amplificada con un amplificador de bajo ruido (LNA) modelo MAAL-007304 de MACOM®.

La segunda placa posee un detector de potencia modelo LT5538 de Linear® y es usado para convertir la potencia medida en un voltaje analógico.

El conversor análogo digital usado es el ADS1 1 15, el cual se compró comercialmente con su placa de prueba. Este último es conectado con una microcomputador Raspberry® pi 3.

La incorporación de filtros es opcional en este dispositivo, pues las antenas solo reciben una banda de frecuencia. Por otro lado, la cámara digital óptica, utilizada en este ejemplo prototipo fue de 800 x 600 mm. En el ejemplo presentado en la figura 10/10, se ve la cámara óptica posicionada sobre el arreglo de antenas, también es de preferencia, posicionar la cámara en el centro de las antenas ya que esta posición simplifica los cálculos para la acción de la cámara de radiofrecuencia.