Ardu5 - Robô Educacional de Programação com Arduino (Integração com Scratch)

Robô com LEDs e Sensor LDR 

🤖 Aprendendo a Programar com Arduino: 

* Inspirado no Projeto do Professor García! 🚀

 

Olá, pessoal! Hoje trago para vocês um emocionante projeto de robô inspirado no trabalho do Professor García: o Robô Ardu5! 

Este robô é uma ótima maneira de aprender a programar com Arduino, e vou explicar todos os detalhes para vocês.

 

🔧 O Projeto:

O Robô com LEDs e Sensor LDR é uma criação incrível que apresenta um design simples e atrativo, perfeito para entusiastas da robótica e programação que desejam dar os primeiros passos no universo do Arduino. O robô possui cinco LEDs: três na barriga de 3mm, (verde, amarelo e vermelho), e dois nos olhos, que adicionam um charme especial ao projeto. Além disso, o robô conta com um sensor LDR (Light Dependent Resistor) posicionado acima da cabeça, que pode ser programado para detectar mudanças de luminosidade no ambiente.

 

🎯 Vantagens do Robô com LEDs e Sensor LDR e Programação com Arduino:

 

Versatilidade: Com cinco LEDs e o sensor LDR, o projeto do Robô proporciona uma experiência de aprendizado diversificada. Os LEDs da barriga por exemplo, permitem simular as luzes de um semáforo, e o sensor LDR possibilita interações com o ambiente, tornando o projeto mais envolvente.

Facilidade de Construção: Embora o projeto tenha algumas alterações referente ao projeto original mencionado, a montagem continua sendo simples e acessível para iniciantes. O uso do Arduino Uno facilita ainda mais o processo.

Aprendizado de Programação: Programar o Robô com LEDs e Sensor LDR é uma experiência educativa e divertida. Os iniciantes podem começar com códigos simples para controlar os LEDs e ler dados do sensor LDR. Conforme ganham confiança, podem explorar conceitos mais avançados.

Integração com Scratch e IDE do Arduino: A flexibilidade de programar o robô tanto na interface Scratch quanto na IDE do Arduino é uma vantagem significativa. Isso permite que jovens aprendizes se envolvam no projeto e aprendam conceitos de programação de forma lúdica.

Materiais necessários

(1) Arduino Uno

(1) PCI Placa de Circuito Impresso perfurado (6cm x 8cm ou 7cm x 9cm)

(1) Impressão da imagem do Ardu5 em papel A4 (couché 120g ou 150g)
(1) LDR 5mm
(2) LEDs vermelhos 5mm ou 10mm (usei 10mm) - Olhos
(3) LED azul, amarelo e verde de 3 mm ou 5mm (usei 5mm)
(1) Resistor de 1K ohm
(5) Resistores de 330 ohm
(1) Cabo de Rede par trançado (10cm)
(7) Pinos macho de 90 graus
(1) Pino fêmea.

* Cola de silicone (usada em artesanatos)

Cálculo da resistência para os leds

R = Va - Vled

    I

R = Resistência

Va = Tensão de alimentação (do Arduino)

Vled = Tensão do led

I = Corrente do Led em ampère

Calculando pela menor tensão do led, podemos ver o valor mínimo de resistência para cada led, que é de 160r:

R = 5V - 1.8V =  3.2V = 160Ω (NO MÍNIMO)

Polaridade dos LED´s

Pinos do Arduino

        Pin D8 =  LDR

        Pin D9 = led verde (5mm)

        Pin D10 = led amarelo (5mm)

        Pin D11 = led vermelho (5mm)

        Pin D12 = led olho direito (10mm)

        Pin D13 = led olho esquerdo (10mm)

        Pin Gnd = Terra 

OBSERVAÇÕES:

•A ligação dos 5 LEDs deve respeitar a polaridade, sempre a perna negativa ou mais curta voltada para a parte superior do Robô Ardu5.

• Os 6 resistores e o LDR não têm polaridade

•O LDR deve ser soldado na cabeça do robô.

