Franzininho - Monte e Programe seu Próprio Arduino

Prévia do material em texto

Franzininho 
 
Monte e Programe 
seu Próprio Arduino 
 
 
 
Diana Santos e Fábio Souza 
 
 
 
 
 
 
 
 
2 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
São Paulo - 2018 
 
 
 
Editora: 
 
Instituto NCB 
www.newtoncbraga.com.br 
 
 
 
 
Diretor responsável: Newton C. Braga 
Coordenação: Renato Paiotti 
Impressão: AgBook – Clube de Autores 
 
http://www.newtoncbraga.com.br/
 
FÁBIO SOUZA e DIANA SANTOS 3 
 
 
FRANZININHO – MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
Autor: Fábio Souza 
São Paulo - Brasil - 2018 
 
Palavras-chave: Eletrônica - Engenharia Eletrônica - 
Componentes – Circuitos práticos – Franzininho – Arduino – Faça 
Você Mesmo – DIY 
 
 
 
 
 
 
 
 
 
Copyright by 
INTITUTO NEWTON C BRAGA. 
1ª edição 
 
 
 
 
 
 
 
 
 
 
 
 
Este obra está licenciado com uma Licença Creative Commons 
Atribuição-CompartilhaIgual 4.0 Internacional. 
 
 
 
 
4 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
Índice 
 
Apresentação 6 
Sobre o Projeto Franzininho 7 
Concepção e desenvolvimento 7 
Continuação pós Arduino Day 8 
Franzininho V2 10 
Comunidade 10 
Licença de Hardware da Franzininho 11 
Aviso Legal 11 
A estrutura da Franzininho DIY 12 
Versão da placa Franzininho V2RV0 13 
Identificando os Componentes 13 
Placa de Circuito impresso 13 
Capacitores 14 
Chave táctil 14 
Resistores 15 
LEDS 16 
Soquete 16 
Barra de pinos 17 
Regulador de Tensão 17 
Conector USB 17 
Attiny85-20P 18 
Pinagem das placas Franzininho 18 
Montando a Franzininho 19 
Montando a Versão V2RV0 19 
Programando o Franzininho 24 
Preparando o Gravador 24 
Gravação do bootloader Gemma 25 
Gravação do bootloader Micronucleus 27 
Gravando o Bootloader no Windows 29 
Gravando no Linux 31 
Instalando os Drivers no Computador 33 
 
 
FÁBIO SOUZA e DIANA SANTOS 5 
 
Configurando os Drivers para o Gemma 33 
Windows 33 
Linux 35 
MAC OSX 36 
Configuração dos drivers para Micronucleus 37 
Configuração dos drivers para Micronucleus 37 
Windows 37 
Linux 38 
Configuração Arduino IDE 39 
Digispark 40 
Upload do Sketch 42 
Programando a Franzininho 46 
Entradas e Saídas Digitais 46 
Configuração do modo de funcionamento do pino 46 
Exemplo 47 
Escrita em um pino digital 48 
Leitura de um pino digital 49 
Entradas Analógicas 50 
Função 51 
PWM 53 
O que é PWM? 53 
Usando as saídas PWM do Arduino 55 
Função 55 
I2C 56 
Exemplo: Leitura do sensor de temperatura DS1620 57 
Exemplos com a Franzininho 61 
Pisca LED 61 
Circuito 61 
Tecla Liga/Desliga 62 
Circuito 63 
Comunidade Franzininho 65 
Anexo A - Esquemático 66 
 
 
 
 
6 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
Apresentação 
 
Olá, o projeto Franzininho foi resultado da ligação de 
pontos na minha jornada. Sempre tive um pé na engenharia e 
outro na educação. Através de iniciativas open source e open 
hardware deixamos nossa contribuição para a comunidade. 
Espero que você possa inspirar a colocar a suas ideias em prática 
e nunca deixe de aprender. Lembre-se que compartilhar(ensinar) 
também é uma forma de aprendizado. 
 
Nesse livro, que escrevi com ajuda da minha parceira de 
vida, Diana Santos, tentamos deixar as informações para 
montagem e uso da Franzininho de uma forma mais clara. 
Como é nosso primeiro livro, ainda estamos aprendendo como 
organizar as informações. Caso encontre algum erro, sugestão de 
melhoria, ou crítica, por favor nos envie um e-mail para: 
contato@franzininho.com.br . 
 
Aproveito para deixar o convite para participar da 
comunidade Franzininho e acompanhar as nossas redes sociais 
e materiais on-line: 
 
www.franzininho.com.br 
 
 
Fábio Souza 
 
mailto:contato@franzininho.com.br
 
FÁBIO SOUZA e DIANA SANTOS 7 
 
Sobre o Projeto Franzininho 
 
Concepção e desenvolvimento 
 
A Franzininho foi desenvolvida para as atividades 
dentro do FAB LAB Livre SP durante o Arduino Day São Paulo 
2017. Thalis Antunes e Fábio Souza conceberam o projeto a partir 
do desafio de realizar atividades simultâneas nos 12 FABLABs 
livres em SP, em um Arduino Day realizado pela Prefeitura de São 
Paulo e com apoio de Embarcados, Fazedores e MinasUP. Como as 
atividades teriam apoio do ITS com os materiais, chegou-se a 
conclusão que seria melhor fazer placas compatíveis com Arduino 
para as pessoas montarem e terem experiência com solda. A 
condição era que o projeto fosse open hardware. A partir dos 
projetos de hardwares das placas Arduino Gemma e Digispark 
(placas open hardware) desenvolveu-se uma placa com 
componentes discretos e em face simples. 
 
 
Franzininho V0 
 
O circuito foi projetado pensando na fabricação usando 
máquinas CNCs ou através de processo de corrosão de PCI. Os 30 
técnicos se empenharam adaptaram o layout da Franzininho para 
o método de fabricação que tinham mais facilidade, foram feitas 
placas de diversas formas. 
 
 
8 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
Teste e validação do projeto dias antes do Arduino Day 2017 
 
No dia 01/04/17 (Dia do Arduino 2017) foram produzidas 
300 placas dentro dos 12 FAB LABs Livres SP. Foi incrível! 
 
 
Oficinas realizadas simultaneamente nos FabLabs durante o Arduino Day 
2017 em São Paulo 
 
 
Continuação pós Arduino Day 
 
Após o Arduino Day , o layout da PCB foi melhorado onde 
foram incluídos mais 2 furos e ajustado o tamanho da placa. 
Também foi melhorado o silk e incluída a bandeira do Brasil. 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 9 
 
 
Franzininho V0RV1 feita após o Arduino Day 
 
Para continuar, tínhamos o desafio de conseguir placas 
para novas oficinas, já que não é todo mundo que tem acesso as 
ferramentas de fabricação digital ou métodos caseiros. Para 
viabilizar a fabricação de placas Franzininho em uma empresa 
especializada, foi lançada uma espécie de compra coletiva pela 
comunidade, liderada por Fábio Souza. Nesta iniciativa foram 
feitas 600 placas, onde as pessoas tiveram acesso as placas com 
acabamento industrial. 
 
 
Primeiro lote de placas com acabamento industrial 
 
