Tabuleiro de xadrez eletrônico (protótipo de demonstração 4x4)

Componentes e suprimentos

Sensor de efeito Hall

Placa de ensaio sem solda em tamanho real

LED (genérico)

Leitor RFID (genérico)

Leitor e antena RFID de 125 kHz

Arduino Mega 2560

Tag RFID 3M

Ferramentas e máquinas necessárias

plexiglass

Papel brilhante

pranchas de madeira

Tinta acrílica (verde escuro e creme) x2

ímãs redondos de 10 mm

Peças de xadrez de peão e rainha

Ferro de soldar e materiais de solda

Aplicativos e serviços online

Arduino IDE

Sobre este projeto

Olá fabricantes,

Eu sou Tahir Miriyev, graduado em 2018 pela Middle East Technical University, Ancara / Turquia. Eu me formei em Matemática Aplicada, mas sempre adorei fazer coisas, especialmente quando envolvia algum trabalho manual com eletrônica, design e programação. Graças a um curso único de prototipagem, oferecido em nosso departamento de Desenho Industrial, tive a chance de fazer algo realmente interessante. O projeto pode ser tratado como um Projeto de Prazo, com a duração de um semestre inteiro (4 meses). Os alunos receberam a tarefa de encontrar uma abordagem criativa para projetar produtos / demos já existentes e realizar suas ideias usando microcontroladores e sensores Arduino. Eu estava pensando em xadrez e depois de fazer algumas pesquisas sobre projetos de sucesso, percebi que em projetos anteriores os fabricantes usavam basicamente mecanismos de xadrez prontos (onde todos os movimentos de cada figura eram programados no núcleo), junto com Raspberry Pi, alguns MUXes , LEDs e interruptores reed. No meu projeto, porém, decidi me livrar de qualquer software externo em termos de mecanismo de xadrez e encontrar uma solução criativa para o problema de reconhecimento de figura, usando leitor RFID, sensores de efeito Hall e Arduino Mega.

Para simplificar, suponha que você tenha um tabuleiro de xadrez com um "cérebro" =microcontrolador e precise fazer seu tabuleiro entender qual figura você segurou em suas mãos e onde a colocou. Este é o problema do reconhecimento de figura. A solução para este problema é trivial quando você tem uma máquina de xadrez com todas as peças em suas posições iniciais no tabuleiro. Antes de explicar porque é assim, deixe-me fazer algumas observações.

Para aqueles que estão entusiasmados sobre como as coisas funcionam aqui, eu tenho que fazer um esclarecimento sobre por que precisamos de interruptores reed (ou no meu caso, usei sensores de efeito Hall):se você colocar um ímã sob cada peça e retirá-lo de um quadrado no tabuleiro (supondo que haja uma chave de palheta sob cada quadrado) devido à existência / não existência do campo magnético acima do sensor, você pode fazer seu controlador entender se há / não uma peça no quadrado. No entanto, ele ainda não diz nada ao microcontrolador sobre exatamente qual peça está no quadrado. Apenas informa que não há / não uma peça em um quadrado. Nesse ponto, nos deparamos com um problema de Reconhecimento de Figura, que pode ser resolvido por meio de uma máquina de xadrez, com todas as peças colocadas em suas posições iniciais no início do jogo de xadrez. Desta forma, o microcontrolador "sabe" onde cada peça está desde o início, com todos os endereços fixados na memória. No entanto, isso nos traz uma grande limitação:você não pode selecionar, digamos, qualquer número de peças e colocá-las aleatoriamente em qualquer lugar do tabuleiro e começar a analisar o jogo. Você sempre tem que começar do início, todas as peças devem estar no tabuleiro originalmente, pois essa é a única maneira do microcontrolador rastrear suas localizações depois que você levantou uma peça e colocou em algum outro quadrado. Em essência, esse foi o problema que percebi e decidi trabalhar para resolver.

Minha solução foi bastante simples, embora criativa. Coloquei um leitor RFID na parte frontal de uma placa. Enquanto isso, coloquei não apenas um ímã sob as peças, mas também uma etiqueta RFID, com cada peça tendo um ID único. Portanto, antes de colocar uma figura em qualquer quadrado desejado, você pode primeiro segurar a peça perto do leitor RFID e deixá-lo ler o ID, identificar a peça, salvá-la na memória e então você pode colocá-la onde quiser. Além disso, em vez de usar interruptores reed, para simplificar o projeto do circuito, usei sensores de efeito Hall, que funcionam de forma semelhante, com a única diferença de enviar 0 ou 1 para um microcontrolador como um dado digital, o que significa "existe" ou "não há" nenhuma peça no quadrado, respectivamente. Também adicionei LEDs (infelizmente não da mesma cor, não tinha), de modo que quando você levantar a peça, todos os locais quadrados, onde uma peça levantada poderia ser colocada, acendam. Pense nisso como uma prática educacional para alunos de xadrez :)

