Mostrando postagens com marcador serial. Mostrar todas as postagens
Mostrando postagens com marcador serial. Mostrar todas as postagens

sexta-feira, 18 de julho de 2014

Display LCD Gráfico Touchscreen TW12864

Marca: TATO
Modelo: TW12864
Site: http://tato.ind.br/  
 
   O display gráfico serial TW-12864 combina um módulo serial com um display gráfico de 128x64 pontos, de fundo branco e letras pretas. Este conjunto recebe dados serialmente a velocidade de 2400 a 15200bps e mostra no display textos ou gráficos. No modo texto ele pode apresentar diferentes tamanhos de fontes.  
  Códigos especiais em ASCII são utilizados para enviar comandos ao display. Instruções adicionais permitem o controle do tamanho de fonte e posicionamento do cursor. As instruções gráficas traçam linhas, retângulos, círculos e pontos.
   O display TW-12864possui uma memória EEPROM que permite armazenar até 30 telas completas que podem ser criadas em qualquer computador PC rodando Windows e armazenadas no display. Com um simples comando as telas podem ser exibidas no display.

O conector do display TW-12864 é do tipo barra de pinos com espaçamento padrão de 0.1”.

ATENÇÃO: Não inverta o 5V e o terra, nem por um instante. Fazendo isto irá destruir o display. Não aplique mais de 5V. Isto pode queimar o display.

Controle de Contraste


   O contraste do display pode ser ajustado através de um trimpot localizado na parte trazeira.



Backlight LED


   O display TW-12864 possui um backlight de LED que possui um baixo consumo de corrente. A intensidade do backlight pode ser ajustada por controle do software.

Selecionando o Baud Rate


   O baud rate padrão do display é 9600bps e ele retornará a esta velocidade sempre que for ligado. A velocidade pode então ser alterada através de comandos de software.

Ligação de Uso


   O display TW-12864 necessita de 5Vx100mA para o funcionamento. Os dois pinos de comunicação são para ligar na UART de um microcontrolador. Para ligação a um PC é necessário um MAX232.

Operação Básica


   Uma vez que o TW-12864 esteja corretamente ligado e configurado para o baud rate do microcontrolador, comandos podem ser enviados para o display. Todos os comandos são em código ASCII e terminador por um <ENTER>.

Tempo de Inicialização


   O display TW-12864 necessita de 200ms para inicializar e estar pronto para receber comandos.

Comandos do Display

------------------------------------------------------------------------------------------------------------------------------------------------------------------------
   Nos comandos abaixo, sempre que o simbolo « aparecer, significa que um <ENTER> foi digitado.

Draw line - Desenha linha - l x0 y0 x1 y1
Desenha uma linha
Exemplo: l 10 20 40 50«
Resultado: Desenha uma linha entre os pontos 10,20 e 40,50 com a cor de frente
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Draw Point - Desenha um ponto - po x y
Desenha um ponto
Exemplo: po 20 30«
Resultado: Desenha um ponto na posição 20,30 com a cor de frente.
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Set Font - Seleciona a fonte - f <tipo>
Seleciona o tipo de fonte
Exemplo: f “13”«
Resultado: Seleciona a fonte tamanho 13
As opções de fonte são:
5, 11, 13, 17
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Text Display - Mostra um texto - t
Mostra um texto no display
Exemplo: t “texto de exemplo”«
Resultado: Escreve texto de exemplo no display
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Draw Rectangle - Desenha um retângulo - r x0 y0 x1 y1
Desenha um retângulo entre os pontos x0,y0 e x1,y1
Exemplo: r 10 20 40 50«
Resultado: Desenha um retângulo entre 10,20 e 40,50
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Draw Rectangle Filled - Desenha um Retângulo Preenchido - rf x0 y0 x1 y1
Desenha um retângulo preenchido
Exemplo: rf 10 20 40 50«
Resultado: Desenha um retângulo preenchido com a cor de frente.
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Rectangle Erase - Apaga Retângulo - re x0 y0 x1 y1
Apaga uma área retangular do display
Exemplo: re 10 20 40 50«
Resultado: Apaga a área entre 10,20 e 40,50
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Rectangle Invert - Inverte Retângulo - ri x0 y0 x1 y1
Inverte uma área retangular do display
Exemplo: ri 10 20 40 50«
Resultado: Inverte a área entre 10,20 e 40,50
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Draw Circle - Desenha um Círculo - c x y r
Desenha um círculo
Exemplo: c 50 60 10«
Resultado: Desenha um círculo no ponto 50,60 com raio 10
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Draw Circle Filled - Desenha um Círculo Preenchido - cf x y r
Desenha um círculo
Exemplo: cf 50 60 10«
Resultado: Desenha um círculo preenchido no ponto 50,60 com raio 10
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Clear Screen - Apaga a Tela - z
Preenche a tela toda com a cor de fundo
Exemplo: z«
Resultado: A tela é preenchida com a cor de fundo.
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
BackLight - bk 0|1|2|3|4|5
Ajusta a intensidade do backlight
Exemplo: bk 1«
Resultado: Liga o backlight na intensidade mínima
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Baud Rate - b 2400|9600|19200|38400|115200
Determina a velocidade de comunicação
Exemplo: b 19200«
Resultado: Muda a velocidade para 19200bps
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Mostra Tela - T n
Mostra uma tela armazenada na memória
Exemplo: T 12«
Resultado: Mostra a tela número 12
O valor de ‘n’ pode ser de 1 a 30

