Luz de sinalização manual de bicicleta: 10 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:41

O objetivo deste projeto é criar uma luz que caiba em uma luva de bicicleta e aponte na direção da curva pretendida, para aumentar a visibilidade à noite. Deve ser leve, fácil de usar e integrado com os movimentos existentes para sinalização (ajuste mínimo do método de sinal (você não precisa pressionar um botão, ele só vai quando você sinaliza)). Isso seria um grande presente de feriado.

Nota: Isso requer conhecimento prévio de como soldar e uma ideia de como programar AVRs é uma grande vantagem. Pensando nisso, divirta-se, seja paciente e poste fotos do seu produto abaixo! Aqui está um vídeo: E aqui está uma foto minha:

Etapa 1: peças

x1 ATmega 32L 8PU (www.digikey.com) x1 soquete DIP de 40 pinos (www.digikey.com) x1 8x8 LED Array (www.sparkfun.com) x1 74138 De-multiplexer (www.digikey.com) x2 Sensores Flex (www.sparkfun.com) x (Muitos) Resistores 180 ohm e 10k ohmx2 Placa PC (www.sparkfun.com) x6 Separadores (www.sparkfun.com) e parafusos para encaixar (Loja de Hardware local) x1 Acelerômetro na placa breakout (www.sparkfun.com) Cabeçalhos x2 - Masculino (www.sparkfun.com), Feminino (www.sparkfun.com) e Ângulo Reto (www.sparkfun.com) x1 LM7805 (www.digikey.com) x2 soquetes de 8 pinos (Eu comprei o meu na Radio Shack) x1 bateria de 9vx1 pé stick-on velcrox1 bicicleta de dedos inteiros glovex1 carretel de poliéster threadx1 Programador (eu tenho este aqui) x1 Descascador de fios e clipx1 MultímetroAlgumas das peças:

Etapa 2: Prepare as placas

Primeiro, adicione os impasses. Você terá que aparafusar dois juntos para obter a altura adequada. Certifique-se de que os espaçadores estejam descendo do lado com as almofadas QUADRADAS. Desta forma, você pode fazer a ponte entre os blocos com solda na parte inferior e fazer a ponte com o bloco comum na parte superior para conectar ao aterramento. Em seguida, adicione o conjunto de LEDs e solde-o. Ele deve estar o mais longe possível da borda da placa com os dois suportes, com o YS voltado para o lado oposto. O pino no canto inferior esquerdo é o pino 1. (Também está marcado na imagem.) Em seguida, adicione os dois soquetes de 8 pinos um em cima do outro para formar um soquete de 16 pinos. Certifique-se de ter um espaço à esquerda e então solde-o. Em seguida, divida os conectores macho e fêmea em seções de 10 e 11 pinos. Você precisará do dobro de cabeçalhos femininos. Solde como visto na foto. Quanto aos cabeçalhos machos, você precisa deslocar o pino para que haja uma quantidade igual em cada lado do plástico. É mais fácil olhar para uma imagem para ver o que quero dizer, então dê uma olhada em # 6. Usei um alicate e funcionou muito bem. Agora, se você pegar os cabeçalhos masculinos e colocá-los entre os 2 cabeçalhos femininos, verá que agora eles têm o tamanho certo para conectar a placa superior e inferior.

Etapa 3: adicione os resistores

Esses resistores ficam entre a matriz de LED e o 74138 (aterramento) para proteger a matriz. Dobre um dos fios do resistor por cima de forma que os dois fios fiquem paralelos. Encaixe-os nos pinos 7, 9, 10, 11, 12, 13, 14 e 15 e solde. Descobri que funciona melhor se você alternar a direção do resistor, como você pode ver na segunda e na terceira fotos.

Etapa 4: conecte o topo

Esta é de longe a etapa mais longa do projeto, então espero que você goste de soldar! Siga o esquema abaixo e certifique-se de testar a continuidade com seu multímetro. Caso você queira saber como eu vim com o esquema, veja o datasheet do array e do 74138.

Etapa 5: preencher a parte inferior

Agora é hora de colocar nossos componentes básicos na placa inferior. Primeiro faremos o soquete DIP de 40 pinos que vai o mais próximo possível do canto superior esquerdo, deixando uma fileira de espaço no lado esquerdo. (Veja a figura 1.) Solde isso e coloque os cabeçotes. A maneira mais fácil de fazer isso é conectar os que estão na parte superior aos que ficarão na parte inferior usando seus cabeçalhos masculinos modificados. Se você fez tudo certo, você deve acabar com os três pinos superiores no cabeçalho esquerdo próximos aos pinos inferiores direitos no soquete. Isso está bem. Usamos apenas o pino mais inferior à direita e, como você pode ver, temos uma visão clara de outra direção. Agora adicione o regulador de tensão conforme mostrado na imagem. Prendi o meu pelo buraco no dissipador de calor de metal com um parafuso e uma porca. O dissipador de calor é outra forma de aterrar o chip e aparafusá-lo à placa fornece um contato sólido com a conexão comum. Ele está conectado tanto na parte inferior quanto na parte superior, porque os dois estão conectados com isoladores de metal. No entanto, se você não estiver usando a conexão comum para aterramento, NÃO aparafuse o dissipador de calor na placa, pois o dissipador de calor serve como aterramento e você provavelmente causará um curto-circuito em alguma coisa. Próximo fio no clipe da bateria. O vermelho vai para o pino à esquerda (com o dissipador de calor para cima e os pinos para baixo), o preto vai para o meio e o pino direito produz + 5v. Agora você pode conectar a energia ao topo (veja a figura 2). Agora, para o conector do programador. Eu tenho um adaptador que fiz para o meu programador, mas você provavelmente vai querer incorporar um cabeçalho de 6 pinos (3x2) em seu projeto. No entanto, se você tiver um adaptador como eu, aqui está o que eu fiz. Peguei um cabeçalho de ângulo reto e um cabeçalho fêmea e os soldou juntos (Figura 3). Então eu o conectei à placa com o primeiro pino conectado ao pino 6. Agora você precisa ligar e aterrar o chip, bem como a fiação em um resistor para puxar o reset alto. Usei um resistor de 10k do pino 9 ao pino 10 e conectei o pino 10 ao + 5v. O próximo pino (11) vai para a conexão comum (Terra). Finalmente, olhe a figura 4 para concluir esta etapa (é bastante autoexplicativa).

Etapa 6: conecte a parte inferior

Lembra daquela etapa realmente divertida em que você precisou passar 30 fios para fazer um conjunto de LEDs funcionar? Agora você pode fazer de novo! No fundo!. Este é um pouco mais rápido, mas não muito. Mais uma vez, olhe para o esquema e verifique todas as conexões com o multímetro. Não se preocupe, esta é a última grande solda do projeto e você está quase pronto.

Etapa 7: Sensores Flex e o Acelerômetro

Vamos lidar com os sensores flex primeiro, mas você está na reta final no que diz respeito ao hardware. Acho que as fotos abaixo explicam muito bem o que fazer. Conecte um pino a + 5v e o outro ao terceiro ou quarto pino da parte superior do lado direito do AVR (o microcontrolador no centro deste projeto). Quando eu juntei isso pela primeira vez, pensei que era tudo o que eu precisava fazer, mas acontece que para o AVR ler os sensores flex, você precisa colocar um resistor do pino no sensor que vai do AVR para o aterramento (veja as fotos # 10 e 11). Usei um 10k. Isso divide a tensão que vai para o AVR, o que praticamente dobra a sensibilidade do sensor. Agora, para o acelerômetro. Como o acelerômetro é apenas um fio de cabelo mais alto que o espaço entre as duas placas e porque podemos querer substituí-lo algum dia, decidi usar cabeçalhos para retirá-lo da placa e conectá-lo. Use um cabeçalho de ângulo reto para conectar aos 6 pinos na placa de breakout. Agora pegue outro coletor de ângulo reto e solde um coletor fêmea aos pinos curtos e, em seguida, solde-o no canto inferior esquerdo da placa. Conecte o acelerômetro para verificar se ele se encaixa, desconecte-o e conecte os pinos apropriados ao Vcc (+ 5v) e Gnd. Em seguida, conecte o pino de saída X ao pino 40 e Y ao pino 39. Agora você deve ser configurado para adicionar os ICs (circuitos integrados) e ligá-lo.

26 de dezembro de 2009: descobri que a maneira como montei o sensor flexível do dedo indicador fez com que o material que conecta o sensor aos pinos se degradasse. Desde então, comprei um sensor de reposição e colei um pedaço de plástico fino com cola quente no sensor para evitar que essa área seja a parte que mais dobra. Eu marquei o local na foto abaixo.

Etapa 8: Adicionando ICs e o primeiro programa

Esta é provavelmente a etapa mais fácil de todo o processo. Mais uma vez, a imagem ajuda. Certifique-se de que possui os chips da maneira correta, conforme explicado na figura # 3. Primeiro, eu conectaria a energia sem nada conectado e tocaria no dissipador de calor do regulador de tensão. Se estiver quente, algo está em curto e você precisa voltar e verificar as conexões. Prossiga desta forma, adicionando um chip de cada vez, sentindo o calor e, uma vez que tudo estiver no lugar, aperte as porcas na placa inferior para que as duas placas fiquem firmemente presas uma à outra. Em seguida, você irá programar o AVR. Se você nunca fez isso antes, uma rápida pesquisa no Google produz uma infinidade de resultados. Se eu fosse você, colocaria meu AVR em uma placa de ensaio e o programaria antes de você tentar em seu trabalho duro. Eu escrevi um programa simples para enviar as informações recebidas dos sensores flex para a matriz de LED. Isso deve lhe dar uma ideia básica do que está ou não funcionando em seu circuito. Aqui está um vídeo do código em ação … e aqui está o código: #define F_CPU 800000UL # include #include #include void ADCINIT () { ADMUX = 0b01100000; ADCSRA = 0b10000000;} int main () {int a; a = 0; int b; b = 0; DDRD = 0xFF; DDRB = 0xFF; DDRA = 0b11100000; ADCINIT (); enquanto (1) {ADMUX = 0b01100011; ADCSRA | = 0b01000000; enquanto (bit_is_clear (ADCSRA, ADIF)); PORTA = 0b00000000; PORTD = ADCH; _delay_ms (1); PORTD = 0x00; ADMUX = 0b01100010; ADCSRA | = 0b01000000; enquanto (bit_is_clear (ADCSRA, ADIF)); PORTA = 0b11100000; PORTB = ADCH; _delay_ms (1); PORTB = 0x00; }}

Etapa 9: Anexando seu Circut a uma luva

Acho que há muitas maneiras de prender seu circuito à sua mão e por um tempo pensei em deixar isso para o leitor, mas depois decidi que o instrutível não estaria completo sem esse fechamento. Fui à minha loja de bicicletas local e comprei a luva de dedo inteiro mais barata que consegui encontrar. O dedo completo é necessário porque, de outra forma, você não pode conectar os sensores flex muito bem. Em seguida, fui a uma loja de tecidos e comprei um fio de poliéster e velcro adesivo. Coloquei a luva e coloquei o circuito na minha mão. Parte do posicionamento é conforto, mas outra parte são os sensores flex. Eles devem descer no meio de dois dedos. Eu costurei laços ao redor dos três espaçadores para segurar a placa principal (veja a figura 2) e então lavei laços 3/4 de cada dedo sensor flexível (nº 3 e 4). Certifique-se de não costurar a luva fechada. Em seguida, coloquei um pedaço de velcro na lateral do meu polegar para segurar a bateria. Após o teste, descobri que vale a pena costurar isso também, pois o palito não dura muito. Em seguida, coloco um laço de velcro em volta do 9v (Figura 5). Esta configuração parece funcionar muito bem. Como você pode ver nas fotos do primeiro e do último slides, agora adicionei luvas para os sensores flex, mas se você não tiver tempo, os loops devem servir. Quando terminar seu projeto, poste fotos do produto acabado abaixo. Adoraria ver o que você criou para conectar o circuito!

Etapa 10: O Código Real

Obrigado por aguentar comigo até agora. Lembre-se de que meu código não é perfeito. Descobri que é preciso aprender um pouco para fazer o sinal funcionar corretamente. Vou continuar tentando aperfeiçoar meu sistema e manter esta página atualizada com o novo código assim que escrevê-lo. 26 de dezembro de 2009: NOVO CÓDIGO! É postado onde o código antigo estava. Muito obrigado a Jacob pela simplificação. Isso realmente funciona bem. Aqui está. Obrigado pela leitura e não se esqueça de votar! #include #include #include // Define ou limpa bits nos registros #define setBit (sfr, bit) (sfr | = (1 << bit)) #define clearBit (sfr, bit) (sfr & = ~ (1 << bit)) #define flipBit (sfr, bit) (sfr ^ = (1 << bit)) #define FALSE 0 #define TRUE 1 #define matrixX (x) (PORTA = (x - 1) << 5) #define matrixGY (y) (PORTD = y) #define matrixRY (y) (PORTB = y) atraso vazio (atraso int sem sinal) {sem sinal int x = 0; enquanto (x <atraso) {x ++; }} void initMatrix () {DDRD = 0xFF; // Controle verde DDRB = 0xFF; // Controle vermelho DDRA = 0xE0; // Controle de solo} void matrixRowDraw (char greenmask, char redmask, char coluna) {matrixX (coluna); int i = 0; para (i = 0; i <8; i ++) {matrixGY (máscara verde & (1 << i)); matrixRY (máscara vermelha & (1 << i)); _delay_us (150); } matrixGY (0x00); matrixRY (0x00); } void matrixLeft () {matrixRowDraw (0x10, 0, 1); matrixRowDraw (0x20, 0, 2); matrixRowDraw (0x40, 0, 3); matrixRowDraw (0xFF, 0, 4); matrixRowDraw (0xFF, 0, 5); matrixRowDraw (0x40, 0, 6); matrixRowDraw (0x20, 0, 7); matrixRowDraw (0x10, 0, 8); } void matrixRight () {matrixRowDraw (0x18, 0, 1); matrixRowDraw (0x18, 0, 2); matrixRowDraw (0x18, 0, 3); matrixRowDraw (0x18, 0, 4); matrixRowDraw (0x99, 0, 5); matrixRowDraw (0x5A, 0, 6); matrixRowDraw (0x3C, 0, 7); matrixRowDraw (0x18, 0, 8); } void adcInit () {ADMUX = 0x60; ADCSRA = 0x80; } char adcGet (char chan) {ADMUX = 0x60 | chan; ADCSRA | = 0x40; enquanto (bit_is_clear (ADCSRA, ADIF)); return ADCH; } char adcAvg (char chan, char avgnum) // Apenas média de até 256 amostras {int i = 0; total int sem sinal = 0; para (i = 0; i <avgnum; i ++) {total + = adcGet (chan); } return total / avgnum; } int main () {initMatrix (); adcInit (); while (1) {while (adcAvg (3, 50)> 0x45 & adcAvg (2, 50)> 0x70) // Os valores hexadecimais aqui devem ser alterados dependendo da configuração do usuário para determinar a sensibilidade dos sensores flex. {if (adcAvg (1, 50)> 0x4F) {matrixRight (); } if (adcAvg (1, 100) <0x4F) {matrixLeft (50); }}} return 0; } Agradecimentos especiais aos Chamberlains, meus pais e amigos que ajudaram.

Finalista no Concurso de Férias Caseiras