Por último, gostaria de observar que apesar do fato de ter usado várias técnicas, o projeto continua simples e compreensível, não muito elaborado ou muito complicado. Não tive tempo de prosseguir com o tabuleiro de xadrez 8x8 (também porque 64 sensores de efeito Hall são caros na Turquia, cobri todas as despesas relacionadas ao projeto), por isso fiz a versão demo 4x4 com apenas duas peças testadas:Peão e Rainha . Em vez de usar um mecanismo de xadrez, escrevi um código-fonte para o Arduino, que gera tudo.

Antes de passarmos ao passo a passo explicação de como o projeto foi feito, recomendo assistir a um vídeo ilustrativo e ter uma ideia intuitiva do que estou falando.

Nota # 1:Um dos LEDs vermelhos (primeiro na linha / da esquerda para a direita) queimou, não importa.

Nota # 2:Embora amplamente utilizado, por experiência própria posso dizer que a tecnologia RFID não é a melhor ideia para usar em aplicações faça você mesmo (claro se você tiver alternativas). Antes de tudo funcionar, fiz várias tentativas de colocar peças de xadrez perto do leitor e esperar até que ele lesse o ID corretamente. A porta serial deve ser configurada para isso porque a forma como o leitor RFID lê a ID é apenas uma dor de cabeça. Deve-se tentar por si mesmo para entender o problema.

Aqui está a lista de todas as ferramentas Usei para o projeto:

Componentes eletrônicos:

breadboard (x1)

Sensores de efeito Hall Omnidirecionais A1126LUA-T (IC-1126 SW OMNI 3-SIP ALLEGRO) (x16)

LEDs básicos de 5 mm (x16)

Jumper fios

Leitor e antena RFID de 125 kHz (x1)

Arduino Mega (x1)

Tags RFID 3M (x2)

Outros materiais:

Plexiglass

papel brilhante

pranchas curtas (de madeira)

Tinta acrílica (verde escuro e creme) x2

papelão fino

ímãs redondos de 10 mm (x2)

Peças de peão e rainha

Ferro de soldar e materiais de solda

É hora de explicar como as coisas foram feitas. Siga a descrição passo a passo:

1. Pegue um cartão 21x21 cm, bem como um cartão extra para cortar e colar as paredes da parte superior do cartão, de forma a fazer 16 quadrados com A B C D 1 2 3 4 enumerados. Como o papelão é fino, você pode colocar 16 sensores de efeito Hall em cada quadrado, com 3 pernas cada e 16 LEDs com 2 pernas cada.

2. Depois de definir os componentes, você precisará fazer um pouco de solda para soldar as pernas dos sensores de efeito Hall e LEDs para fazer a ponte dos fios. Neste ponto, eu recomendaria selecionar fios coloridos de forma inteligente, para que você não se confunda com as pernas + e - dos LEDs, também VCC, GND e as pernas PIN dos sensores de efeito Hall. Claro, pode-se imprimir uma placa de circuito impresso com sensores e até mesmo tipo de LEDs WS2812 já soldados, mas decidi manter o projeto simples e fazer mais um "trabalho manual". Nesse ponto, tudo o que você precisa fazer é preparar os cabos e os sensores; em estágios posteriores, seguindo o esquema de Fritzing, você pode ver onde deve prender a extremidade de cada fio. Em breve, alguns deles irão diretamente para os PINs no Arduino Mega (há o suficiente deles no Arduino), outros para a placa de ensaio e todos os GNDs podem ser soldados a um único pedaço de cabo (tornando o terreno comum) que mais tarde deve ser conectado ao GND na placa Arduino. Uma observação importante aqui:os sensores de efeito Hall são OMNIDIRECIONAIS, o que significa que não importa qual pólo de um ímã será mantido próximo ao sensor, ele enviará 0 dados enquanto houver algum campo magnético próximo e 1 quando não houver, ou seja, o ímã está longe (mais do que digamos 5 sm) do sensor.