================================================================================================================

Comandos do Touch Screen


Operação do Touch Screen


   O touch screen funciona de forma totalmente independente do display em dois modos diferentes:

Botão e Hotspot ou modo xy. 

  • No modo xy, os valores de x e y são retornados enquanto tiver um toque no display. Os valores são retornados em ASCII no formato xxx,yyy«
  • No modo Botão, até 20 botões podem ser definidos e são tratados automaticamente pelo display, se um botão for tocado, sua imagem é invertida no display e o código Bn«, onde n é o número do botão é enviado pela serial. Assim que o botão for solto o código bn« é enviado.
  • O modo HotSpot é similar ao modo Botão, a diferença é que a área sensível não é invertida e os códigos enviados são Hn« e hn« para o toque e quando é solto respectivamente.

Touch Calibrate - Calibra o Touch Screen - tc
Calibra o touch screen
Exemplo: tc«
Resultado: A tela de calibração é mostrada

Button Define - Define Botão - bd n x y "texto"
Cria um botão
Exemplo: bd 1 50 20 “Teste”«
Resultado: Desenha um botão com centro no ponto 50,20

Criando telas gráficas


   As telas para o display podem ser criadas em qualquer programa gráfico disponível para Windows. Crie a tela com 128x64 pontos ou se já tiver alguma imagem pronta, redimensione para este tamanho.

   As imagens devem ser gravadas no formato BMP do Windows e 1 bit de color ou BW.

   Clique aqui e baixe o programa que permite o teste de todos os comandos suportados pelo display assim como o envio das telas gráficas.


Dimensões do display





Providências preliminares para uso do módulo:


Temos dois modos de ligar o módulo à Arduino:

  1. Arduino como intermediaria proporcionando comunicação do PC com o módulo - TX do módulo com TX da Arduino e RX do módulo com RX da Arduino.
  2. Arduino enviando comandos para o módulo – TX do módulo no RX da Arduino e RX do módulo com TX da Arduino.
Assim para realizar testes e enviar imagens para o módulo temos de fazer as ligações no modo 1, conforme o diagrama:



TECLADO MUSICAL

Circuito.



 #include <SoftwareSerial.h>

SoftwareSerial mySerial(4, 5); // RX, TX

char code[2]={0,0};
int bytesread = 0;
int  val = 0;
String codigoObtido="";

void setup()
{


  // Inicia comunicação Serial
  mySerial.begin(9600);

mySerial.println("z");
delay(300);
//desenha retangulo

//desenha botão Dó
mySerial.print("bd 1 8 10 ");
mySerial.write(34);
mySerial.print("D");
mySerial.write(34);
mySerial.println();
//desenha botão Ré
delay(200);
mySerial.print("bd 2 26 10 ");
mySerial.write(34);
mySerial.print("R");
mySerial.write(34);
mySerial.println();
//desenha botão Mi
delay(200);
mySerial.print("bd 3 46 10 ");
mySerial.write(34);
mySerial.print("M");
mySerial.write(34);
mySerial.println();
//desenha botão Fá
delay(200);
mySerial.print("bd 4 66 10 ");
mySerial.write(34);
mySerial.print("F");
mySerial.write(34);
mySerial.println();
//desenha botão Sol
delay(200);
mySerial.print("bd 5 83 10 ");
mySerial.write(34);
mySerial.print("S");
mySerial.write(34);
mySerial.println();
//desenha botão Lá
delay(200);
mySerial.print("bd 6 100 10 ");
mySerial.write(34);
mySerial.print("L");
mySerial.write(34);
mySerial.println();
//desenha botão Si
delay(200);
mySerial.print("bd 7 118 10 ");
mySerial.write(34);
mySerial.print("S");
mySerial.write(34);
mySerial.println();
  

}

void loop() {
  if (mySerial.available()) {
   //Havendo qualquer entrada na porta serial desvia para a função LeBotoes
    leBotoes(); 
  }
  
  

}


void leBotoes(){
 // Recebe as string do Touch screen
  
     if( mySerial.available() > 0) {

        val = mySerial.read();
        if(val!=13){
          //le todos os caracteres recebidos na porta serial até receber o caracter 13
          code[bytesread]=val;
          codigoObtido+=code[bytesread];
          //conta bytes lidos e monta string
          bytesread++;

        }else{
          //ao terminar de obter caracteres, desvia para função de comparação de String Recebida
          comparaStringRecebida();
          //Limpa variáveis
          bytesread=0;
          codigoObtido="";
        }
     
  }

}



void comparaStringRecebida(){
        Serial.print("Valor recebido do display : ");   
        Serial.println(codigoObtido);
        //compara Strings e toca nota correspondente
        if(codigoObtido.equals("B1")){tone(8,261,50);}
        if(codigoObtido.equals("B2")){tone(8,293,50);}
        if(codigoObtido.equals("B3")){tone(8,329,50);}
        if(codigoObtido.equals("B4")){tone(8,349,50);}
        if(codigoObtido.equals("B5")){tone(8,392,50);}
        if(codigoObtido.equals("B6")){tone(8,440,50);}
        if(codigoObtido.equals("B7")){tone(8,493,50);}
}

sexta-feira, 27 de junho de 2014

Alterar nome e senha em módulo Bluetooth

    Neste tutorial iremos aprender como alterar o nome e a senha do modulo Bluetooth JY-MCU HC-06. Para que depois que o seu projeto estiver pronto, poderá colocar um nome relacionado ao projeto. Por exemplo: se o seu projeto for um robô, ficaria mais interessante que na hora de fazer a conexão com um celular ou tablet, que o nome aparecesse como ROBO, ao invés do padrão HC-06, e também que você crie a sua própria senha, ao invés da senha padrão.

Então vamos meter a mão e fazer as configurações!

   O primeiro passo a ser seguido é o esquema de ligação exemplificado na imagem abaixo.

TXD -- PINO 10
RXD -- PINO 11
GND -- GND
VCC -- 5V


arduino mais - LIGAÇÂO BLUETOOTH

Em seguida é necessário carregar o programa abaixo para abrir as configurações do modulo.copie e cole no IDE ou baixe.

===========================================================================================================

#include <SoftwareSerial.h>  
   
   
SoftwareSerial mySerial(10, 11); // RX, TX  
String command = ""; // Stores response of bluetooth device  
            // which simply allows \n between each  
            // response.  
   
void setup()   
{  
  // Open serial communications and wait for port to open:  
  Serial.begin(115200);  
  Serial.println("Type AT commands!");  
  // SoftwareSerial "com port" data rate. JY-MCU v1.03 defaults to 9600.  
  mySerial.begin(9600);  
}  
   
void loop()  
{  
  // Read device output if available.  
  if (mySerial.available()) 
  {  
     while(mySerial.available()) 
     { // While there is more to be read, keep reading.  
       command += (char)mySerial.read();  
     }  
   Serial.println(command);  
   command = ""; // No repeats  
  }  
  
  // Read user input if available.  
  if (Serial.available())
  {  
    delay(10); // The DELAY!  
    mySerial.write(Serial.read());  
  }  
   
}// END loop()  

===========================================================================================================

   Após ter feito a ligação correta do modulo e carregado o programa no arduino, abra o monitor serial do IDE do arduino e configure o baud rate para 115200 e Sem fim de linha.

Agora é só configurar enviando os códigos abaixo.

AT - Retorna "OK", o que indica que o módulo bluetooth está respondendo aos comandos



AT+NAME : Altera o nome do módulo Bluetooth



AT+VERSION - Retorna a versão do firmware da placa





AT+PINXXXX - Altera a senha do bluetooth, onde XXXX é a nova senha, e você pode utilizar qualquer combinação de 4 números. Este comando retorna "OKsetPIN"

AT+BAUDX - Altera o baud rate (velocidade de transmissão) do módulo, sendo que X por ter os valores de 1 a 9, conforme tabela abaixo :

Valor    Baud Rate
1           1200
2           2400
3           4800
4           9600
5           19200
6           38400
7           57600
8           115200
9           230400


É isso ai galera, espero que tenham gostado do tutorial.

Valeu!

segunda-feira, 23 de junho de 2014

Detalhes sobre o Arduino Uno



arduino mais - arduino UNO


Visão geral:


   O Arduino Uno é uma placa de microcontrolador baseado no ATmega328 ( datasheet ). Tem 14 pinos digitais de entrada / saída (dos quais 6 podem ser usados ​​como saídas PWM), 6 entradas analógicas, um de 16 MHz ressonador cerâmico, uma conexão USB, um conector de alimentação, um cabeçalho ICSP, e um botão de reset. Ele contém tudo o necessário para suportar o microcontrolador; basta conectá-lo a um computador com um cabo USB ou ligá-lo com um adaptador AC para DC ou bateria para começar.
   O Uno é diferente de todas as placas anteriores em que não usam o chip controlador USB-to-serial FTDI. Em vez disso, ele apresenta o Atmega16U2 ( Atmega8U2 até a versão R2) programado como um conversor USB para serial.

Revisão 2 tem um resistor de PullDown 8U2 HWB, tornando-o mais fácil de colocar em modo DFU .

Revisão 3 da placa tem os seguintes novos recursos: 
  • 1.0 pinagem: adicionado pino SDA e SCL que estão perto do pino AREF, e outros dois novos pinos colocados perto do pino RESET, o IOREF que permitem que os Shields se adaptem à tensão fornecida a partir da placa. No futuro, os escudos serão compatíveis tanto com a placa que usa o AVR, que opera com 5V, quanto com o Arduino que opera com 3.3V. O segundo é um pino não conectado, que está reservada para efeitos futuros. 
  • Circuito de RESET Stronger. 
  • Atmega 16U2 substituiu o 8U2.
"Uno" significa UM em italiano, e leva o nome para marcar o lançamento do Arduino 1.0. O Uno e a versão 1.0 são as versões de referência do Arduino. O Uno é o mais recente em uma série de placas Arduino USB, e o modelo de referência para a plataforma Arduino; para uma comparação com as versões anteriores, consulte o índice de placas Arduino.

Resumo


Microcontrolador:                                 ATmega328
Tensão de funcionamento:                    5V
Tensão de entrada (recomendado): 7-12V
Tensão de entrada (limites):                 6-20V
Digital I/O:                                          14 (dos quais 6 oferecem saída PWM)
Pinos de entrada analógica:                  6
Corrente DC por I / O:                        40 mA
Corrente DC no pino 3.3V:                 50 mA
Memória Flash:                                 32 KB ( ATmega328 ), dos quais 0,5 KB utilizados pelo carregador de inicialização
SRAM:                                               2 KB ( ATmega328 )
EEPROM:                                          1 KB ( ATmega328 )
Clock:                                                 16 MHz

Alimentação

   O Arduino Uno pode ser alimentado através da conexão USB ou com uma fonte de alimentação externa. A fonte de alimentação é selecionada automaticamente.
   A alimentação pode vir de um adaptador AC para DC ou bateria. O adaptador pode ser conectando com um  plugue de centro positivo 2,1 milímetros na entrada de alimentação da placa.  Pode-se alimentar a placa com uma bateria ligada diretamente nos pinos Gnd e Vin.
   A placa pode operar com alimentação externa de 6 a 20 Volts. Abaixo de 7V, o pino de 5V pode fornecer menos de cinco Volts e a placa pode ficar instável. Se usar mais do que 12V, o regulador de tensão pode superaquecer e danificar a placa. É recomendado de 7 a 12 Volts.