•Os 7 pinos machos devem ser soldados à esquerda dos 8 orifícios dos pés do Ardu5.

•O único pino fêmea é soldado no orifício à direita dos pés Ardu5.

ARQUIVOS PARA DOWNLOAD

Códigos e tutorial

Imprimir em tamanho A4 (papel couché)
Desenho do Ardu5 está em escala real para ser recortado 

(8cm x 5,5cm) e colado na placa de circuito impresso.

Simulação do projeto no TinkerCad

Aulas usando o Scratch (S4A) do Professor Garcia

Baixe os Sprits das aulas aqui

CONTINUA ABAIXO, (CLIQUE EM "Mais informações")

Caveira Animatrônica com Arduino Uno - Tutorial

 

Projeto de Caveira Animatrônica com Arduino: Divertida e Interativa!

Olá, pessoal! Hoje eu vou apresentar um projeto super empolgante e criativo: a criação de uma Caveira Animatrônica utilizando Arduino e alguns componentes eletrônicos. Essa caveira é capaz de realizar movimentos nos olhos e na boca, tornando-a interativa e proporcionando uma experiência única e divertida.

A criação dessa caveira foi inspirada em uns 3 projetos que achei na internet, sendo que comecei a fazer a primeira versão com meus alunos do ensino fundamental, um projeto bem simples que foi baseado nesse projeto da Udemy criado por Marco T. Chella:

Robótica Criativa com Arduino e Scratch - I

https://www.udemy.com/course/roboticacriativa

Versão 1

A segunda versão foi em curso de formação que dei uma melhorada, adicionei os leds nos "olhos" e fantaziei de Papai Noel

:

Versão 2

A terceira versão pesquisei bastante e achei dois projetos interessantes, um foi no site Instructables: 
Interactive Skull de PeckLauros e outro do canal no youtube do Leandro Fellipe, no vídeo chamado: Uma caveira muito doida! Meu primeiro projeto com Arduino!

Versão 3

A Caveira Animatrônica é composta por dois LEDs vermelhos que servem como olhos e três micro servos motores. Os servos são responsáveis pelos movimentos dos olhos e da mandíbula, proporcionando movimentos realistas.

Para tornar essa caveira ainda mais especial, o projeto utiliza um sensor ultrassônico (HR-SC04) para detectar a proximidade de objetos em relação a ela. Isso permite que a caveira reaja de forma diferente conforme uma pessoa se aproxima ou se afasta. As animações dos olhos e da boca variam em velocidade e intensidade, criando uma experiência interativa e envolvente para quem estiver por perto.

O código foi especialmente desenvolvido para fins educacionais e de entretenimento, tornando o projeto uma ótima opção para quem deseja aprender mais sobre eletrônica, programação e Arduino. Com esse projeto, você poderá se divertir criando sua própria caveira animada e até mesmo explorar novas possibilidades de animatrônicos.

Para montar o projeto a maior dificuldade é achar uma caveira, a que eu usei comprei no Mercado Livre e é de uma coleção antiga da National Geografic, chamada O Corpo Humano: 

Caso não encontro tem outras opções de resina bem baratas por sinal, no mercado livre que você pode tentar usar e também pode encontrar em lojas especializadas em fantasias.

Os outros materiais são mais acessíveis e encontrados em lojas especializadas em eletrônica. O código também é fornecido neste post, e o tutorial em vídeo no meu canal do youtube, o que facilitará o processo de replicação e personalização do projeto.

Com esse projeto, você terá a oportunidade de criar uma atração única para festas temáticas, eventos especiais ou mesmo para presentear alguém que aprecie esse tipo de arte eletrônica.

Então, mãos à obra! Divirta-se construindo sua própria caveira animada e encante seus amigos com essa experiência interativa. Não se esqueça de conferir o canal do Laboratório Maker, e o Instagram para mais projetos eletrizantes!

Esperamos que você tenha gostado dessa proposta criativa e esteja ansioso para começar. Comente abaixo se já tem alguma ideia para personalizar sua caveira animatrônica ou compartilhe suas dúvidas. Até a próxima e boa diversão com a eletrônica!