3. Prepare um papelão de 21x21 cm semelhante e fixe o Arduino Mega e uma placa de ensaio longa nele. Você também pode cortar 4 paredes de qualquer altura desejada de papelão novamente e colá-las verticalmente com aquelas duas camadas de placas quadradas de 21x21 cm. Em seguida, siga os Esquemas de Fritzing para configurar as coisas. Você também pode configurar o leitor RFID depois de concluir os LEDs e os sensores de efeito Hall.

4. Teste se todos os LEDs e sensores funcionam, enviando sinais usando códigos básicos. Não evite essa etapa, pois ela permitirá que você teste se tudo está funcionando corretamente e passe para a construção posterior da placa.

5. Prepare o Peão e a Rainha, com dois ímãs de um raio de 10 cm fixados abaixo, bem como etiquetas RFID redondas. Posteriormente, você precisará ler os IDs dessas tags na Serial Screen no Arduino IDE.

6. Se tudo funcionar bem, você pode iniciar o código principal e experimentar!

7 (opcional). Você pode fazer algum trabalho artístico com madeira que dará à sua demonstração uma visão mais natural. Depende da sua vontade e imaginação.

Aqui estão alguns vídeos e fotos de diferentes estágios:

Obrigado pela sua atenção! Teste tudo e fique à vontade para escrever nos comentários sobre qualquer tipo de erro que perdi, melhorias, sugestões etc. Ansioso por ouvir algumas opiniões sobre o projeto. Se você precisar de qualquer tipo de ajuda com o projeto, me mande um email (miriyevt @ gmail .com) ou adicione o Skype (tahir.miriyev9r1), para que possamos agendar uma conversa e discutir o assunto em detalhes. Boa sorte!

Código

thinK_code.ino

thinK_code.ino Arduino

Tentei deixar tantos comentários quanto pude, a fim de tornar o processo de análise de código compreensível. Para ser honesto, a lógica pode parecer um pouco complexa à primeira vista, mas se você se aprofundar na lógica do código, ela parecerá mais abrangente.