Os pinos de alimentação são os seguintes:


  • Vin - É um "jump" interno, fornece a mesma tensão que está sendo recebida na entrada de alimentação externa da placa (Não USB).
  • 5V - Fornece 5V regulados pelo regulador de tensão da placa.
  • 3V3 - Fornece 3,3V regulados pelo regulador de tensão da placa. Corrente máxima de 50 mA.
  • GND - Negativo/Terra.
  • IOREF – Este pino na placa Arduino fornece a referência de tensão com que o microcontrolador opera. Um shield configurado corretamente pode ler a tensão do pino IOREF e selecionar a fonte de alimentação adequada ou habilitar tradutores de tensão nas saídas para o trabalho com a 5V ou 3.3V.

Memória


   O ATmega328 tem 32 KB (com 0,5 KB utilizada para o bootloader). Ele também tem 2 KB de SRAM e 1 KB de EEPROM (que pode ser lido e escrito com a biblioteca EEPROM).

Entradas e Saídas


   Cada um dos 14 pinos digitais do Uno podem ser utilizados como uma entrada ou uma saída, usando  as funções pinMode (), digitalWrite (), e digitalRead() . Eles operam com 5 volts. Cada pino pode fornecer ou receber um máximo de 40 mA e tem um resistor pull-up interno (desconectado por padrão) de 20-50 kOhms. Além disso, alguns pinos têm funções especializadas:


  • Serial: 0 (RX) e 1 (TX). Usado para receber (RX) e transmitir (TX) dados seriais TTL. Estes pinos são ligados aos pinos correspondentes do USB-TTL chip serial ATmega8U2.
  • Interrupts externas: 2 e 3 - Estes pinos podem ser configurados para disparar uma interrupção on um valor baixo, uma borda de subida ou decida, ou uma mudança em valor. Veja a função attachInterrupt ( ) para obter detalhes.
  • PWM:. 3, 5, 6, 9, 10, 11 e fornecem saída PWM de 8 bits com a função analogWrite ().
  • SPI:. 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK) Estes pinos suportam comunicação SPI utilizando a biblioteca SPI .
  • LED: 13. Há um built-in LED conectado ao pino digital 13. Quando o pino está em valor alto, o LED está ligado, quando o pino esta em valor baixo, ele está desligado..
   O Uno tem 6 entradas analógicas, rotulados A0 a A5, cada um dos quais com 10 bits de resolução (i.e. 1024 valores diferentes). Por padrão, eles medem de terra para 5 volts, embora seja possível mudar o limite superior de sua faixa usando o pino AREF e a função analogReference ( ). Além disso, alguns pinos têm funcionalidades especializadas:

  • TWI: pino A4 ou SDA e pino A5 ou SCL – Suporte a comunicação TWI utilizando a biblioteca Wire.
  • Reset. Levar o pino reset em nivel baixo para resetar o microcontrolador. Tipicamente usado para adicionar um botão de reset para shields que escondem o botão da placa.
   Veja também o mapeamento entre os pinos do Arduino e portos ATmega328. O mapeamento para o Atmega8, 168, e 328 são idênticos.

Comunicação

   O Arduino Uno possui uma série de facilidades para se comunicar com um computador, outro Arduino, ou outros microcontroladores. O ATmega328 fornece comunicação serial UART TTL (5V) que está disponível nos pinos digitais 0 (RX) e 1 (TX). Um ATmega8U2 na placa canaliza esta comunicação para a USB e aparece como uma porta virtual para o software no computador. O firmware do '8U2 utiliza os drivers padrão USB COM e nenhum driver externo é necessário. Entretanto, no Windows, um arquivo .inf é necessário. Ainda faltam as instruções específicas mas em breve estarão disponíveis. O software do Arduino inclui um monitor serial que permite dados textuais ser enviados e recebidos da placa. LEDs conectados ao RX e TX piscarão enquanto dados estiverem sido transmitidos pelo chip USB-para-serial e pela conexão USB (mas não para comunicação serial nos pinos 0 e 1).
   A biblioteca SoftwareSerial permite comunicação serial em qualquer um dos pinos digitais do Uno.
   O ATmega328 também suporta I2C (TWI) e comunicação SPI. O software Arduino inclui uma biblioteca Wire para simplificar o uso do I2C bus; veja a documentação para mais detalhes. Para a comunicação SPI, use a biblioteca SPI .

Programação

   O Arduino Uno pode ser programado com o software Arduino. Selecione “Arduino Uno" a partir do menu Ferramentas> Placa (de acordo com o microcontrolador em sua placa). Para mais detalhes, consulte as referências e tutoriais.
   O ATmega328 no Arduino Uno vem pré-gravado com um bootloader que permite o envio de novos códigos sem o uso de um programador de hardware externo. Ele se comunica com o protocolo original STK500 (referências , arquivos de linguagem C ).
   Você também pode ignorar o bootloader e programar o microcontrolador através do conector ICSP (programação In-Circuit Serial), veja estas instruções para mais detalhes.
   O ATmega16U2 (ou 8U2 no rev1 e placas Rev2) código fonte do firmware está disponível. O ATmega16U2/8U2 é carregado com um bootloader DFU, que pode ser ativado por:


  • Em placas Rev1: conectar o jumper de solda na parte traseira da placa (perto o mapa de Itália) e, em seguida, redefinir o 8U2.
  • Em placas Rev2 ou posteriores: existe um resistor PullDown 8U2/16U2 HWB, tornando-a mais fácil de colocar em modo DFU.
   Você pode então usar o software da Atmel FLIP (Windows) ou o programador DFU (Mac OS X e Linux) para carregar um novo firmware. Ou você pode usar o cabeçalho ISP com um programador externo (substituindo o bootloader DFU). Veja este tutorial contribuído pelo usuário para obter mais informações.

Reset automatico por software

   Ao invés de necessitar do pressionamento físico de um botão antes de um upload, o Arduino Uno é desenvolvido de maneira que permita que esta operação seja feita por meio do software rodando em um computador. Uma das linhas de controle de fluxo do hardware (DTR) do ATmega8U2 é conectado à linha de reset do ATmega328 através de um capacitor de 100nF. Quando esta linha é declarada (rebaixada) a linha de reset cai o suficiente para resetar o chip. O software do Arduino utiliza esta capacidade para permitir o envio de código novo simplesmente pressionando o botão de upload na IDE. Isto significa que o bootloader pode ter um intervalo mais curto, uma vez que o rebaixamento do DTR pode ser melhor coordenado com o início do upload.

   Esta configuração tem outras implicações. Quando o Uno é conectado a um computador rodando Mac OS X ou Linux, ele é resetado cada vez que uma conexão é estabelecida com o software (via USB). Durante o próximo meio segundo o bootloader estará rodando no Uno. Uma vez que ele está programado para ignorar dados malformados (i.e. qualquer coisa diferente do upload de um novo código), ele irá interceptar os primeiros bytes de informação após a abertura da conexão. Se um programa rodando na placa recebe alguma configuração ou outra informação quando começa a rodar esteja seguro de que o software com o qual ela se comunica espere por um segundo antes de começar a enviar dados.

   O Uno contem uma trilha que pode ser interrompida (cortada fisicamente) para desabilitar o auto-reset. Os conectores de cada lado da trilha podem ser soldados para reabilitar esta função. Ela está identificada como "RESET-EN". Você também pode desabilitar o auto-reset conectando um resistor de 110Ω do 5V à linha de reset, veja este tópico do fórum para mais detalhes.

Proteção contra sobre-corrente na USB

   O Arduino Uno possui um polyfuse resetável que protege a porta USB do seu computador contra sobre-corrente e curtos circuitos. Embora muitos computadores tenham sua própria proteção interna, o fuso fornece uma camada a mais de proteção. Se mais de 500mA forem aplicados a porta USB ele automaticamente irá interromper a conexão até que o curto ou a sobrecarga seja removido.

Características físicas

   A largura e o comprimento máximos do PCB do Uno são 68,58 e 53,34mm respectivamente (2,7" x 2,1"), com os conectores USB e de alimentação extendendo-se além destas dimensões. Quatro orifícios para parafusos permitem que a placa seja fixada a uma superfície ou encapsulamento. Verifique que a distância entre os pinos digitais 7 e 8 é de 160mil (milésimos de polegada ou 0,16"), não é nem mesmo um múltiplo dos 100mil que separam os outros pinos.