Materiais Utilizados:

Caveira (com olhos, tampa, mandíbula e dentes)

Arduino Uno ou Similar (Usei o Uno depois coloquei o chip no Standalone/Zatino)

Capacitor Eletrolítico de 1000uF 16V

2x LED´s Vermelhos 5mm

2x Resistores 330r 

3x Micro servo motores

Sensor Ultrassônico HC-SR04

Fios flexíveis / Jumpers

Tubo termoretrátil fino

Cola Rápida

Cola Quente

Lacres ("Língua de sogra")

Manta Bidim preta

Fio rígido

Placa (PCB) de Circuito Impresso perfurada, para facilitar a montagem do circuito interno da caveira

Alicate, tesoura, microretifica(ideal)

Fonte de Celular 5V e no mínimo 1A.

Como calculei a corrente necessária

LEDs:

2 LEDs 5mm vermelhos com resistor em cada um. Supondo que o resistor limitador seja de 220 ohms (o valor exato depende da tensão e corrente desejadas), o consumo total para os LEDs será:

Corrente dos LEDs = 2 * (0,02A) = 0,04A (ou 40mA)

Servos:

3 servos SG90 9g com uma corrente nominal de 220mA cada e uma corrente de pico estimada em 2,5 vezes a corrente nominal:

Corrente dos servos = 3 * (0,22A) * 2,5 = 1,65A (ou 1650mA)

Sensor Ultrassônico:

O sensor ultrassônico HC-SR04 consome aproximadamente 15mA:

Corrente do sensor = 0,015A (ou 15mA)

Arduino Uno:

A corrente típica do Arduino Uno é de aproximadamente 50mA:

Corrente do Arduino = 0,05A (ou 50mA)

Agora, some todas as correntes:

Corrente total necessária = 0,04A (LEDs) + 1,65A (servos) + 0,015A (sensor) + 0,05A (Arduino) = 1,755A (ou 1755mA)

* Isso é no caso extremo, mas acredito que 1A já da conta.

OBSERVAÇÕES:

SOBRE OS SERVOS:

Usar um pino PWM para controlar um servo motor é preferível, pois permite movimentos mais suaves e precisos, já que o sinal PWM é projetado para esse propósito. Se você estiver usando um servo motor em outros pinos digitais que não são PWM, ainda será possível controlá-lo usando técnicas de temporização, mas isso pode exigir mais esforço e habilidades em programação. Portanto, quando possível, é melhor usar um pino PWM para controlar servo motores.

SOBRE O SENSOR:

O sensor de distância ultrassônico HC-SR04 não pode ser ligado aos pinos PWM do Arduino porque o sensor utiliza um protocolo de pulso simples para medir a distância, enquanto os pinos PWM geram sinais pulsados com largura de pulso variável. Isso pode causar interferência e imprecisão nas medições, pois o sensor requer uma resposta precisa no tempo para calcular a distância corretamente. Portanto, é recomendado conectar o sensor aos pinos digitais não PWM do Arduino para garantir uma comunicação adequada e confiável.

MINHAS CONEXÕES:

// BOCA:

int fechada = 140;

const int abertura1 = 110;

const int abertura2 = 90;

const int abertura3 = 70;  // Abertura máxima para não forçar o servo

// OLHOS:

const int olhoEsquerdoFora = 50;

const int olhoEsquerdoDentro = 130;

int olhoEsquerdoFrente = 90;

const int olhoDireitoFora = 130;

const int olhoDireitoDentro = 50;

int olhoDireitoFrente = 90;

// PINOS DO SENSOR:

const int trigPin = 8; // Pino de saída do sensor ultrassônico (trigger)

const int echoPin = 7;  // Pino de entrada do sensor ultrassônico (echo)

// PINOS DOS SERVOS:

const int olhoEsquerdoPin = 3; // Pino digital com PWM para o servo do olho esquerdo

const int olhoDireitoPin = 5;  // Pino digital com PWM para o servo do olho direito

const int mandibulaPin = 11;   // Pino digital com PWM para o servo da mandíbula

const int enderecoOlhos = 0; // Endereço na EEPROM para armazenar a posição dos olhos

const int enderecoMandibula = 2; // Endereço na EEPROM para armazenar a posição da mandíbula

// Define as distâncias de controle das animações.

const int distanciaLonge = 50; // Acima de 50 centímetros

const int distanciaMedia = 30; // Entre 30 e 50 centímetros

const int distanciaPerto = 15; // Menor ou igual a 15 centímetros

CÓDIGO PARA BAIXAR

O código está todo detalhado para melhor entendimento.

Até o próximo projeto!! :)

Usando uma matriz de LEDs 8 x 8 (1088AS) com Arduino Uno COM MAX7219

 

    Como criar 'Evil Eyes' (olhos malignos) animados usando um Arduino Uno e duas matrizes de LED vermelho 8x8 com chip driver MAX7219.

    O design é tal que uma animação pode ser criada de forma rápida e simples usando o Microsoft Excel para desenvolver graficamente cada quadro animado, gerar automaticamente o código 'C', 'soltá-lo' em um esboço de estrutura (EvilEyes2.ino) e fazer a compilação para visualizar os resultados da animação ao vivo em segundos. 

Uma vez que a animação está correta, muitas animações podem ser combinadas para execução assíncrona em um esboço de estrutura separado (EvilEyesN.ino) para usar mais leds.

Nesse projeto usei os seguintes componentes:

Baixe a biblioteca para o Arduino LedControl no GitHub:

https://github.com/wayoda/LedControl/releases

Conexões:

As partes são conectadas como mostrado acima, 'encadeadas' da esquerda para a direita em grupos de dois. No software, a posição 1 está à esquerda, movendo-se para a direita de forma incremental.

Nota 1: Lembre-se de que o Arduino alimenta a parte inferior da matriz de LED (IN) e o topo da matriz de LED (OUT) alimenta a parte inferior da próxima matriz de LED (IN) e assim por diante etc.

Referência:

Instructables Steve Quinn

Vídeo Tutorial do Excel (Youtube)

O vídeo acima fornece uma visão geral 'muito' breve de como criar a animação.

Tabela Original em Inglês (Excel) para criação dos olhos

Baixe a tabela em Português

OBS: No código no final dessa postagem, já tem uma animação pronta, caso queira mudar, siga os passos abaixo:

1. Abra a planilha 

2. Clique na aba 'Source'. Para cada par de cores de 'Olhos', tem o pixel VERMELHO correspondente na matriz de LED 8x8 para que seja iluminado para este quadro de animação. 

3. Uma vez concluído, vá para a aba 'Detais' e preencha quantas animações você gostaria de codificar. Em seguida, pressione o botão 'Generate Code'.

4. Após a conclusão da geração, a planilha muda para a aba 'Code'. Basta pressionar Ctrl-A para selecionar tudo e, em seguida, Ctrl-C para copiar todo o código para a área de transferência.

5. Abra a IDE do Arduino. Em seguida, cole por cima do código existente. Ctrl-V. 

6. Crie sua animação juntando vários quadros em um 'filme' (você só precisa usar o olho esquerdo como referência, o quadro escolhe automaticamente a próxima entrada na matriz para o olho direito), escolhendo quanto tempo deseja exibir o quadro e o brilho que você deseja que ele seja exibido na matriz 8x8.

7. Compile.

8. Repita os passos 6 e 7 até estar satisfeito com o seu 'filme'.

As instruções completas estão na planilha na aba marcada como 'Details'.

Observação: Para que a geração automática de código funcione, a planilha precisará ter as macros ativadas. Se você está preocupado com o VBA, mantenha as macros desativadas, abra a planilha e pressione Alt-F11. O editor VBA será aberto e você pode se certificar de que não há nada de errado no código.

SOBRE O CÓDIGO

Tem dois códigos:

O código EvilEyes2 é para usar com 2 matrizes de leds e o código EvilEyesN é para 3 ou mais.

Importante observar que no código original desses links, talvez seja necessário alterar uma parte do código, onde está escrito:

'prog_uchar' troque por 'const unsigned char'.

No arquivo EvilEyes2.ino, está na linha 69

e no arquivo EvilEyesN.ino está na linha 103.

Isto é devido a atualização do Arduino IDE

Montando o Filme

Um filme é apenas uma sequência de quadros animados;

A sequência de quadros é mantida em uma matriz de 'frames' 

('frameType' no esboço) ou 'movie' ('frameType movie[ ]' no esboço).

Cada 'frameType' tem três parâmetros:

int frameCount; // Um ​​ponteiro para o array contendo as animações que você acabou de projetar.

int frameDelay; // Um ​​valor de atraso em milissegundos indicando quanto tempo exibir este determinado quadro.

frameLuminance; // um valor 0...15 indicando o brilho para exibir este quadro.

Portanto, um filme é uma coleção de quadros;

frameType movie[ ] = { // Piscar {LeftEye2,6000,1}, {LeftEye2,5,1}, {LeftEye3,10,1}, {LeftEye4,10,1}, {LeftEye3,10,1}, {LeftEye2,5,1} };

Veja também um tutorial Matriz de Leds 8x8 SEM MAX7219

https://laboratoriomaker.blogspot.com/2023/02/usando-uma-matriz-de-leds-8-x-8-1088as.html

Código para o par de olhos:

// // D10 = Digital O/P CS Pin // D11 = Digital O/P Clock Pin // D12 = Digital O/P Data Pin // #include <avr/pgmspace.h> #include <LedControl.h> const int numDevices = 2; // number of MAX7219s used const int dataPin = 2; const int clkPin = 4; const int csPin = 3; LedControl lc=LedControl(dataPin,clkPin,csPin,numDevices); // Drop this code into Arduino development environment #define LeftEye1 0 #define RightEye1 1 #define LeftEye2 2 #define RightEye2 3 #define LeftEye3 4 #define RightEye3 5 #define LeftEye4 6 #define RightEye4 7 #define LeftEye5 8 #define RightEye5 9 #define LeftEye6 10 #define RightEye6 11 #define LeftEye7 12 #define RightEye7 13 #define LeftEye8 14 #define RightEye8 15 #define LeftEye9 16 #define RightEye9 17 #define LeftEye10 18 #define RightEye10 19 #define LeftEye11 20 #define RightEye11 21 #define LeftEye12 22 #define RightEye12 23 #define LeftEye13 24 #define RightEye13 25 #define LeftEye14 26 #define RightEye14 27 #define LeftEye15 28 #define RightEye15 29 #define LeftEye16 30 #define RightEye16 31 #define LeftEye17 32 #define RightEye17 33 #define LeftEye18 34 #define RightEye18 35 #define LeftEye19 36 #define RightEye19 37 #define LeftEye20 38 #define RightEye20 39 typedef struct { const unsigned char array1[8]; } binaryArrayType; binaryArrayType binaryArray[40] = { { // LeftEye1, 0 B01111110, B10000001, B10000001, B10011001, B10011001, B10000001, B10000001, B01111110 }, { // RightEye1, 1 B01111110, B10000001, B10000001, B10011001, B10011001, B10000001, B10000001, B01111110 }, { // LeftEye2, 2 B00000000, B00111100, B01000010, B01011010, B01011010, B01000010, B00111100, B00000000 }, { // RightEye2, 3 B00000000, B00111100, B01000010, B01011010, B01011010, B01000010, B00111100, B00000000 }, { // LeftEye3, 4 B00000000, B00111100, B00100100, B00110100, B00110100, B00100100, B00111100, B00000000 }, { // RightEye3, 5 B00000000, B00111100, B00100100, B00110100, B00110100, B00100100, B00111100, B00000000 }, { // LeftEye4, 6 B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00000000 }, { // RightEye4, 7 B00000000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000 }, { // LeftEye5, 8 B01111110, B10000001, B10000001, B10011001, B10011001, B10000001, B10000010, B01111100 }, { // RightEye5, 9 B01111100, B10000010, B10000001, B10011001, B10011001, B10000001, B10000001, B01111110 }, { // LeftEye6, 10 B01111110, B10000001, B10000001, B10011001, B10011001, B10000010, B10000100, B01111000 }, { // RightEye6, 11 B01111000, B10000100, B10000010, B10011001, B10011001, B10000001, B10000001, B01111110 }, { // LeftEye7, 12 B01111110, B11000001, B10000001, B10011001, B10011010, B10000100, B10001000, B01110000 }, { // RightEye7, 13 B01110000, B10001000, B10000100, B10011010, B10011001, B10000001, B11000001, B01111110 }, { // LeftEye8, 14 B00111110, B01000001, B10000001, B10011001, B10011010, B10000100, B01001000, B00110000 }, { // RightEye8, 15 B00110000, B01001000, B10000100, B10011010, B10011001, B10000001, B01000001, B00111110 }, { // LeftEye9, 16 B01111110, B10000001, B10000001, B10011001, B10011001, B10000001, B10000001, B01111110 }, { // RightEye9, 17 B01111110, B10000001, B10000001, B10011001, B10011001, B10000001, B10000001, B01111110 }, { // LeftEye10, 18 B01111110, B10000001, B10000001, B10000001, B10011001, B10011001, B10000001, B01111110 }, { // RightEye10, 19 B01111110, B10000001, B10000001, B10000001, B10011001, B10011001, B10000001, B01111110 }, { // LeftEye11, 20 B01111110, B10000001, B10000001, B10000001, B10011001, B10011001, B10000001, B01111110 }, { // RightEye11, 21 B01111110, B10000001, B10000001, B10000001, B10011001, B10011001, B10000001, B01111110 }, { // LeftEye12, 22 B01111110, B10000001, B10000001, B10000001, B10000001, B10011001, B10011001, B01111110 }, { // RightEye12, 23 B01111110, B10000001, B10000001, B10000001, B10000001, B10011001, B10011001, B01111110 }, { // LeftEye13, 24 B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10011001, B01111110 }, { // RightEye13, 25 B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10011001, B01111110 }, { // LeftEye14, 26 B00000000, B00111100, B01000010, B01000010, B01000010, B01011010, B00111100, B00000000 }, { // RightEye14, 27 B00000000, B00111100, B01000010, B01000010, B01000010, B01011010, B00111100, B00000000 }, { // LeftEye15, 28 B00000000, B00111100, B00100100, B00100100, B00100100, B00111100, B00111100, B00000000 }, { // RightEye15, 29 B00000000, B00111100, B00100100, B00100100, B00100100, B00111100, B00111100, B00000000 }, { // LeftEye16, 30 B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00000000 }, { // RightEye16, 31 B00000000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000 }, { // LeftEye17, 32 B00010000, B00010000, B00010000, B00010000, B00010000, B00010000, B00010000, B00000000 }, { // RightEye17, 33 B00000000, B00010000, B00010000, B00010000, B00010000, B00010000, B00010000, B00010000 }, { // LeftEye18, 34 B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10001101, B01111110 }, { // RightEye18, 35 B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10001101, B01111110 }, { // LeftEye19, 36 B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10000111, B01111110 }, { // RightEye19, 37 B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10000111, B01111110 }, { // LeftEye20, 38 B01111110, B10000001, B10000001, B10000001, B10000001, B10000011, B10000011, B01111110 }, { // RightEye20, 39 B01111110, B10000001, B10000001, B10000001, B10000001, B10000011, B10000011, B01111110 } }; typedef struct { int frameCount; // index pointer into binaryArray signifying animation frame int frameDelay; // Approx delay in MilliSeconds to hold display this animated frame int frameLuminance; // 0 ... 15, The intensity of the led matrix for a given frame } frameType; frameType movie[] = { // Blink {LeftEye1,6000,1}, {LeftEye2,5,1}, {LeftEye3,10,1}, {LeftEye4,10,1}, {LeftEye17,100,1}, {LeftEye4,10,1}, {LeftEye3,10,1}, {LeftEye2,5,1}, // Full wide again {LeftEye1,3000,2}, // Frown {LeftEye5,5,3}, {LeftEye6,5,4}, {LeftEye7,5,5}, {LeftEye8,4000,11}, {LeftEye7,5,5}, {LeftEye6,5,4}, {LeftEye5,5,3} }; void delayMillis(int milliseconds) { for(int i=0; i < milliseconds; i++) delayMicroseconds(1000); } void setup(){ for (int x=0; x<numDevices; x++){ lc.shutdown(x,false); //The MAX72XX is in power-saving mode on startup lc.setIntensity(x,1); // Set the brightness to default value lc.clearDisplay(x); // and clear the display } } void loop(){ lc.setIntensity(0,3); lc.setIntensity(1,3); while (true){ for (int a = 0; a < (sizeof(movie)/sizeof(frameType)); a++) { for (int i = 0; i < 8; i++) { lc.setRow(0,i, binaryArray[movie[a].frameCount].array1[i]); lc.setRow(1,i, binaryArray[movie[a].frameCount+1].array1[i]); lc.setIntensity(0,movie[a].frameLuminance); lc.setIntensity(1,movie[a].frameLuminance); } delayMillis(movie[a].frameDelay); } } }

Usando uma matriz de LEDs 8 x 8 (1088AS) com Arduino Uno SEM MAX7219

 

1088AS

Material

Neste projeto vamos precisar de:

Faça a figurinha da Copa Qatar para o seu filho(a) - Modelo para baixar

 

Foto do perfil retirada do site Pexels 

BAIXAR MODELO EM CORELDRAW

Arquivo em CorelDraw 2018 versão 20

OBS: O modelo da figurinha peguei no link da Rocketseat, onde o Mayk Brito ensina você a fazer sua figurinha "online":

Crie sua figurinha da copa (HTML + CSS + JS)

Baixei no formato "svg" a partir do figma e fiz algumas alterações, se quiser baixar meu modelo para colocar sua foto ou do seu filho(a) e imprimir como adesivo é só clicar no link acima e baixar. 

Como Funciona uma TV em Câmera Lenta - The Slow Mo Guys / (TV CRT, LCD, OLED) Cores RGB.

Vídeo muito interessante, recomendo!
obs: Ativar a legenda no youtube

Se você está lendo isto, você já viu uma tela. Mas, no entanto você REALMENTE a viu? De verdade? Não se preocupe, O Daniel Gruchy (Gav) irá ajudá-lo. 

Filmado com a Phantom Flex e Phantom V2511 entre 1.600 e 380.000 quadros por segundo.

Siga o Gav no Instagram 

Canal do Daniel no Youtube.

Criando um Script .bat para inicializar Programas, Arquivos, Navegador.... junto com o Windows

 

Primeiro passo  - Criar um arquivo com o bloco de notas e salvar com a extensão .bat

obs1:  O nome do arquivo bat é opcional

obs2: Caso não consiga ver a extensão do arquivo nas pastas é só habilitar da seguinte forma:

Segundo Passo - Abra o arquivo com o botão direito do mouse e clique em "editar":

Feito isso, você vai abrir o bloco de notas e colar o seguinte texto e alterar conforme sua necessidade:

obs: altere o caminho das pastas ou programas para o seu caso, esse código é só um exemplo.

@echo off :: Executa os programas: start C:\xampp\xampp-control.exe ::Para iniciar o Word: start winword.exe ::Para iniciar o Chrome: start Chrome.exe :: Abre os Arquivos ou Pastas: start C:\xampp\htdocs\cursophp\ ::Caminhos de diretórios(pastas) com espaços, usar aspas para abrir arquivos: start F:\"CURSOS PROGRAMAÇÃO\PHP\Guanabara - PHP"\PHPGuanabara.docx ::Caminhos de diretórios(pastas) com espaços, usar "-" e aspas para abrir pastas: start "-" "F:\CURSOS PROGRAMAÇÃO\JavaScript\Alura" :: Abre o navegador com as seguintes abas: start https://web.whatsapp.com/ start https://www.google.com.br exit

Caminhos de diretórios com espaços:
exemplo:  start "-" "F:\CURSOS PROGRAMAÇÃO\JavaScript\Alura"
O que acontece é que o comando start entende as primeiras aspas como o título de um eventual prompt de comando a ser aberto. 

Assim, quando tenho que usar aspas no caminho para esse comando (por conta dos espaços do caminho) preciso colocar um título qualquer antes. 

E o título é aquele tracinho.

Caminhos de diretórios com acentos:

exemplo:  start "-" "F:\CURSOS PROGRAMAÇÃO"

Se mesmo assim apresentar o erro acima por causa da acentuação, é só colocar esse código no começo da bat, pois ele converte os caracteres especiais para UTF-8:

@CHCP 65001

* UTF-8 é um tipo de codificação binária de comprimento variável criado por Ken Thompson e Rob Pike. Pode representar qualquer caractere universal padrão do Unicode, sendo também compatível com o ASCII. 

Agora para iniciar esse Script com o Windows, segure nas teclas "Windows" + "r" (ou digite "executar" em iniciar) e digite o comando: shell:startup

Clique em "OK" e cole esse arquivo bat dentro dessa pasta

Agora é só reiniciar o computador para ver se deu certo!

Sobre os comandos em Batch Script (script em lote):

Comando @echo off

@echo off

Por padrão, um arquivo em lote exibirá seu comando enquanto é executado. A finalidade deste primeiro comando é desligar esta exibição. O comando "echo off" desliga a exibição de todo o script, exceto o próprio comando "echo off". O sinal de "arroba" "@" na frente faz com que o comando também se aplique a si mesmo.

Comentários ::

:: Observações 

onde está escrito 'Observações' é o comentário a ser adicionado.

Comando START

START “programa”

Este comando inicia um programa em uma nova janela ou abre um documento.

Comando Exit

Exit 

Este comando sai do console do DOS.

Outros comandos no site: 

https://www.tutorialspoint.com/batch_script/

PYTHON, JSON no VSCode - Comando json.dump não codifica acentos (utf8)

 

Quando usamos o comando json.dump:

Exemplo:

json.dump(dict, arquivo_json, indent = 4)

 

Para converter um arquivo para json, o dump desconfigura os acentos, mesmo se o seu VSCode estiver configurado para utf8

Arquivo obtido após a conversão:

A palavra “Grifinória” ficou desconfigurada

Segue configurações da minha máquina:

VSCode - Versão: 1.66.2 (user setup)

Python 3.10

OS: Windows_NT x64 10.0.19044 (Windows 10)

 

SOLUÇÃO

Pesquisando na internet consegui chegar nessa solução que foi a única que resolveu meu problema:

Desabilitar o ASCII (Código Padrão Americano)

json.dump(dict, arquivo_json, ensure_ascii=False, indent=4)

 

Agora o arquivo foi convertido corretamente:

 

·        Acredito que o comando .dump está convertendo os caracteres de utf8 para ASCII, então colocando ele para False, ele mantem o utf8 (caractere universal padrão do Unicode, sendo também compatível com o ASCII).

 

Outras soluções que não resolveram o meu problema, mas podem ser úteis para outros casos:

Figura: parte inferior direita do VSCode

 

Verifique se o seu VSCode está configurado para UTF-8, em

Arquivo/Preferências/Configurações/Encoding

Em configurações do json:

Altere para utf8 e em files.autoGuessEncoding para True

 

Alterando as configurações de Região:

Windows + R, depois digite “control’ e OK.

Clique em 'Alterar formatos de data, hora ou número':

Aba: 'Administrativo/Alterar localidade do sistema/'

Habilitar o UTF-8 e depois OK.