Dessas 600 placas diversas foram usadas para oficinas 
em hackerspaces , oficinas de solda, eventos. Com isso a 
comunidade só ganhou força. Com isso surgiram diversas 
contribuições da comunidade para o projetos, como: materiais 
 
 
10 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
para oficinas, layout, projetos e principalmente na documentação. 
A comunidade está crescendo cada vez mais e com diversas 
iniciativas. 
 
 
Franzininho V2 
 
Após um período trabalhando com a Franzininho V0RV1, 
foi desenvolvida uma nova versão com conector USB. Essa nova 
versão eliminou 2 problemas: facilitou a fabricação e orientação 
da placa ao conectá-la no computador. 
 
 
Franzininho V2 
 
A pinagem e funcionamento das duas versões são as 
mesmas. 
 
Comunidade 
 
Atualmente o projeto é liderado por Fábio Souza e Diana 
Santos, com apoio da comunidade. Todos os materiais 
desenvolvidos são publicados com licenças open source e 
publicamente, o que permitem que todos tenham acesso e 
possam usar como quiserem. 
 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 11 
 
Licença de Hardware da Franzininho 
O Hardware Franzininho foi publicada com a licença 
CC-SA-4.0, sendo um projeto open hardware que permite que 
qualquer pessoa possa: 
Estudar - Modificar - Construir - Distribuir - Vender. 
A proposta é que todos os interessados possam montar o 
seu Arduino compatível, entender como funciona, fazer projetos e 
contribuir para o desenvolvimentode um projeto open source. 
 
O nome Franzininho foi dado em continuação a 
placa open hardware que o Autor fez para sua 
palestra no Arduino Day de 2016, a Franzino. 
 
Aviso Legal 
O projeto é open hardware e publicado com uma licença 
que permite a venda por empresas sem a necessidade de pagar 
royalties ou obrigação de contribuir para a comunidade. 
As placas e kits oferecidos no comércio, são de 
responsabilidade das empresas que estão comercializado. Assim 
como o valor e negociação deve ser feito com eles. 
Qualquer material comercializado, oficinas, e projetos 
feitos com a Franzininho são de responsabilidade das pessoas e 
empresas que estão a frente da negociação. 
Nós tentaremos ficar em cima para manter a 
qualidade e metodologia de aplicação do projeto, porém 
não podemos garantir que as mesmas sejam garantidas. 
Sendo assim, caso tenha algum problema, antes de atacar 
o projeto Franzininho ou os seus idealizadores, verifique 
se não foi um problema da empresa ou responsável a 
frente da atividade. 
O projeto está em constante atualização, e está só no 
começo. Fica o convite para qualquer pessoa que queira 
colaborar, aprender, criar novas placas, para interagir na 
comunidade. Apesar de ser um projeto de hardware, diversas 
áreas podem somar para o projeto. 
 
 
12 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
A estrutura da Franzininho DIY 
 
A Franzininho DIY foi desenvolvida com a proposta de 
"Faça você mesmo" e com base na plataforma Arduino. Você 
trilhará a jornada do Maker de eletrônica, montando e 
programando a sua própria placa Arduino. 
Neste capítulo você encontra todas as informações para 
montagem e uso da sua placa Franzininho. Você conhecerá os 
componentes, o passo a passo da montagem e como configurar a 
IDE Arduino para programação. 
 
Hardware : Todo o projeto de 
hardware está disponível no Github: 
franzininho-diy-board. 
 
Referência Descrição 
C1 Capacitor Cerâmico 100 nF x 50 V 
C2 Capacitor eletrolítico 10 uF x 35 V 
D1 Diodo Zener 3,6 V 0,5W 
D2 Diodo Zener 3,6 V 0,5W 
D3 Diodo 1N4148 
IC1 Microcontrolador ATTINY85 - 20PU 
IC2 78L05 - Regulador de tensão 
SQ1 Soquete Para CI - 8 pinos 
JP3 Barra de pinos estampada 15 mm 180° - 8 vias 
J1 Barra de pinos estampada 15 mm 180° - 3 vias 
LED Led 3mm Amarelo Difuso 
ON Led 3mm Verde Difuso 
R1 Resistor 68 R - 5% 1/4 W 
R2 Resistor 68 R - 5% 1/4 W 
R3 Resistor 1K5 - 5% 1/4 W 
R4 Resistor 1K - 5% 1/4 W 
R5 Resistor 1K - 5% 1/4 W 
RESET Chave Táctil 6x6x5 mm 
USB Conector USB Macho 90º com trava 
PCB Placa de circuito impresso Franzininho V2 
 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 13 
 
Versão da placa Franzininho V2RV0 
 
Placa Franzininho DIY V2 
 
 
 
 
Identificando os Componentes 
 
Para deixar claro todo o funcionamento da Franzininho, 
precisamos conhecer um pouco dos componentes que compõem o 
projeto, assim poderemos fazer mudanças e aprimorar ainda 
mais este projeto. 
 
 
Placa de Circuito impresso 
A placa de circuito impresso é responsável por receber 
todos os componentes. Ela pode ser feita de fibra de vidro ou 
fenolite. Para a Franzininho DIY foi desenvolvida um projeto em 
face simples, o que permite a fabricação caseira. 
Na parte superior da placa (TOP) há os desenhos dos 
componentes, indicando a posição de cada um. O componentes 
são encaixados em seus respectivos locais e depois são soldados 
através da parte inferior (Bottom). 
 
 
14 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
TOP e Bottom da placa Franzininho DIY V2 
 
Capacitores 
Capacitores são dispositivos elétricos capazes de 
armazenar carga elétrica em um campo elétrico. Na Franzininho 
temos 2 tipos de capacitores. 
 
 
C1 - Capacitor Cerâmico 100 
nF x 50 V 
 
C2 - Capacitor eletrolítico 10uF 
x 35V 
 
 
 
Chave táctil 
É um botão de 
contato momentâneo. Na 
Franzininho usamos uma 
chave táctil NA (normalmente 
aberta) de 4,3 x 6 x 6 mm que 
tem a função de botão de 
Reset. 
 
Chave – RESET 
 
 
FÁBIO SOUZA e DIANA SANTOS 15 
 
Resistores 
Os resistores são componentes passivos que se opõem a 
passagem de corrente elétrica no circuito. Existem diversos tipos 
de resistores disponíveis. Na Franzininho DIY usamos resistores 
de carbono de 1/4 W. Os anéis coloridos indicam o valor e 
tolerância do resistor. 
 
Tabela Código de cores para resistores de 4 faixas 
Fonte: 
http://blog.render.com.br/eletronica/como-calcular-o-valor-de-um-resistor/ 
 
Na Franzininho usamos 5 resistores, com as seguintes 
referências e valores: 
 
http://blog.render.com.br/eletronica/como-calcular-o-valor-de-um-resistor/
 
16 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
R1 e R2 - 68 R (Azul, Cinza, Preto, 
Dourado) 
 
R3 - 1K5 (Marrom, Verde, 
Vermelho, Dourado) 
 
 
R4 e R5 - 1K (Marrom, Preto, 
Vermelho, Dourado) 
 
 
LEDS 
LED (Light Emitting Diode), é 
usado para a emissão de luz em locais e 
instrumentos onde se torna mais 
conveniente a sua utilização no lugar de 
uma lâmpada. 
Na Franzininho são usados dois 
leds difusos de 3 mm 
ON - LED Verde, 
LED - LED Amarelo 
 
 
 