Nota:Semelhante ao tabuleiro de xadrez real, eu numerado abstratamente quadrados como A1, A2, A3, A4, B1, ..., C1, ..., D1, .., D4. No entanto, no código, não é prático usar essa notação. Portanto, usei matrizes e representou quadrados como 00, 01, 02, 03,10,11,12,13, ..., 32,33 respectivamente.

 #include  SoftwareSerial RFID (11, 12); // ----------------------------------------------- ------------ COMEÇAR ------------------------------------- -------------------------------------------------- ------ int empty_pos [2]; int figure_pos [2] [2]; // pensando na posição da figura como uma matriz de dois vetores (rainha e peão) com três entradas (x pos, y pos e valor 1 (rainha), 2 (peão) int new_id [14] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; int id_type_matrix [4] [4] ={{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}; int temp =0; int queen_id [14] ={2, 53, 65, 48, 48, 56, 51, 49, 55, 70, 65, 51, 52, 3}; int pawn_id [14] ={2, 53, 65, 48, 48, 56, 51, 56, 67, 49, 56, 52, 68, 3}; int temp_vect [2]; int count =0; int ID =0; int yeni_id [14]; // matriz de matriz inicial para sensores de efeito Hallint hes_bool_matrix [4] [4]; // lista de efeito Hall pinos dos sensores em Arduinoconst int hes_00 =44; const int hes_01 =45; const int hes_02 =46; const int hes_03 =47; const int hes_10 =48; const int hes_11 =49; const int hes_12 =50; const int hes_13 =2; const int hes_20 =3; const int hes_21 =4; const int hes_22 =5; const int hes_23 =6; const int hes_30 =7; const int hes_31 =8; const int hes_32 =9; const int hes_33 =10; int hes_pin_matrix [4] [4] ={{hes_00, ele s_01, hes_02, hes_03}, {hes_10, hes_11, hes_12, hes_13}, {hes_20, hes_21, hes_22, hes_23}, {hes_30, hes_31, hes_32, hes_33}}; // LED pinsconst int led_00 =22; const int led_01 =23; const int led_02 =24; const int led_03 =25; const int led_10 =26; const int led_11 =27; const int led_12 =28; const int led_13 =29; const int led_20 =30; const int led_21 =31; const int led_22 =32; const int led_23 =33; const int led_30 =34; const int led_31 =35; const int led_32 =36; const int led_33 =37; int led_matrix [4] [4] ={{led_00, led_01, led_02, led_03}, {led_10, led_11, led_12, led_13}, {led_20, led_21, led_22, led_23}, {led_30, led_31, led_32, led_33}}; // ---------- ------------------------------------------- ÁREA DE CONFIGURAÇÃO ----- -------------------------------------------------- -------------------------- configuração vazia () {RFID.begin (9600); Serial.begin (9600); // modos de leitura (entrada) para sensores de efeito hall pinMode (hes_01, INPUT); pinMode (hes_02, INPUT); pinMode (hes_03, INPUT); pinMode (hes_00, INPUT); pinMode (hes_10, INPUT); pinMode (hes_11, INPUT); pinMode (hes_12, INPUT); pinMode (hes_13, INPUT); pinMode (hes_20, INPUT); pinMode (hes_21, INPUT); pinMode (hes_22, INPUT); pinMode (hes_23, INPUT); pinMode (hes_30, INPUT); pinMode (hes_31, INPUT); pinMode (hes_32, INPUT); pinMode (hes_33, INPUT); // modos de escrita (saída) para pinos de LED pinMode (led_00, OUTPUT); pinMode (led_01, OUTPUT); pinMode (led_02, OUTPUT); pinMode (led_03, OUTPUT); pinMode (led_10, OUTPUT); pinMode (led_11, OUTPUT); pinMode (led_12, OUTPUT); pinMode (led_13, OUTPUT); pinMode (led_20, OUTPUT); pinMode (led_21, OUTPUT); pinMode (led_22, OUTPUT); pinMode (led_23, OUTPUT); pinMode (led_30, OUTPUT); pinMode (led_31, OUTPUT); pinMode (led_32, OUTPUT); pinMode (led_33, OUTPUT); read_tags (); atraso (1000); first_figure (); atraso (1000); Serial.end (); RFID.end (); atraso (5000); Serial.begin (9600); atraso (1000); RFID.begin (9600); atraso (1000); read_tags (); atraso (5000); //RFID.flush (); // interrompe várias leituras second_figure (); delay (1000); // id_type_matrix [0] [2] =2; // id_type_matrix [2] [1] =1;} // ------------------ --------------------------------- ÁREA DE FUNÇÕES --------------- --------------------------------------------- // --- ------------------------------------- Rastreamento de ID RFID e reconhecimento de figuras ------- ---------------------------------------- boolean compare_ID (int aa [14], int bb [14]) {boolean ff =false; int fg =0; para (int cc =0; cc <14; cc ++) {if (aa [cc] ==bb [cc]) {fg ++; }} if (fg ==14) {ff =true; } return ff;} int read_tags () {Serial.println ("Coloque a figura perto do leitor RFID"); atraso (5000); RFID.flush (); // interrompe várias leituras if (RFID.available ()> 0) {delay (300); para (int z =0; z <14; z ++) {ID =RFID.read (); new_id [z] =ID; Serial.println (new_id [z], DEC); atraso (500); }} Serial.println ("leitura de ID feita"); ++ contagem; atraso (5000); // hora de colocar a figura em um quadro e a segunda na frente de um readerreturn RFID new_id;} void first_figure () {if (compare_ID (new_id, queen_id) ==true) {Serial.println ("QUEEN IS DETECTED" ); for (int s =0; s <=3; s ++) {for (int t =0; t <=3; t ++) {if (digitalRead (hes_pin_matrix [s] [t]) ==0) {id_type_matrix [s ] [t] =1; temp_vect [0] =s; temp_vect [1] =t; Serial.print ("Queen é colocado em:"); Serial.print (s); Serial.println (t); digitalWrite (led_matrix [s] [t], HIGH); atraso (1000); digitalWrite (led_matrix [s] [t], LOW); }}}} else if (compare_ID (new_id, pawn_id) ==true) {Serial.println ("PAWN IS DETECTED"); for (int s =0; s <=3; s ++) {for (int t =0; t <=3; t ++) {if (digitalRead (hes_pin_matrix [s] [t]) ==0) {id_type_matrix [s ] [t] =2; temp_vect [0] =s; temp_vect [1] =t; Serial.print ("O peão é colocado em:"); Serial.print (s); Serial.println (t); digitalWrite (led_matrix [s] [t], HIGH); atraso (1000); digitalWrite (led_matrix [s] [t], LOW); }}}} else {Serial.println ("Figura indefinida"); }} void second_figure () {if (compare_ID (new_id, queen_id) ==true) {Serial.println ("QUEEN IS DETECTED"); for (int s =0; s <=3; s ++) {for (int t =0; t <=3; t ++) {if (digitalRead (hes_pin_matrix [s] [t]) ==0 &&(s! =temp_vect [0] || t! =temp_vect [1])) {id_type_matrix [s] [t] =1; Serial.print ("Queen é colocado em:"); Serial.print (s); Serial.println (t); digitalWrite (led_matrix [s] [t], HIGH); atraso (1000); digitalWrite (led_matrix [s] [t], LOW); }}}} else if (compare_ID (new_id, pawn_id) ==true) {Serial.println ("PAWN IS DETECTED"); for (int s =0; s <=3; s ++) {for (int t =0; t <=3; t ++) {if (digitalRead (hes_pin_matrix [s] [t]) ==0 &&(s! =temp_vect [0] || t! =temp_vect [1])) {id_type_matrix [s] [t] =2; Serial.print ("O peão é colocado em:"); Serial.print (s); Serial.println (t); digitalWrite (led_matrix [s] [t], HIGH); atraso (1000); digitalWrite (led_matrix [s] [t], LOW); }}}}} // ------------------------------------------- ---- ENCONTRANDO FIGURAS -------------------------------------------- ----------------------------- // função extra para desligar leds somente quando você colocar a figura de volta no tabuleirovoid leds_off () {int i, j; para (i =0; i <=3; i ++) {para (j =0; j <=3; j ++) {digitalWrite (matriz_ded [i] [j], BAIXO); }}} // --------------------------------------------- ---- MOVING QUEEN -------------------------------------------- -------------------------------------------------- --evite move_queen () {int i, j; para (i =vazios_pos [0]; i <3;) {digitalWrite (led_matriz [++ i] [vazios_pos [1]], ALTO); // acende ao longo de uma linha vertical} for (i =empty_pos [0]; i> 0;) {digitalWrite (led_matrix [- i] [empty_pos [1]], HIGH); } para (i =vazios_pos [1]; i <3;) {digitalWrite (led_matriz [vazios_pos [0]] [++ i], ALTO); // acende ao longo de uma linha horizontal} para (i =empty_pos [1]; i> 0;) {digitalWrite (led_matrix [empty_pos [0]] [- i], HIGH); } i =vazios_pos [0]; j =vazios_pos [1]; para (i =i - 3, j =j - 3; i <=3, j <=3; i ++, j ++) {if (i> =0 &&j> =0 &&i! =empty_pos [0]) { Serial.print (i); Serial.println (j); digitalWrite (led_matrix [i] [j], HIGH); }} i =vazios_pos [0]; j =vazios_pos [1]; para (i =i + 3, j =j - 3; i> =0, j <=3; i--, j ++) {if (i> =0 &&i <=3 &&j> =0 &&j <=3 &&i! =Vazio_pos [0]) {Serial.print (i); Serial.println (j); digitalWrite (led_matrix [i] [j], HIGH); }}} // ------------------------------------- começar a ler o número de figuras e salvar as posições para cada um deles -------------------------- void figure_reading () {// leia todas as posições em um loop para detectar a posição de um peão int i, j, found_figure =0; start:found_figure =0; // ler todas as posições ocupadas (0) e vazias (1) no tabuleiro // atribuir 0 (=quadrado vazio), 1 (=quadrado ocupado) a uma variável hes_bool_matrix [0] [0] =digitalRead (hes_00); hes_bool_matrix [0] [1] =digitalRead (hes_01); hes_bool_matrix [0] [2] =digitalRead (hes_02); hes_bool_matrix [0] [3] =digitalRead (hes_03); hes_bool_matrix [1] [0] =digitalRead (hes_10); hes_bool_matrix [1] [1] =digitalRead (hes_11); hes_bool_matrix [1] [2] =digitalRead (hes_12); hes_bool_matrix [1] [3] =digitalRead (hes_13); hes_bool_matrix [2] [0] =digitalRead (hes_20); hes_bool_matrix [2] [1] =digitalRead (hes_21); hes_bool_matrix [2] [2] =digitalRead (hes_22); hes_bool_matrix [2] [3] =digitalRead (hes_23); hes_bool_matrix [3] [0] =digitalRead (hes_30); hes_bool_matrix [3] [1] =digitalRead (hes_31); hes_bool_matrix [3] [2] =digitalRead (hes_32); hes_bool_matrix [3] [3] =digitalRead (hes_33); for (i =0; i <=3; i ++) {for (j =0; j <=3; j ++) {if (hes_bool_matrix [i] [j] ==0) {found_figure ++; if (found_figure ==1) {if (id_type_matrix [i] [j] ==0) {id_type_matrix [i] [j] =temp; temp =0; } if (id_type_matrix [i] [j] ==1) {Serial.print ("Queen is standing on:"); Serial.print (i); Serial.println (j); figura_pos [0] [0] =i; figura_pos [0] [1] =j; } else if (id_type_matrix [i] [j] ==2) {Serial.print ("O peão está em pé:"); Serial.print (i); Serial.println (j); figura_pos [0] [0] =i; figura_pos [0] [1] =j; // if (id_type_matrix [i] [j] ==0) {// id_type_matrix [i] [j] =temp; // temp =0; }}}} else if (found_figure ==2) {if (id_type_matrix [i] [j] ==0) {id_type_matrix [i] [j] =temp; temp =0; } if (id_type_matrix [i] [j] ==1) {Serial.print ("Queen is standing on:"); Serial.print (i); Serial.println (j); figura_pos [1] [0] =i; figura_pos [1] [1] =j; // if (id_type_matrix [i] [j] ==0) {// id_type_matrix [i] [j] =temp; // temp =0; }} else if (id_type_matrix [i] [j] ==2) {Serial.print ("O peão está em pé:"); Serial.print (i); Serial.println (j); figura_pos [1] [0] =i; figura_pos [1] [1] =j; // if (id_type_matrix [i] [j] ==0) {// id_type_matrix [i] [j] =temp; // temp =0; } // goto out; }}}}} out:if (found_figure ==0 || found_figure ==1) {goto start; } else if (found_figure ==2) {leds_off (); } //---------------------------------------------- nós escolha qual figura escolher --------------------------------------------- -------------------- empty_pos [0] =-1; atraso (2000); if (digitalRead (hes_pin_matrix [figure_pos [0] [0]] [figure_pos [0] [1]]) ==1) {empty_pos [0] =figure_pos [0] [0]; empty_pos [1] =figure_pos [0] [1]; temp =id_type_matrix [empty_pos [0]] [empty_pos [1]]; id_type_matrix [empty_pos [0]] [empty_pos [1]] =0; } else if (digitalRead (hes_pin_matrix [figure_pos [1] [0]] [figure_pos [1] [1]]) ==1) {empty_pos [0] =figure_pos [1] [0]; empty_pos [1] =figure_pos [1] [1]; temp =id_type_matrix [empty_pos [0]] [empty_pos [1]]; id_type_matrix [empty_pos [0]] [empty_pos [1]] =0; } // ------------------------------------------- MOVING PAWN ou QUEEN -------------------------------------------------- -------------------------------------------------- if (temp ==1) {if (empty_pos [0]! =-1) {move_queen (); goto start; }} else if (temp ==2) {if (empty_pos [0]! =-1) {if (empty_pos [0] <2) {digitalWrite (led_matrix [empty_pos [0] + 1] [empty_pos [1]] , ALTO); digitalWrite (led_matrix [empty_pos [0] + 2] [empty_pos [1]], HIGH); } else if (empty_pos [0] ==2) {digitalWrite (led_matrix [empty_pos [0] + 1] [empty_pos [1]], HIGH); } senão; } delay (100);} figure_reading ();} // ------------------------------------ --------------------------------- início do loop --------------- -------------------------------------------------- ------------------- void loop () {figure_reading ();}

Esquemas

Os esquemas são um pouco complicados, eu sei, mas a ideia deve ser clara. Foi a primeira vez que usei o Fritzing (altamente recomendado por sinal), provavelmente as conexões poderiam ser traçadas com mais precisão. De qualquer forma, anotei tudo dentro do esquema.

Nota:Não consegui encontrar o modelo exato do RDIF Reader entre os componentes do banco de dados do Fritzing. O modelo que usei é o módulo RFID 125Khz - UART. Você pode encontrar tutoriais no Youtube sobre como configurar este módulo com o Arduino. 4x4demo_q0nvG3T3nS.fzz

Ingegno Retro Games Console Construa uma viagem! Robot - Projeto Easy Starter para Crianças

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial