Como identificar marcadores de LED modulando seu brilho?

Para um projeto meu, preciso usar marcadores de infravermelho para identificar locais de pontos no espaço com algoritmos de estereovisão e várias câmeras de infravermelho. Também preciso que cada marcador de LED tenha um ID reconhecível exclusivo, que é o meu problema atual.

Meu pensamento era que cada LED piscasse entre dois estados de brilho (isso é possível?) Em uma sequência reconhecível, mas ainda assim seja suficientemente brilhante para acompanhar o estado de brilho mais baixo.

Não sei como implementar isso ou realmente por onde começar a procurar. Sou programador, mas nunca trabalhei com circuitos reais antes. Você pode me ajudar a começar?

se todos os seus LEDs estiverem sendo controlados da mesma fonte, considere usar um microcontrolador + codificação Manchester diferencial + seus estados LED alto / baixo para codificar bitstrings de sequências repetidas, como:

id #0: 1000000000000000[10000000000000001000000000000000....]
id #1: 1000000000000001[10000000000000011000000000000001....]
id #2: 1000000000000010
id #3: 1000000000000011
id #4: 1000000000000100

para codificar números de identificação como uma sequência de bits de 16 bits que consiste em 1, depois 7 zeros e um ID # de 8 bits. Em seguida, ao decodificar, procure um 1 seguido por 7 zeros e depois pegue os bits subseqüentes subsequentes. Isso funciona para todos os IDs de 8 bits (mesmo # 128 = 10000000 que codifica como 1000000010000000 que não podem necessariamente ser sincronizados corretamente, mas para esse número, isso não importa).

(Se você tiver menos LEDs em potencial, use menos bits; esse esquema é bastante simples e generaliza para 1 + (N-1) zeros + um número de N bits)

A codificação Manchester é de relógio automático, portanto, você deve poder sincronizar um receptor com ele (mesmo que seja outro microcontrolador que não tenha certeza da frequência, faça uma amostragem várias vezes por bit para ficar bloqueado).

Se você pudesse acender e apagar cada LED em uma frequência diferente, isso provavelmente simplificaria bastante as coisas, pois você poderia usar 555 circuitos baseados para piscar cada um na frequência necessária.

Todo mundo parece estar começando com Arduinos estes dias, assim que algo como isso é provavelmente o que você está procurando. No entanto, parece que você pretende usar muitode LEDs neste projeto que seriam difíceis com um arduino. Está tudo fora do topo da minha cabeça * aqui, mas pode ser possível usar um transistor e um resistor grande em paralelo para que, quando o transistor estiver desligado, a corrente flua através do resistor grande e você tenha uma luz fraca. Quando você o liga, a corrente flui através do transistor devido à menor resistência e você obtém o estado mais brilhante. Supondo que isso funcione, você pode usar componentes digitais, como microcontroladores, para controlar os transistores e obter o flash necessário. Em anexo está um esquema do que quero dizer (os valores são arbitrários, você provavelmente precisará alterá-los para o seu circuito):

Seja como for, será bastante difícil, considerando que você não fez muita eletrônica. Boa sorte!

*está tarde; isso pode estar completamente errado e não funcionar. ymmv.

Eu faria uma variação da ideia de penjuin. Eu usaria um estado ligado e desligado para gerar os dois níveis. Em vez de tentar rastrear o LED no estado desligado (ou estado baixo), torne o estado desligado curto e apenas acompanhe o estado ligado.

Você também não mencionou quantos LEDs precisa rastrear e com que rapidez eles estão se movendo.

Sim, dois estados "escuro" e "brilhante" são fáceis. Dado qualquer circuito que pisque e acenda um LED com um transistor, você adiciona um resistor nesse transistor. Então, quando o transistor estiver totalmente desligado, o resistor permitirá um brilho fraco. Eu começaria com um resistor exatamente do mesmo valor que o resistor limitador de corrente já conectado ao LED. (Todo LED precisa de um resistor limitador de corrente).

Para alguns marcadores, uma bateria independente e um temporizador 555 em cada um deles serão o hardware de marcador mais simples. (mais alguns resistores e capacitores).

O sistema geral é mais simples se você puder sincronizar os LEDs: ligue todos os marcadores no início do ciclo, desligue um marcador de cada vez até que todos estejam desligados, ligue-os novamente e inicie o ciclo novamente. A quantidade de energia necessária para manter um grupo de LEDs piscando por algumas horas normalmente pesa muito menos na forma de uma ou duas baterias centrais, em vez de uma bateria por LED. (Isso requer um IC comparador em cada LED ou alguns registros de turno ou um Arduino emulando esses registros de turno em algum local central). (Isso requer muitos fios que passam de um marcador para o próximo ou de cada marcador para algum ponto central - para que não seja possível para o seu aplicativo.)

Isso torna o seu software de reconhecimento de visão muito mais simples se o PC puder controlar diretamente os LEDs. Quando o PC estiver procurando pelo LED_5, ele poderá desligar e ligar o LED_5 e ter certeza de que o LED que piscou deve ser o LED_5. Talvez usando algo como um conversor de porta paralela de USB para 8 bits , que (com 8 resistores, um por LED) pode controlar diretamente 8 LEDs ou (com 4 resistores, um por coluna) uma matriz 4x4 de 16 LEDs. (Isso requer ainda um outro fio, um cabo USB do PC para o conversor, mas não requer qualquer baterias ou transistores ou chips adicionais - esta pode ser a mais simples para um programador não-eletrônica cara para começar a trabalhar).

Eu acho que você pode ter problemas com o lado da visão, se a taxa de quadros da câmera não for alta o suficiente em relação à taxa de movimento dos LEDs.

os LEDs precisarão alternar entre alto e baixo em algum múltiplo razoável da taxa de quadros da câmera, pelo menos 2 quadros por alteração de estado para garantir que alguns dos quadros tenham luz de apenas um estado em vez de misturados de dois estados, o que significa que você precisa de dois quadros para cada bit de dados emitidos pelos LEDs para identificar qual marcador é. obviamente, um código mais curto será melhor para isso.

Se os marcadores estiverem se movendo uma distância acima da que está na mesma ordem em que estão distantes um do outro no quadro, o sistema de visão poderá perder a confiança na identificação correta de quais flashes pertencem a qual marcador.

^{simular este circuito - esquemático criado usando o CircuitLab}

Figura 1, 2 e 3 esquemas de LED.

• LEDs duplos oferecem controle muito simples. R2 define o brilho do LED sempre ativo. R1 define o brilho do LED pulsado.
• LED único, brilho duplo é outro esquema simples. D3 sempre acende com a corrente passada por R4. Quando o BUF2 baixa, ele conecta R3 a GND e a corrente através de D3 aumenta, fazendo com que o LED brilhe mais.
• O controle de brilho do PWM é o mais simples do ponto de vista do hardware, mas o software precisa controlar o brilho do LED.

Figura 2. Codificação PWM.

Usando a modulação por largura de pulso (PWM), você pode variar o brilho aparente variando a proporção liga / desliga. A Figura 2 mostra uma sequência de alta potência, baixa potência e alta potência.

Para a sua aplicação, você precisa definir a frequência PWM alta o suficiente para que o sensor da câmera não veja nenhum tremor. A modulação de dados ou a taxa de alternância entre brilho alto e baixo teriam que ser no máximo metade da taxa de quadros e mais provavelmente cerca de um décimo da taxa de quadros para discerni-lo adequadamente.

Você também pode precisar abordar o ângulo do feixe dos LEDs. Parece que suas câmeras não estarão no eixo o tempo todo.