Soquete 
Soquete é usado para o encaixe 
de circuitos integrados, facilitando a sua 
troca na placa. Na Franzininho usamos 
um soquete de 8 pinos para acomodar o 
Microcontrolador attiny85 IC1 – Soquete 
 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 17 
 
Barra de pinos 
São usadas para 
expansão de pinos e 
entrada de alimentação 
na placa. Na Franzininho 
usamos 3 vias para o 
conector de alimentação e 
8 vias para o conector de 
expansão da placa 
J1 - Barra de 3 pinos 
P0, P1...GND - Barra de 8 pinos 
 
Regulador de Tensão 
Usado para baixar a tensão 
de entrada para um nível que o 
circuito possa trabalhar. Na 
Franzininho usamos um regulador 
de tensão de 5V, o 78L05. 
 
 IC2 - 78L05 - Regulador de 
tensão 5V 
 
 
Conector USB 
Usado para conectar a placa 
ao computador ou a um circuito de 
alimentação com conector USB. Na 
Franzininho usamos um Conector 
USB Macho 90º com trava. 
 
Conector USB Macho 90º 
com trava 
 
 
 
 
 
18 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
Attiny85-20P 
 
Este é a parte central da 
placa , o microcontrolador Attiny85, 
onde o programa que criarmos será 
armazenado e executado. 
Attiny85-20PU 
Pinagem das placas Franzininho 
 
Pinagem da placa Franzininho versão V2RV0* 
 
*A pinagem de saída das versões anteriores são 
iguais a esta última versão, porém na versão V2RV0 
foi incluído conector de alimentação externa. 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 19 
 
Montando a Franzininho 
 
Antes de tudo você deve preparar o ambiente, separando 
as ferramentas necessárias para a soldagem, vamos precisar de: 
● Ferro de solda 
● Rolo de estanho 
● Alicate de corte etc. 
● Óculos de proteção 
 
Você também deve separar os componentes para deixar 
organizado, para que facilite na hora de soldar. Você encontra os 
componentes na lista de materiais. Tudo organizados, então 
vamos lá?! 
 
 
Montando a Versão V2RV0 
De início você terá uma placa sem componentes, 
conforme a imagem abaixo. 
 
 
 
Para deixarmos a montagem simples e limpa, 
aconselhamos primeiramente soldarmos dos diodos como na 
imagem abaixo. Procure na placa o local onde devemos encontrar 
a referênica D3, onde colocaremos o Diodo 1N4148. Feito isso , 
devemos soldar os dois Diodos Zeners nas referências D1 e D2. 
 
 
 
20 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
Agora iremos soldar os nossos resistores, o primeiro é o 
resistor de 60 ohms (as cores de marcação sãoazul, cinza, preto 
e dourado), este deve ser soldado na referência R1. O segundo 
resistor tem a mesma resistência (68 ohms) e deverá ser soldado 
em paralelo ao primeiro onde encontramos a referência R2. 
O terceiro resistor é de 1,5 KW (as cores de marcação 
são marrom, verde, vermelho e dourado), e deverá ser soldado 
na referência R3. 
Por último devemos soldar os resistores de 1 kW 
(marcação nas cores marrom, preto, vermelho e dourado), que 
estão em paralelo com as referências R4 e R5. 
 
 
 
O nosso próximo passo é soldarmos a chave de RESET e 
depois o soquete de 8 pinos onde iremos encaixar o nosso CI 
(IC1). 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 21 
 
 
 
Agora nós iremos soldar os LEDs e capacitor C1. Para 
isso localize na placa a referência ON e LED. Na referência ON 
soldamos o LED verde e na referência LED soldamos o LED 
amarelo. Vale salientar que os LED tem uma posição correta e a 
inserção errada destes inibe o funcionamento da placa. 
Agora precisamos soldar o nosso capacitor cerâmico na 
referência C1 , este se encontra perto dos diodos D1 e D3. 
 
 
Esta versão do Franzininho possui um regulador de 
tensão de 5 V, o usado é o CI 78L05 que deverá ser soldado na 
referência IC2. 
 
 
 
22 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
 
Nosso próximo passo é soldarmos os conectores de 3 e 8 
pinos. Localize na placa as referências J1 e a sequencia GND, VCC 
e P5 a P0. Na referência J1 soldamos a barra de 3 pinos e na 
outra a barra de 8 pinos conforme podemos ver na figura abaixo. 
 
 
Agora para finalizar vamos soldar o capacitor eletrolítico 
C2, lembrando que o positivo deve ser soldado na posição 
correta, o positivo fica o mais próximo da palavra Franzininho. 
Soldamos também o conector USB por onde faremos a 
comunicação entre o computador e a placa. 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 23 
 
 
 
Por último colocamos no soquete de 8 pinos o 
microcontrolador Attiny85. 
Agora é só plugar no computador e começarmos o nosso 
primeiro programa. 
 
 
 
 
 
24 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
Programando o Franzininho 
 
O microcontrolador usado no Franzininho, é o Attiny85, 
porém ele vem de fábrica totalmente limpo, sem nenhuma 
programação. Para que ele possa receber todas as programações 
que iremos criar é necessário prepará-lo , ou seja, gravar o 
bootloader. 
Precisaremos então de um computador, um Arduino que 
servirá de gravador, alguns fios que iremos conectar o arduino 
com uma placa de matriz de contato onde colocaremos o Attiny85 
e um capacitor eletrolítico para desacoplamento. 
Atualmente temos dois bootloaders possíveis para o uso 
da Franzininho. O primeiro é o usado no Arduino Gemma, que é 
mais simples de usar pois a IDE já vem preparada para a placa, 
onde não precisamos instalar pacotes adicionais. 
O segundo é o Micronucleus o qual pretendemos deixar 
como padrão no futuro, esse bootloader além de pequeno e bem 
flexível. É o mesmo usado na digispark e diversas outras placas 
que usam microcontroladores da família attiny. 
A seguir explicamos como instalar cada um deles, 
conforme a sua escolha. 
 
 
Preparando o Gravador 
 
Para gravarmos o bootloader precisamos montar o nosso 
gravador. Em nosso exemplo usaremos o Arduino Uno , mas é 
possível usar outros tipos de Arduino com AVR. 
Iremos conectar o computador ao Arduino Uno e com os 
fios tiremos conectar algumas portas do Arduino Uno à nossa 
matriz de contatos onde colocamos o microcontrolador Attiny, 
conforme o esquema da figura abaixo. 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 25 
 
 
Feitas as conexões, precisaremos configurar o Arduino 
Uno como um programador ISP. 
 
Caso não tenha IDE do Arduino 
(ambiente de programação) , acesse 
www.arduino.cc 
 
 
Gravação do bootloader Gemma 
 
O Arduino Gemma é uma criação da fabricante de placas, 
a Adafruit, e ela criou um bootloader próprio para o Attiny85. 
Você pode usar a Franzininho como se fosse um Arduino Gemma, 
 
 
26 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
para isso é só gravar esse bootloader no microcontrolador 
Attiny85. A Adafruit disponibiliza um sketch para a gravação do 
bootloader da Arduino Gemma e Trinket. 
 
Sketch – No mundo dos 
microcontroladores, “sketch” são 
programas ou parte de programas 
prontos que servem de “modelo” ou 
podem ser aplicados na íntegra nos 
microcontroladores, no bom estilo 
Copia e Colar. 
Bootloader da Adafruit: 
https://learn.adafruit.com/introducin
g-trinket/repairing-bootloader 
 
Neste exemplo utilizamos uma versão traduzida pelo 
“Mau Maker”. Você pode acessar o projeto disponibilizado na 
plataforma Arduino Create 
( https://create.arduino.cc/editor/maujabur/397f14ad-1fc1-49a5-
b9a8-2143fda15b35/preview ) . 
Você também pode baixar os arquivos que estão nesse 
repositório e gravar usando a IDE Arduino offline. 
O primeiro passo é fazer o upload do código para a 
Arduino UNO. 
Com as ligações feitas corretamente para a gravação do 
bootloader, abra o terminal serial, configure o baudrate para 
9600 bps, e envie a letra G para iniciar a gravação. Será exibida a 
seguinte mensagem: 
 
 
https://create.arduino.cc/editor/maujabur/397f14ad-1fc1-49a5-b9a8-2143fda15b35/preview
https://create.arduino.cc/editor/maujabur/397f14ad-1fc1-49a5-b9a8-2143fda15b35/preview
 
FÁBIO SOUZA e DIANA SANTOS 27 
 
 
Após a gravação do microcontrolador, você poderá 
retirá-lo da matriz de contatos e colocá-lo na Franzininho, mas 
lembre-se de colocar na posição correta. 
 
 
Gravação do bootloader Micronucleus 
Micronucleus é um bootloader desenvolvido para os 
microcontroladores AVR ATtiny que possuem restrição de 
interface USB, e baseado na ferramenta de programação 
multiplataforma o libusb, onde tem uma grande ênfase na 
compactação do bootloader, sendo o menor bootloader para 
microcontroladores AVR ATtiny. 
O Micronucleus é amplamente usado e instalado em 
milhares de dispositivos de hardware de código aberto: 
https://github.com/micronucleus/micronucleus/blob/mas
ter/Devices_with_Micronucleus.md 
Ele é opção ideal para a Franzininho e estamos 
trabalhando para padronizar esse bootloader para o nosso projeto 
(em andamento). 
A seguir vamos exibir como você pode gravar o ATtiny85 
 
https://github.com/micronucleus/micronucleus/blob/master/Devices_with_Micronucleus.md
https://github.com/micronucleus/micronucleus/blob/master/Devices_with_Micronucleus.md
 
28 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
para usar o Micronucleus. 
O primeiro passo é configurar a placa Arduino UNO como 
programador ISP. Para isso, na IDE do Arduino acesse Arquivo-> 
Exemplos->ArduinoISP->ArduinoISP 
 
 
 
Feito isso é só enviar o código para o Arduino Uno e ele 
estará configurado para ser um gravador AVR. 
O próximo passo é carregar o bootloader que iremos usar 
e enviar para o Attiny85, e para isso usaremos o firmware do 
Micronucleous , onde podemos encontrar no endereço 
https://github.com/micronucleus/micronucleus ou 
https://github.com/micronucleus/micronucleus/archive/master.zip 
Salve o arquivo no seu computador, descompacte e 
procure pela pasta: micronucleus\firmware\releases . 
Utilizaremos o arquivo: t85_default.hex 
 
 
 
 
https://github.com/micronucleus/micronucleus
https://github.com/micronucleus/micronucleus/archive/master.zip
 
FÁBIO SOUZA e DIANA SANTOS 29 
 
Gravandoo Bootloader no Windows 
Abra o prompt de comando e vá até o diretório onde está 
o Arduino. 
 
 
Agora vamos preparar o comando para gravar usando o 
avrdude: 
 
C:\arduino-1.8.2\hardware\tools\avr/bin/avrdud
e -C 
C:\arduino-1.8.2\hardware\tools\avr/etc/avrdude.conf -v 
-pattiny85 -cstk500v1 -PCOM3 -b19200 
-Uflash:w: C:\Users\fabio\Downloads\Arduino\micronucleu
s\firmware\releases/t85_default.hex:i 
 
Você precisa substituir as partes em negrito no comando 
acima, conforme os caminhos para os arquivos em seu 
computador. 
Verifique em qual porta a placa está conectada e 
substitua no comando PCOM3 . 
Certifique-se que a placa está conectada corretamente ao 
PC, assim como a ATtiny85 no Arduino Uno. 
Copie o código e cole no prompt e pressione enter. Será 
iniciada a gravação: 
 
 
30 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 31 
 
 
 
Após a gravação do microcontrolador, você poderá 
retirá-lo da matriz de contatos e colocá-lo na Franzininho, mas 
lembre-se de colocar na posição correta. 
 
 
 
Gravando no Linux 
Abra o terminal: 
Agora vamos preparar o comando para gravar usando o 
avrdude: 
 
/home/fabio/Downloads/arduino-1.8.5/hardware
/tools/avr/bin/avrdude -C 
/home/fabio/Downloads/arduino-1.8.5/hardware/tools/a
vr/etc/avrdude.conf -v -pattiny85 -cstk500v1 -P/dev/ttyACM0 
-b19200 
-Uflash:w: /home/fabio/Downloads/micronucleus-master/f
irmware/releases/t85_default.hex:i 
 
Você precisa substituir as partes em negrito no comando 
acima, conforme os caminhos para os arquivos em seu 
computador. 
Verifique em qual porta a placa está conectada e 
substitua no comando ttyACM0 . No meu caso está na ttyACM0 e 
no seu computador pode ser diferente. 
Certifique-se que a placa está conectada corretamente ao 
PC, assim como a ATtiny85 no Arduino Uno. 
Copie o código e cole no terminal e pressione enter: 
 
 
 
32 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
 
Será iniciada a gravação: 
 
 
 
Após a gravação do microcontrolador, você poderá 
retirá-lo da matriz de contatos e colocá-lo na Franzininho, mas 
lembre-se de colocar na posição correta. 
 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 33 
 
Instalando os Drivers no 
Computador 
 
Até aqui você possui a placa pronta, gravou o bootloader 
no microcontrolador através do seu Arduino e colocou o 
microcontrolador na placa. 
Agora precisamos instalar os drivers necessários para 
que você possa utilizar os seus códigos na Franzininho. Os drivers 
são códigos que servem para capturar o seu código, 
transformá-lo numa sequência binária, com as devidas posições 
de memória e portas para aquele determinado microcontrolador, 
em nosso caso o Attiny85. Mas como vimos no capítulo anterior , 
nós usamos dois tipos de bootloader, o Gemma e o Micronucleus, 
dependendo do qual você escolheu , um tipo de driver deverá ser 
instalado. Outro ponto que devemos ver é o tipo de sistema 
operacional que o seu computador possui. 
A seguir iremos detalhar cada um deles. 
 
 
Configurando os Drivers para o Gemma 
 
Windows 
Antes de usar a placa você precisa instalar o driver para 
o Windows. 
Baixe o driver: 
https://github.com/adafruit/Adafruit_Windows_Drivers/r
eleases/download/2.2.0/adafruit_drivers_2.2.0.0.exe 
E depois instale: 
 
 
34 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
 
Na próxima tela escolha a opção: Trinket / Pro Trinket 
/ Gemma (USBtinyISP): 
 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 35 
 
Depois da instalação terminar, precisamos saber se o 
computador irá reconhecer a placa Franzininho, para isso insira a 
placa no computador e veja se a mesma é reconhecida no 
gerenciador de dispositivos : 
 
 
 
Caso por algum motivo não dê certo a instalação, faça o 
download dos arquivos e mande instalar buscando os arquivos na 
pasta. Faça o download aqui : 
https://github.com/adafruit/Adafruit_Windows_D
rivers/archive/2.0.0.0.zip 
 
 
 
Linux 
Para usar com a maioria das distribuições Linux é 
necessário configurar algumas regras udev. Essa configura a USB 
para que seja programada pela Arduino IDE. 
Para instalar as regras, você precisará baixá-las e 
copiá-las para o local das regras do udev em seu sistema. Para a 
maioria dos sistemas Linux, como o Ubuntu, etc., as regras do 
udev são armazenadas em /etc/udev/rules.d/ (verifique a 
documentação da distribuição / fóruns de ajuda se você não 
encontrar essa pasta). Execute os seguintes comandos: 
 
 
 
36 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
wget 
https://raw.githubusercontent.com/Franzininho/Franzinin
ho-Linux/master/franzininho-gemma.rules 
sudo cp franzininho-gemma.rules /etc/udev/rules.d/ 
 
Em seguida, você precisará recarregar as regras do udev 
para que elas sejam aplicadas corretamente. Você pode reiniciar 
sua máquina ou executar um comando como o seguinte: 
 
sudo reload udev 
 
Se o comando acima falhar, tente executar: 
 
sudo udevadm control --reload-rules 
sudo udevadm trigger 
 
E se isso ainda falhar, reinicialize seu sistema, pois ele 
garantirá que o udev ative a nova configuração. 
Você também pode adicionar-se ao grupo de dialout com 
sudo usermod -a -G dialout $USER 
ou 
sudo usermod -a -G plugdev $USER 
 
Fonte: 
https://learn.adafruit.com/adafruit-arduino-ide-setup/linux-setup 
 
 
MAC OSX 
 
Se você estiver usando o Mac OS Mavericks, Yosemite ou 
mais atual, talvez seja necessário atualizar a configuração para 
permitir a execução do Arduino IDE. 
● Abra as Preferências do Sistema no Menu Apple. 
● Abra o painel de controle Segurança e Privacidade. 
● Clique na guia Geral. 
● Clique no ícone de bloqueio e faça o login 
 
 
FÁBIO SOUZA e DIANA SANTOS 37 
 
● Alterar Permitir Aplicativos Transferidos De Para Qualquer 
Lugar 
● Abra o IDE baixado. 
● Volte para as preferências de segurança e mude a seleção 
de volta para a Mac App Store e os desenvolvedores 
identificados 
● Você só precisa passar por esse procedimento uma vez. 
Mavericks vai lembrar que não há problema em executar o 
aplicativo. 
● É isso aí, você está pronto para começar a usar o Arduino 
IDE com a placa Arduino Gemma no OSX! 
 
Fonte: 
https://learn.adafruit.com/adafruit-ar
duino-ide-setup/mac-osx-setup 
 
 
 
Configuração dos drivers para 
Micronucleus 
 
Se você está usando o Micronucleus como bootloader e 
as bibliotecas da Digispark, precisamos executar as configurações 
a seguir. 
 
Configuração dos drivers para Micronucleus 
Se você está usando o Micronucleus como bootloader e 
as bibliotecas da Digispark, faça as configurações a seguir: 
 
Windows 
 
Precisamos fazer o download do driver no link abaixo: 
https://github.com/digistump/DigistumpArduino/
releases/download/1.6.7/Digistump.Drivers.zip 
 
 
https://learn.adafruit.com/adafruit-arduino-ide-setup/mac-osx-setup
https://learn.adafruit.com/adafruit-arduino-ide-setup/mac-osx-setup
 
38 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
Descompacte e instale o arquivo. Vale lembrar que para 
Windows 32 bits é necessário executar o arquivo DPinst.exe e se 
estiver usando o Windows 64 bits executar o arquivo 
DPinst64.exe 
 
Fonte: 
http://digistump.com/wiki/digispark/t
utorials/connecting 
 
Linux 
 
Para o Linux Troubleshooting baixe o arquivo no link: 
http://digistump.com/wiki/digispark/tutorials/linuxtroubleshootin
g 
 
 
http://digistump.com/wiki/digispark/tutorials/connecting
http://digistump.com/wiki/digispark/tutorials/connecting
http://digistump.com/wiki/digispark/tutorials/linuxtroubleshooting
http://digistump.com/wiki/digispark/tutorials/linuxtroubleshootingFÁBIO SOUZA e DIANA SANTOS 39 
 
Configuração Arduino IDE 
 
Com a instalação dos devidos drivers no computador, 
precisamos configurar o Arduino IDE, o nosso compilador para o 
Arduino. Como desde o começo do livro estamos utilizando o 
Bootloader do Gemma e do Micronucleus/Digispark, precisaremos 
configurar” o Arduino IDE para compilar os nossos códigos 
corretamente para a Franzininho. 
Para configurar o Arduino IDE para compilar os códigos 
para o Arduino Gemma, clique em “Ferramentas” na barra de 
menus, depois clique em “Placas” e finalmente procure a placa 
“Arduino Gemma” na lista que aparecer. 
 
 
 
Agora precisamos informar ao Arduino IDE qual é o 
programador que iremos utilizar, e neste caso clique em 
“Ferramentas” na barra de menu, depois clique em 
“Programador” e escolha na lista que aparecer “Arduino Gemma”. 
 
 
40 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
 
Pronto, acabamos de configurar a placa e o programador 
que utilizaremos para criarmos os programas que serão utilizados 
na Franzininho que utiliza o bootloader da Arduino Gemma. Agora 
o próximo passo é fazer o upload do seu sketch para a placa. 
 
 
Digispark 
Com o micronucleus gravado no Attiny85 você pode 
programar a Franzininho usando o pacote de software 
desenvolvidos para a digispark. Para isso, você precisa instalar o 
pacote de suporte da Digispark na Arduino IDE (É necessário 
estar conectado a internet). Acesse o menu 
Arquivos->preferências e cole a URL a seguir para gerenciador 
de placas: 
http://digistump.com/package_digistump_index.json 
 
http://digistump.com/package_digistump_index.json
 
FÁBIO SOUZA e DIANA SANTOS 41 
 
 
Agora acesse o menu: Ferramentas-> Placa -> 
Gerenciador de Placas. Aguarde alguns segundos até 
atualização da lista de pacotes e digite "digi". Aparecerá o 
pacote “Digistump AVR Boards” e clique em instalar. 
 
 
Aguarde o fim da instalação e clique em fechar. 
Agora na barra de menu clique em “Ferramentas” , 
depois e “Placas” , no menu que aparecer escolha a opção 
“Digispark (Default - 16.5mhz)” . 
 
 
42 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
Depois acesse através da mesma barra de menu o item 
“Ferramentas” , depois em “Programador” e na lista que 
aparecer selecione a opção “Micronucleus”. 
 
 
 
 
Pronto a IDE está pronta para programar a placa. 
 
 
Upload do Sketch 
 
Agora o nosso próximo passo é fazer o upload do Sketch 
para a Franzininho, ou seja, iremos gravar na Franzininho os 
programas que faremos mais adiante. Primeiramente vamos 
gravar um código ou Sketch sem nada dentro, só para 
aprendermos como fazer. 
Então precisamos conectar a nossa placa ao computador, 
de agora em diante não precisaremos mais da utilização de uma 
placa de Arduino para fazer a intermediação entre o computador 
e a Franzininho, uma vez que já gravamos o Bootloader na 
Franzininho. 
 
 
FÁBIO SOUZA e DIANA SANTOS 43 
 
Os primeiros passos para fazermos o upload do nosso 
Sketch é igual para os dois tipos de bootloader, tanto a Gemma 
como o Micronucleus, somente na hora das mensagens que 
ambos apresentam que são diferentes. 
Abaixo temos um esquema de como podemos fazer essa 
conexão para ambos os casos. 
Primeiramente conecte a sua Franzininho ao seu 
computador via cabo USB. 
 
 
 
Agora é necessário “Resetar” a placa. 
 
 
Na tela do Arduino IDE clique no botão “Upload” 
(Carregar). Com esse comando o computador irá gravar na 
Franzininho o Sketch. 
 
Assim que o Sketch vai sendo compilado e gravado na 
Franzininho, uma tela irá informando linha a linha o que está 
 
 
44 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
sendo feito. É aqui que as coisas tomam rumo diferentes. Caso 
você tenha optado pelo Bootloader da Gemma, aparecerá a tela a 
seguir. 
 
 
 
Caso você tenha optado pelo Bootloader da Micronucleus 
– Digispark a seguinte tela aparecerá. Caso a placa não esteja 
conectada, você tem até 60 segundos para conectá-la. 
 
 
 
Assim que Sketch estiver totalmente gravado, uma 
mensagem aparecerá como o da figura abaixo, caso tenha 
escolhido o Bootloader da Gemma. 
 
Caso tenha escolhido o Bootloader da Micronucleus – 
Digispark , aparecerá a tela apresentada abaixo. 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 45 
 
 
 
Pronto, agora você poderá utilizar a sua Franzininho. 
 
 
 
 
46 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
Programando a Franzininho 
 
Neste capítulo aprenderemos a programar a Franzininho, 
e uma dica interessante para quem está iniciando neste mundo 
da programação, é buscar leituras sobre Lógica de Programação. 
 
Entradas e Saídas Digitais 
Na Franzininho temos 6 pinos que podem ser usados com 
entradas ou saídas digitais(P0 a P5), conforme pinout: 
 
Pinagem Franzininho V2 (verificar limitações de uso dos pinos) 
 
 
Configuração do modo de funcionamento do pino 
Os pinos do ATtiny85 podem ser configurados como 
entradas ou saídas, além de outras funções. Para configuração 
com entrada ou saída vamos usar a seguinte função: 
 
 
FÁBIO SOUZA e DIANA SANTOS 47 
 
 
pinMode() 
Função que configura um pino específico para ser entrada 
ou saída digital. 
 
Sintaxe: 
pinMode(pino, modo); 
 
Parâmetros: 
pino -> corresponde ao pino que você irá usar, no caso 
da Franzininho podemos usar pinos de 0 a 5. 
modo -> deve-se colocar o modo que deseja configurar 
o pino: 
INPUT = Entrada onde ele fica aguardando um sinal. 
OUTPUT = Saída onde aparece um sinal do pino para 
ativar um circuito externo. 
INPUT_PULLUP = Entrada digital com resistor de 
pull-up (ligado ao VCC) interno habilitado; 
 
Exemplo 
Vamos configurar pino P0 para leitura de uma tecla, 
portanto será uma entrada digital. Também vamos configurar o 
pino P1 para acionamento do LED, ou seja, uma saída digital: 
 
int tecla = 0; //pino da tecla 
int LED = 1; //pino do LED 
 
void setup () { 
 pinMode(tecla, INPUT); //configura pino da tecla como entrada 
 pinMode(LED, OUTPUT); //configura pino do LED como saída 
} 
 
void loop(){ 
} 
 
Geralmente as configurações são realizadas dentro da 
função setup() . Na função loop são realizadas as tarefas durante 
o funcionamento da placa, como veremos mais à frente. 
 
 
48 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
Escrita em um pino digital 
Os pinos digitais configurados como saídas digitais 
podem assumir dois valores, conforme a escrita no código. Os 
valores podem ser HIGH ou LOW, que se traduzem em 5V ou 0V 
no pino da Franzininho. Para escrita digital vamos usar a seguinte 
função: 
 
digitalWrite() 
Função que coloca um nível lógico Alto (HIGH, 5V) ou 
baixo (LOW, 0V) em um pino configurado como saída digital. 
 
Sintaxe: 
digitalWrite(pino, valor) 
 
Parâmetros: 
pino: Número correspondente ao pino; 
 
valor: HIGH OU LOW 
 
Exemplo 
Inverte o estado do LED (P1) em intervalos de 1 
segundo: 
const int LED = 1; //pino digital conectado ao LED 
 
void setup(){ 
 pinMode(LED,OUTPUT); //pino digital de saída 
} 
 
void loop(){ 
 digitalWrite(LED,HIGH); //acende o led da placa 
 delay(1000); //aguarda um segundo 
 digitalWrite(LED,LOW); //apaga o led da placa 
 delay(1000); //aguarda um segundo 
} 
 
A função delay(ms) espera um tempo em milisegundos. 
No caso do exemplo acima, 1000 ms = 1 segundo. 
 
 
FÁBIO SOUZA e DIANA SANTOS 49 
 
Leitura de um pino digital 
Um pino digital pode assumir dois valores,HIGH e LOW, 
conforme o nível de tensão presente no mesmo: 5V ou 0V. 
Podemos usar o pino configurado como entrada digital para ler 
estados de sensores, que por sua vez representam estados de 
situações, por exemplo: 
● botão solto ou pressionado; 
● porta aberta ou fechada 
● presença de objeto ou não presença de objeto 
 
Para leitura de uma entrada digital usamos a seguinte 
função: 
 
digitalRead() 
Função que lê o valor presente e um pino digital. Este 
valor pode ser HIGH ou LOW. 
 
Sintaxe: 
digitalRead(pino) 
 
Parâmetros: 
pino -> valor correspondente ao pino que se deseja ler. 
 
Retorno = HIGH ou LOW. 
 
Exemplo: 
Vamos ler o estado da tecla, ligar o pino P2 e acionar o 
LED ligado a pino P1 conforme o seu estado: 
 
 
50 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
const int LED = 1; //pino para o LED 
const int BOTAO = 2; //pino para o botão 
 
int val = 0; // val será utilizado para armazenar o estado do pino 
 
void setup(){ 
 pinMode(LED,OUTPUT); //o LED é uma saída 
 pinMode(BOTAO,INPUT); //o BOTAO é uma entrada 
} 
 
void loop (){ 
 val = digitalRead(BOTAO); // lê e armazena o valor de entrada 
 digitalWrite(LED, val); //aciona LED conforme valor lido do botão 
} 
 
 
Entradas Analógicas 
 
Na Franzininho temos 1 pino que pode ser usado como 
entrada Analógica (A1). O Attiny85 possui mais entradas 
analógicas(A0,A2,A3), que também podem ser usadas mas com 
limitações no hardware* conforme pinout: 
 
 
FÁBIO SOUZA e DIANA SANTOS 51 
 
 
Pinagem Franzininho V2 (verificar limitações de uso dos pinos) 
 
Função 
Para a leitura de um sinal analógico no pino que possui 
essa função, não é necessário configurar o pino como entrada 
analógica. Isso é feito na função de leitura: 
 
int analogRead(pino) 
 
Lê o valor presente em um pino configurado como 
entrada analógica. Internamente o Arduino possui um conversor 
A/D de 10 bits. Dessa forma o valor retornado por esta função 
estará na faixa de 0 a 1023 conforme o valor presente no pino. 
 
Sintaxe: 
analogRead(pino); 
 
Parâmetros: 
pino -> valor do pino configurado como entrada 
analógica (0,1,2,3 na Franzininho) 
 
 
52 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
Retorno = int (0 a 1023) 
 
Exemplo: 
Vamos ler o valor de um potenciômetro ligado ao pino 
P2(A1) e acionar o LED, quando a leitura atingir um valor 
definido: 
 
 
const byte LED = 1; //pino do LED 
const byte POT = A1; //pino do Potenciômetro 
 
void setup() { 
 pinMode(LED,OUTPUT); 
} 
 
void loop() { 
 
 int valor = analogRead(POT); // lê o valor do potenciômetro 
 
 if(valor> 511){ //se valor maior que 511 
 digitalWrite(LED,HIGH); //liga LED 
 }else{ //se não 
 digitalWrite(LED,LOW); //apaga LED 
 } 
} 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 53 
 
 
 
 
 
PWM 
 
O que é PWM? 
 
PWM, do inglês Pulse Width Modulation, é uma técnica 
utilizada por sistemas digitais para variação do valor médio de 
uma forma de onda periódica. A técnica consiste em manter a 
frequência de uma onda quadrada fixa e variar o tempo que o 
sinal fica em nível lógico alto. Esse tempo é chamado de duty 
cycle, ou seja, o ciclo ativo da forma de onda. No gráfico a seguir 
estão exibidas algumas modulações PWM: 
 
 
 
54 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
 
Analisando as formas de onda nota-se que a frequência 
da forma de onda tem o mesmo valor e varia-se o duty cycle da 
forma de onda. Quando o duty cicle está em 0% o valor médio da 
saída encontra-se em 0 V e consequentemente para um duty 
cycle de 100% a saída assume seu valor máximo, que no caso é 
5V. Para um duty cycle de 50% a saída assumirá 50% do valor da 
tensão, 2,5 V e assim sucessivamente para cada variação no duty 
cycle. Portanto, para calcular o valor médio da tensão de saída de 
um sinal PWM pode-se utilizar a seguinte equação: 
 
Vout = (duty cycle/100)* Vcc 
 
Onde : 
Vout - tensão de saída em V; 
duty cycle - valor do ciclo ativo do PWM em %; 
Vcc - tensão de alimentação em V. 
 
O PWM pode ser usada para diversas aplicações, como 
por exemplo: 
 
● controle de velocidade de motores; 
● variação da luminosidade de leds; 
 
 
FÁBIO SOUZA e DIANA SANTOS 55 
 
● geração de sinais analógicos; 
● geração de sinais de áudio. 
Usando as saídas PWM do Arduino 
Na Franzininho temos 3 pinos que pode ser usado como 
saídas PWM(PWM0,PWM1 e PWM4) conforme pinout: 
 
 
 
 
 
Função 
A função analogWrite() escreve um valor de PWM em 
um pino digital que possui a função PWM. Para usar o pino como 
saída PWM é necessário configurá-lo como saída digital. 
 
Sintaxe: 
analogWrite(pino, valor) 
 
Parâmetros: 
pino -> corresponde ao pino que será gerado o sinal 
PWM (0,1,4 na Franzininho); 
valor -> corresponde ao duty cycle, ou seja, o valor que 
permanecerá em nível alto o sinal. O valor deve ser de 0 a 255 
onde com 0 a saída permanece sempre em nível baixo e 255 a 
saída permanece sempre em nível alto. 
 
 
56 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
Exemplo: 
Vamos controlar o brilho do LED conforme o valor lido no 
potenciômetro. 
 
 
 
 
const byte LED = 1; //pino do LED 
const byte POT = A1; //pino do Potenciômetro 
void setup() { 
 pinMode(LED,OUTPUT); 
} 
void loop() { 
 int valor = analogRead(POT); // lê o valor do potenciômetro 
 analogWrite(LED,valor/4); //escreve no LED valor entre 0 e 255 
} 
 
 
I2C 
A biblioteca Wire usada para aplicações I2C não é 
compatível com o ATtiny85 . Para a função de I2C podemos usar 
a biblioteca TinyWireM , disponibilizada pela Adafruit. Você pode 
baixá-la no github ou instalar através do gerenciador de 
bibliotecas no Arduino, como a ilustração a seguir. 
 
 
FÁBIO SOUZA e DIANA SANTOS 57 
 
 
Os pinos da I2C na Franzininho são: P0(SDA) e P2(SCL), 
conforme pinout mostrado a seguir. 
 
 
 
 
Exemplo: Leitura do sensor de temperatura 
DS1620 
No próximo exemplo faremos a leitura do sensor de 
temperatura utilizando o protocolo I2C para a coleta dos dados. 
 
 
58 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
 
/* ATtiny85 as an I2C Master Ex1 BroHogan 
 * I2C master reading DS1621 temperature sensor. (display with leds) 
 * SETUP: 
 * ATtiny Pin 1 = (RESET) N/U ATtiny Pin 2 = (D3) LED3 
 * ATtiny Pin 3 = (D4) to LED1 ATtiny Pin 4 = GND 
 * ATtiny Pin 5 = SDA on DS1621 ATtiny Pin 6 = (D1) to LED2 
 * ATtiny Pin 7 = SCK on DS1621 ATtiny Pin 8 = VCC (2.7-5.5V) 
 * NOTE! - It's very important to use pullups on the SDA & SCL lines! 
 * DS1621 wired per data sheet. This ex assumes A0-A2 are 
 * set LOW for an addeess of 0x48 
 * TinyWireM USAGE & CREDITS: - see TinyWireM.h 
 * NOTES: 
 * The ATtiny85 + DS1621 draws 1.7mA @5V when leds are not 
 * on and not reading temp. 
 * Using sleep mode, they draw .2 @5V @ idle - 
 * see http://brownsofa.org/blog/archives/261 
 */ 
 
#include <TinyWireM.h> // I2C Master lib for ATTinys which use USI 
 
#define DS1621_ADDR 0x48 // 7 bit I2C address for DS1621 
 // temperature sensor 
#define LED1_PIN 4 // ATtiny Pin 3 
#define LED2_PIN 1 // ATtiny Pin 6 
 
 
FÁBIO SOUZA e DIANA SANTOS 59 
 
#define LED3_PIN 3 // ATtiny Pin 2 
 
int tempC = 0; // holds temp in C 
int tempF = 0; // holds temp in F 
 
void setup(){ 
 pinMode(LED1_PIN,OUTPUT); 
 pinMode(LED2_PIN,OUTPUT); 
 pinMode(LED3_PIN,OUTPUT); 
 Blink(LED1_PIN,2);// show it's alive 
 TinyWireM.begin(); // initialize I2C lib 
 Init_Temp(); // Setup DS1621 
 delay (3000); 
} 
 
void loop(){ 
 Get_Temp(); 
 Blink(LED1_PIN,tempC/10); // blink 10's of temperature on LED 1 
 delay (1000); 
 Blink(LED2_PIN,tempC%10); // blink 1's of temperature on LED 2 
 delay (4000); // wait a few sec before next reading 
} 
 
void Init_Temp(){ // Setup the DS1621 for one-shot mode 
 TinyWireM.beginTransmission(DS1621_ADDR); 
 TinyWireM.send(0xAC); // Access Command Register 
 TinyWireM.send(B00000001); // One-shot mode for battery savings 
 //TinyWireM.send(B00000000); // if setting cont.mode for fast reads 
 TinyWireM.endTransmission(); // Send to the slave 
} 
 
 
void Get_Temp(){ // Get the temperature from a DS1621 
 TinyWireM.beginTransmission(DS1621_ADDR); 
 
 
60 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 TinyWireM.send(0xEE); // if one-shot, start conversions now 
 TinyWireM.endTransmission(); // Send 1 byte to the slave 
 delay(750); // if one-shot, must wait ~750 ms for conversion 
 TinyWireM.beginTransmission(DS1621_ADDR); 
 TinyWireM.send(0xAA); // read temperature (for either mode) 
 TinyWireM.endTransmission(); // Send 1 byte to the slave 
 TinyWireM.requestFrom(DS1621_ADDR,1); // Request 1 byte from slave 
 tempC = TinyWireM.receive(); // get the temperature 
 tempF = tempC * 9 / 5 + 32; // convert to Fahrenheit 
} 
 
 
void Blink(byte led, byte times){ // poor man's GUI 
 for (byte i=0; i< times; i++){ 
 digitalWrite(led,HIGH); 
 delay (400); 
 digitalWrite(led,LOW); 
 delay (175); 
 } 
} 
 
 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 61 
 
Exemplos com a Franzininho 
 
Com tudo pronto e configurado é hora de se divertir, mas 
antes de criarmos nosso primeiro programa é bom copiar e 
entender como funciona o código-fonte do Arduino. Uma coisa 
interessante para que utiliza a Franzininho é que existem 
milhares de códigos prontos , que podemos copiar e modificar 
conforme as nossas necessidades, sem ter que partir do zero. 
O primeiro código que iremos testar é o Pisca LED, o qual 
chamamos de “Olá Mundo”. Um código e uma montagem bem 
simples. Lembrando que no site da Comunidade Franzininho 
existem outros códigos que podem ser usados e convidamos você 
a participar compartilhando as suas criações em nosso site 
 
http://www.franzininho.com.br 
 
 
Pisca LED 
O primeiro contato com a programação com o Arduino, 
você faz o blink (que faz com que o led pisque em intervalos de 
tempo). Com a Franzininho não é diferente, você pode testar com 
o próprio LED que ela tem ou caso você queira, pode ligar um 
LED em uma protoboard. A seguir vamos explicar como fazer um 
blink com a Franzininho. 
 
Materiais: 
Placa Franzininho; 
Protoboard; 
LED 3mm; 
Resistor 330; 
Jumpers 
 
Circuito 
Na protoboard ou Matriz de Contatos montamos o 
circuito para acionamento do LED conforme a figura abaixo. 
 
http://www.fabiosouza.com.br/
 
62 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
 
 
 
/* Pisca LED - Blink - Esse exemplo exibe como piscar o LED presente 
na placa ou um LED externo ligado ao pino 1 da Franzininho em 
intervalos de 1 segundo. */ 
const int LED = 1; //pino digital conectado ao LED 
void setup(){ 
 pinMode(LED,OUTPUT); //pino digital de saída 
} 
void loop(){ 
 digitalWrite(LED,HIGH); //acende o led da placa 
 delay(1000); //aguarda um segundo 
 digitalWrite(LED,LOW); //apaga o led da placa 
 delay(1000); //aguarda um segundo 
} 
 
 
 
Tecla Liga/Desliga 
 
Nesse exemplo vamos fazer uma projeto com uma tecla 
liga/desliga, que pode ser usada para acionamentos de diversos 
outros projetos, ou fazer parte de um projeto maior onde este 
módulo pode ser aplicado com o botão liga e desliga. 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 63 
 
Materiais: 
Placa Franzininho; Protoboard; LED 
3mm; 1 Resistor 220; 1 Resistor de 
1K; 1 Botão; Jumpers; 
 
Circuito 
 
No protoboard ou Matriz de Contatos vamos inserir um 
LED, resistores e um botão, conforme a imagem abaixo. 
 
 
 
 
 
64 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
/* 
 Franzininho 
 Exemplo: Tecla liga/desliga 
 Esse exemplo exibe como fazer ligar e desligar 
 uma saída através de uma tecla 
*/ 
const int LED = 1; //pino para o LED 
const int BOTAO = 2; //pino para o botão 
int estadoAnteriorBotao = 0; // armazena o estado anterior do botão 
 
void setup(){ 
 pinMode(LED,OUTPUT); //o LED é uma saída 
 pinMode(BOTAO,INPUT); //o BOTAO é uma entrada 
} 
 
void loop (){ 
 int estadoAtualBT= digitalRead(BOTAO); // Lê estado do botão 
 delay(10); 
if ((estadoAtualBT != estadoAnteriorBotao)&& (estadoAtualBT == 
LOW)){ //Se o botão foi pressionado e o seu estado mudou 
 digitalWrite(LED,!digitalRead(LED)); //inverte estado do LED 
 } 
 
 estadoAnteriorBotao = estadoAtualBT; 
 //salva o estado do botão para comparar na próxima leitura 
} 
 
 
 
 
 
 
FÁBIO SOUZA e DIANA SANTOS 65 
 
Comunidade Franzininho 
 
O projeto Franzininho possui uma grande comunidade 
ativa, compartilhando e trocando conhecimento. O bacana da 
comunidade Franzininho é que pessoas de várias áreas podem 
colaborar e interagir contribuindo assim com a melhoria do 
projeto e com novas ideias para aplicação. 
Hoje temos uma comunidade no Facebook e também no 
Telegram. Fique a vontade para participar, ficaremos muito felizes 
em ver você na comunidade Franzininho: 
 
Comunidade Franzininho no Facebook: 
https://www.facebook.com/groups/299236843857849/ 
 
Comunidade Franzininho no Telegram: 
https://t.me/franzininho 
 
 
 
 
 
 
 
66 MONTE E PROGRAME SEU PRÓPRIO ARDUINO 
 
Anexo A - Esquemático