Carta Aberta ao NOVO Ministro de Tecnologia

Boa noite Ministro Celso Panseira!

Parabéns pela "aquisição" da pasta de Ciências & Tecnologia do Brasil!

Sei que o Sr. já passou por 4 partidos e que é dono de restaurante... Além de ser formado em Letras e um leitor assíduo do dicionário!

Gostaria de saber como o Sr. pretende contribuir para esse Ministério tão importante para o futuro do nossos engenheiros e tecnólogos?

Acho que seria importante o Sr. fazer uma declaração pública sobre suas ideias e planos para atuar no Ministério da Tecnologia.

Eu não queria lhe assustar, mas nós tecnólogos temos dificuldades de aceitar administradores da pasta de Tecnologia que são da área de humanas...

Mas eu sei que o Sr. é muito criativo, uma vez que tirou o nome do seu restaurante de uma palavra bonita do dicionário!

Aliás fico muito feliz pela sua dedicação no assunto em que o Sr. é formado! Afinal de contas um letrado que não conhece o dicionário é imprestável, né?

Assim pensamos os tecnólogos sobre um administrador na pasta de exatas, mas com formação em humanas. É imprestável também, concorda?

Só espero que o Sr. não seja tão imprestável quanto o seu antecessor Aldo Rebelo que não fez nada além de tentar criar um projeto para acabar com o dia do halloween e instituir o dia do Saci-Pererê!

Não espero que o Sr. seja um Marco Antonio Raupp que é formado em física, doutorado em matemática, além de presidente do SBMAC (espero que o Sr. saiba o que é isso) e também ex-diretor do Inpe... Devo continuar ou o Sr. já entendeu?

Não acredite que somos bobos, pois sabemos que seu cargo foi "loteado" e negociado de forma política e que o Sr. passou por 4 partidos, mostrando que não tem escrúpulos e nem firmeza ideológica. Apenas interesses pessoais. Nós sabemos disso e nem precisa se explicar...

Não esperamos muito do Sr., sabemos de suas limitações no assunto de Ciências e Tecnologia.

Portanto não precisa se esforçar muito (eu sei que não vai) apenas esquente a cadeira para alguém que tenha diploma na área de exatas e que leia livros técnicos ao invés de dicionários.

Sem mais nada a dizer, sem mais esperanças no futuro tecnológico do Brasil, termino essa carta pedindo que o Sr. diminua seu próprio salário, pois o Sr. não tem as características necessárias para exercer essa pasta, portanto acredito que o Sr. deveria ganhar menos.

Ah! Se o Sr. interessar, tem umas faculdades de tecnologia que duram apenas 2 anos e iriam agregar muito ao seu conhecimento na área. E algumas ainda oferecem o curso a distância, o que não atrapalharia suas tarefas como dono de restaurante, leitor de dicionário, e no tempo livre, Ministro da pasta de Ciências e Tecnologia.

Atenciosamente,
Renato Aloi
seriallink.com.br
Indústria Brasileira

O que é Arduino Standalone?

Bom dia pessoal!

Hoje vamos falar do Arduino Standalone!

Esse termo "standalone" não tem tradução direta para o português. Ele significa "ficar sozinho", mas não de uma forma solitária, e sim de uma forma de "vigia da torre".

O vigia de uma torre também "fica sozinho", mas ele está cumprindo um papel! Ele está trabalhando!

O Arduino Standalone é baseado no chip principal da plataforma Arduino, que é o ATMegaXXX (onde XXX é o modelo do ATMega). Ele é fabricado pela Atmel e faz parte da linha de produtos chamada MegaAVR.

Todos os microcontroladores da plataforma Arduino (exceto pelo DUE) são da linha MegaAVR que é uma das plataformas 8 bits da Atmel.

Esta plataforma MegaAVR da Atmel, que lançou os ATMegas, e que a equipe Italiana do Arduino decidiu usar em seu projeto, é a evolução da plataforma anterior, que é o 8051.

Ainda tenho algum material sobre 8051 no Laboratório da Serial Link (e também tem muito material sobre standalone e protuino, que é o standalone da Serial Link):

http://seriallink.com.br/lab/

Pra quem já trabalhou com 8051 sabe que Standalone é o padrão. O Arduino UNO agregou várias funcionalidades na placa pra facilitar nosso trabalho na bancada.

Mas no chão de fábrica, seu chip ATMega com seu programa Arduino estão sozinhos!

Se você quiser alimentação de 3.3V, terá que fazer o circuito você mesmo! Não tem almoço grátis! Mas tem dica! Use um LM317!


Eu mesmo quando comecei, foi pelo Protuino, que é um Arduino Standalone da Serial Link funcionando em uma protoboard, veja o link do produto educacional:

http://seriallink.com.br/web/index.php?r=produtos%2Fkitprotuinoftdi

Essa versão do link acima é a mais atual, com manual para professor, dicas de montagens etc. O material original pode ser encontrado no primeiro link do Laboratório da Serial Link.

Muita gente não conhece a história do Laboratório da Serial Link (LdSL) e confunde com a do Laboratório de Garagem (LdG).

A verdade é que o Laboratório da Serial Link nasceu encubado dentro do LdG, mas que, por desacordos comerciais, separaram.

Dito isso, é possível ver muito do material original no meu canal antigo:

http://www.youtube.com/graccula

Os primeiros vídeos desse canal mostram (de forma amadora, claro) o nascimento do Protuino e todo trabalho de clonagem do FTDi, que é a plataforma USB/Serial da Serial Link.

Pois no Arduino Standalone você não tem conversor USB/Serial, então ou você usa um Arduino UNO pra gravar o chip, ou você conecta um Conversor USB/Serial direto no chip do ATMega para gravar o programa do Arduino.

A equipe italiana do Arduino partiu para outra plataforma diferente do FTDi, pois eles adotaram uma linha de microcontroladores da Atmel que já tem o conversor USB/Serial embutido no chip, e que ainda pode ser programado para nossa vantagem!

Legal né? Só que isso dá muito problema e vemos uma enchurrada de iniciantes reclamando que o Arduino parou de responder quando ligamos na USB do computador.

Isso acontece pois o chip ATmega com USB/Serial embutida as vezes "esquece" sua programação original e pára de funcionar de uma hora pra outra...

Por isso a Serial Link nunca abandonou a plataforma FTDi como sendo a USB/Serial mais eficiente que existe atualmente.

Isso sem falar que o chip FT232RL possui várias funcionalidades adicionais, como por exemplo uma saída 3.3V que já economiza um circuito adicional de regulador de tensão.

A própria Robocore não acompanhou a equipe italiana e manteve o FTDi em seu Arduino Black Board.

Atualmente ficou claro que a plataforma Arduino é um sucesso tão grande e tão avassalador, que já estamos desmontando aquela placa azul e jogando ela fora.

Já estamos conseguindo tomar nossas próprias decisões de layout de circuitos de forma que atenda o mercado brasileiro de uma forma que o italiano ou o chinês nunca vão conseguir.

E vamos em frente!

Que venha a GBK Robotics! Vamos criar uma epidemia de Arduino no Brasil!



Abcs,

Renato Aloi

Vantagens da FRAM no Arduino Contra EEPROM

O que é FRAM?

É um acrônimo para Memória RAM "Ferro-Elétrica", porém não volátil, que pode reter os dados mesmo depois de desligada alimentação elétrica. Mas ao contrário do que o nome indica, FRAM não é afetada por campos magnéticos, pois não possui realmente ferro na composição do chip. Materiais "ferro-elétricos"mudam de polaridade em um campo elétrico, mas não são afetados por campos magnéticos.

Quais são as vantagens da FRAM sobre Flash/EEPROM?

1) Velocidade! FRAM possui tempos de escrita bem mais curtos. Levando em conta todas operções envolvidas, um ciclo de escrita da FRAM leva menos de 50ns (nanosegundos). Isso é aproximadamente 1000x mais rápido que a EEPROM. Sem falar que a EEPROM precisa de dois passos de escrita: um comando de escrita, seguido por um comando de leitura/verificação. Já a função de escrita na memória FRAM acontece no mesmo processo de leitura da memória. Ou seja, existe apenas um comando para escrita e para leitura. Então, na prática, todo trâmite demorado de escrita da EEPROM é eliminado com eficiência em um modelo baseado em um chip FRAM.

2) Baixo Consumo. A escrita em uma célula da FRAM ocorre em baixa voltagem; e muito pouca corrente é suficiente para alterar os dados. Na EEPROM precisamos de altas voltagens. FRAM utiliza tensão de 1.5V, sendo que essa baixa voltagem se traduz em eficiência energética e permite adicionar mais funcionalidades a taxas mais altas de transferência.

3) Confiabilidade. Pela razão de apenas uma pequena quantidade de energia ser necessária para alimentar a FRAM, o chip já consome de antemão toda energia necessária para funcionar, evitando perda de dados (data-tearing), que é um efeito que ocorre na EEPROM. Além disso, FRAM acumula mais de 100 Trilhões de ciclos de leitura/escrita, ou mais -- excedendo de longe os ciclos de escrita da EEPROM.

Como utilizar no Arduino?

Existe um módulo da Adafruit:

https://www.adafruit.com/products/1897

Mas basta usar diretamente o chip MB85RS256 da Fujitsu para ter 256K de memória não volátil adicionais no seu Arduino!

http://www.fujitsu.com/downloads/MICRO/fma/formpdf/fram_rs256fs.pdf

Veja também a biblioteca para FRAM no Arduino:

Versão 1:
http://hackscribble.github.io/hackscribble-ferro-library/

Versão 2:
https://github.com/adafruit/Adafruit_FRAM_SPI

Abraços
Renato Aloi

Cobertura 4G no Brasil

Bom dia!

Até uns anos atrás, apenas reparávamos no ícone do sinal da rede de celular, quando aparecia o famoso "3G" escrito no topo da tela.

Ficávamos eufóricos quando isso acontecia! E finalmente a conexão fluia! Era até possível navegar na Internet pelo 3G! Baixar email no celular!

A gente ficava olhando aquele "EDGDE" escrito no topo da tela, como se pudéssemos alterá-lo com o poder da mente!

De repente aparecia o tal 3G... Mas só em alguns pontos da cidade de SP.

Agora estou em Uberlândia e meu Android (que ainda não é o tal de Caramelow), aparece a seguinte simbologia:

E, H, H+, 3G, 4G


Eu só vi esse 4G aparecer (depois que eu troquei o chip para essa nova tecnologia) lá no centro da cidade, em alguns pontos... E ainda sim muito instável.

Aqui na periferia fica sempre ativo o E e as vezes, entra o H (maioria das vezes). Mas bem de vez em quando entra um modo H+. Vai entender!

Eu não sei como eles fatiaram essas faixas de frequencia e nem como organizaram essas portadoras, mas ainda há muito trabalho a ser feito!

O aumento de velocidade quando pula de um Edge para um 3G ou ainda para o 4G é realmente gritante (!) mas a impressão que dá é que "eles" não "liberam" o total do sinal pois a rede não aguentaria o fluxo de dados.

A maior prova disso é que a próprias operadoras estão tendo que limitar o consumo de dados dos clientes.

Na verdade os limites sempre existiram, mas só agora como as velocidades do 4G, conseguimos consumir taxas absurdas de download. E isso está causando problemas para as operadoras e fazendo com que elas tenham que investir em equipamentos caros. O que acaba encarecendo mais ainda a telefonia no Brasil.

A agência que regula telefonia só aplica multas e castigos para os "excessos" que as operadoras aprontam.

Mas quando as operadoras estão excedendo nas suas torturas, é porque o consumidor final já sofreu tanto que ficou evidente! Começa a aparecer notícias na mídia, etc.

Mas a grande verdade é que as agências reguladoras não regulam, os agentes de concessão apenas concedem, e ninguém quer fazer o trabalho de acompanhar de perto o andamento dessas implantações tecnológicas no Brasil.

Enquanto faltarem engenheiros nos cargos e sobrarem politicos nas agências em ONG's, continuaremos assim.

Abraços,
Renato Aloi

Clonagem de Controle de Portão com Arduino

Pessoal,

Bom dia! Eu resolvi escrever hoje sobre esse assunto, pois é de interesse de proprietários de portões eletrônicos, síndicos e administradores de condomínios em geral.

Eu sei que a molecada está doida querendo clonar tudo! Mas vamos com calma aí! Esse post inclusive não é voltado para o técnico, ao contrário, é voltado para o usuário do sistema de portão eletrônico.

Eu tenho uma biblioteca de Controle Remoto RF para Arduino, conforme segue link:

https://github.com/renatoaloi/RFremote

Mas tomei o cuidado de não publicar a parte de clonagem!

Mas e se você tivesse publicado, Renato?

Bom, quando eu publiquei a minha biblioteca no GitHub, em 2013, os fabricantes de controladora de portões eletrônicos já estavam se antecipando e usando códigos criptografados para aumentar a segurança na hora de abrir o portão da garagem.

Eu sei que é tudo uma questão de tempo até que se consiga quebrar todas essas proteções que as empresas de segurança criam, mas até lá elas criam outras e assim vamos tendo alguma segurança.

Vamos entender como funciona essa briga de gato-e-rato e também porque ela acontece!

Porque tem gente tentando quebrar segurança desses controles?

Nem todos são bandidos. Lógico que existem aqueles que desejam um programa igual daqueles filmes de aventura, que com alguns cliques o meliante abre o portão da vítima.

Mas a Internet está aí e programadores do mundo inteiro podem ser contratados com alguns cliques em sites específicos... Precisamos entender onde estão os pontos fracos para nos defender.

E ao mesmo tempo, temos estudantes, hobbistas, músicos, querendo aprender e utilizar essa tecnologia para seus fins.

Ahh, você pensa: Mas estão querendo roubar a criptografia do sistema de portão eletronico desse jeito!

Não é bem assim. As fabricantes de controladoras de portão eletrônico não possuem tecnologia de criptografia. Elas importam de empresas como Microchip, Atmel, etc. Então, muitas vezes os programadores das empresas que fabricam essas controladoras possuem o mesmo conhecimento (ou menos) de um programador experiente da indústria!

Então é um jogo de gato e rato pois as empresas de portões eletrônico tem que consultar os hackers especialistas em quebrar esses códigos para justamente saber qual a melhor opção. E tem que ser assim!

Um bom hacker que consegue uma façanha dessas deve ser contratado e não preso!

Ahhh, mas como saber se eu estou seguro com o meu portão eletrônico?

A dica que eu quero deixar para os moradores,  síndicos e administradores de condomínio que fazem uso de portão eletrônico, verifiquem qual tecnologia é utilizada para criptografia dos dados.

Vejamos, existem atualmente 3 tipos de segurança envolvendo acionamento de portões eletrônicos.

1) Learning Code - Sem criptografia
2) Rolling Code - Criptografia por "rolagem" de chave-privada
3) Hopping Code - Criptografia KeeLoq da Microchip de 128-bit

O primeiro é o Learning Code, que não tem criptografia e se você está usando esse tipo de sistema no seu portão eletrônico, você NÃO está seguro!

O segundo Rolling Code é bem mais seguro e é baseado em uma chave fornecida pela empresa fabricante da controladora. O usuário nem percebe que essa chave existe e sem ela o hacker mal-intencionado não consegue fazer nada! Você ESTÁ seguro! Até um futuro próximo. Pois não é impossível tentar advinhar essa chave, pois ela não é grande como nosso próximo caso.

O terceiro e último sistema de segurança é o Hopping Code, que é o mais atual e mais seguro que se manterá assim por bastante tempo no futuro. Mesmo os melhores hackers vão ter que suar muito a camisa pra conseguir burlar a chave de 128-bits e a criptografia KeeLoq da Microchip, que é uma das principais fabricantes de chip no MUNDO.

Verifique então com seu fornecedor qual é o chip que ele está usando ao lhe fornecer o equipamento.

Qual Chip deve ter meu equipamento para eu me sentir seguro?

Abra o controle remoto do seu portão eletronico e tente ler as inscrições no chip principal da placa. Compare com as informações abaixo para saber se você está seguro ou não:

Chip HT6P20X - Troque imediatamente seu sistema de portão eletrônico! Pois ele não é seguro!

Chip HCSXXXX - Se seu chip começa com HCS, pode ficar tranquilo, você está seguro, mas tenha em mente nos próximos 4 anos trocar pelo Hopping Code.

Chip MCSXXXX - Esses são da Microchip, você estará seguro pelos próximos 4 anos pelo menos.

Não existe computador no mundo atualmente que consiga quebrar uma chave de criptografia de 128-bits nos próximos 2 anos pelo menos.


Mas como tudo muda muito rápido, pode ser que a minha previsão não chegue a 4 anos. Vamos ver!

Material para leitura:

• https://acturcato.wordpress.com/2014/01/14/clonagem-de-controle-remoto-rf-learning-code-ht6p20b-com-arduino/
• https://en.wikipedia.org/wiki/Rolling_code
• http://www.microchip.com/pagehandler/en-us/technology/embeddedsecurity/technology/home.html 

Para finalizar, se você gosta de números, veja quando tempo levaria para quebrar uma chave de 128-bits:

São 2¹²⁸ = 340282366920938463463374607431768211456 possiveis chaves de  128 bits; significa que levaria milhões de anos para descobrir a chave certa.

Fonte: http://security.stackexchange.com/questions/31726/why-so-long-to-break-128-bit-encryption


Abraços,
Renato

Tutorial Matemática de Bits no Arduino

Introdução

Normalmente quando programamos no ambiente computacional do Arduino (ou em qualquer outro computador), habilidades como manipular bits individualmente se tornam úteis e até necessárias. Aqui algumas situações onde a Matemática de Bits pode auxiliar:

• Economizar memória, armazenar 8 valores binários (true/false) em apenas 1 byte
• Ativar/Desativar bits individualmente para controlar Registradores de Porta
• Executar determinadas operações aritméticas, envolvendo cálculos em potência de base 2

Neste tutorial primeiro exploraremos o básico dos operadores de bit disponíveis na linguagem C++. Então aprendermos a combinar essas técnicas para efetuar certas operações bem úteis.

Sistema Binário

Para explicar melhor os operadores de bit, este tutorial apresentará a maioria dos valores inteiros usando a notação binária, também conhecida como “Base de 2” ou “Base Binária”. Neste sistema binário, todos os valores inteiros são expressos utilizando-se apenas dígitos 0 e 1. É dessa forma que todos os equipamentos eletrônicos armazenam dados internamente. Cada dígito 0 ou 1 é chamado de bit, que é um apelido para “binary digit” (dígito binário, em inglês).

No sistema decimal (base 10), que estamos acostumados, fatorando um número como 572 temos 5*10² + 7*10¹ + 2*10⁰. Da mesma forma, fatorando um número binário como 11010, temos 1*2⁴ + 1*2³ + 0*2² + 1*2¹ + 0*2⁰ = 16 + 8 + 2 = 26 (em decimal).

Infelizmente a maioria dos compiladores C++ não fornecem quaisquer meios para o programador expressar números binários diretamente no código. Mas felizmente o Arduino, desde a versão 0007, possui as constantes B0 até B11111111 definidas por para nos ajudar a representar números binários de 8 bits, do 0 ao 255 (em decimal).

Dica: Lembre-se que 2⁸ = 256

Operador de Bit AND

O operador de bit chamado AND no padrão C++ é expresso por um “ampersand” &, usado entre duas expressões numéricas. O operador AND manipula cada posição de bit, atuando sobre os números envolvidos na operação, de acordo com a seguinte regra: se ambos os bits da mesma posição em ambos os lados da expressão forem 1, o resultado também é 1, caso contrário o resultado é 0. Uma outra forma de escrever isso é:

0 & 0 == 0

0 & 1 == 0

1 & 0 == 0

1 & 1 == 1

No Arduino, o tipo de variável int é um valor de 16-bits, então ao usarmos o operador & entre duas expressões int, temos 16 operações simultâneas ocorrendo, uma para cada posição de bit. Em um fragmento de código como este:

int a =  92;    // em binario: 0000000001011100

int b = 101;    // em binario: 0000000001100101

int c = a & b;  // resultado:  0000000001000100, or 68 in decimal.

Cada um dos 16 bits da variável a ou b são processados usando o operador AND, e todos os 16 resultados são gravados na variável c, gerando o valor 01000100 em binário, que é 68 em decimal.

Um dos usos mais comuns para o operador de bit AND é selecionar um (ou mais) bit(s) a partir de um valor inteiro, o que chamamos de “masking” (mascarar). Por exemplo, se você quiser acessar o último bit menos significante da variável x, e guardá-lo na variável y, você poderia usar o código a seguir:

int x = 5;       // em binario: 101

int y = x & 1;   // agora y == 1

x = 4;           // em binario: 100

y = x & 1;       // agora y == 0

Dica: Use essa técnica para saber se o número é par ou impar. Se você verificar o bit mais alto, você consegue determinar se o número é positivo ou negativo. Veja mais abaixo...

Operador de Bit OR

O operador OR em C++ é o símbolo de barra vertical |. Assim como o operador &, o operador | atua independentemente em cada bit dos dois lados da operação. Mas o que ele faz é diferente (claro). O operador OR retorna 1 quando qualquer um dos bits de entrada for 1, caso contrário, retorna 0. Em outras palavras:

0 | 0 == 0

0 | 1 == 1

1 | 0 == 1

1 | 1 == 1

Abaixo podemos ver um exemplo de uso do operador OR em um trecho de código C++:

int a =  92;    // em binario: 0000000001011100

int b = 101;    // em binario: 0000000001100101

int c = a | b;  // resultado:  0000000001111101, ou 125 em decimal.

O operador de bit OR é normalmente usado para garantir que um bit esteja ligado (configurado com valor 1) em uma determinada expressão. Por exemplo, para copiar os bits da variável a para variável b, garantindo que o último bit seja 1, use o seguinte código:

b = a | 1;

Operador de Bit XOR

Temos aqui um operador não muito usual em C++ chamado operador de bit exclusivo OR, também conhecido por XOR. Este operador é expresso pelo símbolo de circunflexo ^, e é similar ao operador OR, exceto pelo fato que ele retorna 1 quando apenas um dos lados da operação tem entrada com valor 1. Se ambos os bits dos dois lados da operação forem 0 ou forem 1, ambos ao mesmo tempo, o retorno do XOR será 0, conforme segue:

0 ^ 0 == 0

0 ^ 1 == 1

1 ^ 0 == 1

1 ^ 1 == 0

Outra forma de olhar para o operador XOR é que o resultado é 1 quando ambos bits da operação são diferentes; e o resultado é 0 quando são iguais, ao mesmo tempo.

Temos aqui um código de exemplo:

int x = 12;     // em binario: 1100

int y = 10;     // em binario: 1010

int z = x ^ y;  // em binario: 0110, ou em decimal = 6

O operador ^ é normalmente usado para inverter um valor de 1 para 0 e vice-versa. Atuando em apenas um ou mais bits da equação e deixando outros em paz. Por exemplo:

y = x ^ 1;   // inverte o bit menos significativo em x

   // e guarda resultado em y.

Operador de Bit NOT

O operador NOT em C++ é escrito usando o símbolo do til ~. Ao contrario dos operadores & e |, o operador NOT é aplicado a um único operando que fica a direita. O operador NOT muda cada bit para seu oposto: 0 vira 1 e 1 vira 0. Por exemplo:

int a = 103;    // em binario:  0000000001100111

int b = ~a;     // em binario:  1111111110011000 = -104

Você deve estar surpreso de ver um número negativo como resultado da operação, como -104. Isto acontece porque o bit mais alto de um número inteiro é chamado de bit de sinal. Se o maior bit do número, em questão, for 1, significa que ele é interpretado como negativo. Esta codificação de positivo e negativo de um número é chamada de “complemento de dois”.

As vezes um inteiro com sinal pode causar problemas na programação. Veremos mais adiante.

Dica: Para retirar o sinal de um tipo de variável, declare-a antecedendo com a palavra "unsigned". Exemplos: unsigned int a; unsigned long b; unsigned char c;

Operadores de Deslocamento de Bit

Existem dois operadores de deslocamento na linguagem C++: o operador de deslocamento para a esquerda << e deslocamento para direita >>. Estes operadores deslocam os bits do operando da esquerda da equação pela quantidade de posições determinadas pelo operando da direita. Por exemplo:

int a = 5;        // em binario: 0000000000000101

int b = a << 3;   // em binario: 0000000000101000 = 40

int c = b >> 3;   // em binario: 0000000000000101 = 5

Quando você desloca um valor x por y bits (x << y), a quantidade y de bits mais a esquerda de x será perdida, deslocada para o além:

int a = 5;        // em binario: 0000000000000101

int b = a << 14;  // em binario: 0100000000000000
   // descartou primeiro 1 de 101

O importante é que não existam bits de interesse mais a esquerda quando for efetuar um deslocamento para esquerda. E a mesma coisa vale para o deslocamento a direita. Uma forma simples de encarar este operador é que o deslocamento para a esquerda é o mesmo que 2 elevado ao operando da direita. Por exemplo, para gerar potências de 2, as seguintes expressões podem ser usadas:

1 <<  0  ==    1

1 <<  1  ==    2

1 <<  2  ==    4

1 <<  3  ==    8

...

1 <<  8  ==  256

1 <<  9  ==  512

1 << 10  == 1024

...

Quando você desloca x a direita por y bits (x >> y), e o bit mais alto é 1, o comportamento depende do tipo de dados da variável x. Se x for do tipo int, é bit mais alto é o que controla o sinal, determinando se x é positivo ou negativo. Como discutido acima, nesse caso, o bit do sinal é copiado para os bits mais baixos, por razões historicamente esotéricas!

int x = -16;     // em binario: 1111111111110000

int y = x >> 3;  // em binario: 1111111111111110

Esse fenômeno é chamado de extensão de sinal. E normalmente não é o efeito que você quer. Ao invés disso, você esperararia que zeros fossem preenchendo os bits novos mais a esquerda. Acontece que as regras para deslocamento a direita são diferentes para as variáveis do tipo unsigned int, então você pode usar um “cast” para suprimir os 1's aparecendo na esquerda.

int x = -16;               // em binario: 1111111111110000

int y = unsigned(x) >> 3;  // em binario: 0001111111111110

Se você tomar cuidado em evitar tipos de dados com sinal, você então pode usar o operador de deslocamento a direita >> como uma forma de dividir pelas potências de 2. Por exemplo:

int x = 1000;

int y = x >> 3;   // divisao de 1000 por 8
    // resultado y = 125.

Operadores de Atribuição

Muitas vezes na programação queremos operar nos valores de uma variável x e guardar essa informação modificada de volta na mesma variável x. Na maioria das linguagens de programação, por exemplo, você poderia incrementar o valor por 7, usando o seguinte código:

x = x + 7;    // incrementa x em 7

Por causa desse tipo de coisa ocorrer tão frequentemente, a programação C++ oferece um atalho em forma de operadores de atribuição especiais. O código acima pode ser escrito de forma mais concisa, assim:

x += 7;    // incrementa x em 7

Acontece que os operadores de bit AND e OR, deslocamento para direita e deslocamento para a esquerda, todos eles também possuem atalhos de atribuição. Vejamos um exemplo:

int x = 1;  // em binario: 0000000000000001

x <<= 3;    // em binario: 0000000000001000

x |= 3;     // em binario: 0000000000001011

            // porque 3 = 11 em binario

x &= 1;     // em binario: 0000000000000001

x ^= 4;     // em binario: 0000000000000101
     // inverte usando mascara 100

x ^= 4;     // em binario: 0000000000000001
     // inverte usando mascara 100 de novo

Não existe atalho para o operador de bit NOT, então se você precisar inverter os bits de uma variável x, você precisará fazer assim:

x = ~x;    // inverte todos os bits de x

    // guarda de volta em x

Tradução livre do original http://playground.arduino.cc/Code/BitMath

Por Renato Aloi

Arduino - Manipulação Direta de Portas

Registradores de Portas

Registradores de portas (PORT) nos permitem acesso de baixo-nível e uma manipulação mais eficiente das portas de e/s do microcontrolador, em uma placa Arduino. Vamos falar dos chips utilizados, que podem variar entre o ATMega8, 168 e 328. Estes chips em questão possuem 3 canais de Portas:

• B (portas digitais de 8 a 13)
• C (entradas analógicas)
• D (portas digitais de 0 a 7)

Cada canal é controlado por 3 Registradores (sendo 1 de configuração, um de manipulação de portas digitais e um só de leitura), e cada qual pode ser definido como variável de sistema, na linguagem do Arduino.

1) Existe um registrador chamado DDR que configura o sentido da porta se ela é de saida (OUTPUT) ou de entrada (INPUT).
2) O Registrador PORT controla se a porta está no estado lógico alto (HIGH) ou baixo (LOW).
3) Existe também o Registrador PIN que efetua a leitura das portas configuradas como INPUT pela função pinMode().

O mapeamento dos chips ATmega8 e ATmega168 mostram essas portas. O chip Atmega328p que é mais novo, segue o mesmo modelo de portas do Atmega168 exatamente!

Os Registradores DDR e PORT podem ser escritos e lidos. Já o Registrador PIN só pode ser lido!

PORTD mapeado para as portas digitais 0 até 7 do Arduino

DDRD - Registrador de Sentido do Port D - leitura/escrita

PORTD - Registrador de Estado do Port D - leitura/escrita

PIND - Registrador das Entradas do Port D - leitura apenas

PORTB mapeado para as portas digitais 8 até 13 do Arduino. Os dois bits mais altos (6 e 7) são dos pinos do cristal e não são usados.

DDRB - Registrador de Sentido do Port B - leitura/escrita

PORTB - Registrador de Estado do Port B - leitura/escrita

PINB - Registrador das Entradas do Port B - leitura apenas

PORTC mapeado para as portas analógicas 0 até 5 do Arduino. Pinos 6 e 7 são acessíveis apenas no Arduino Mini

DDRC - Registrador de Sentido do Port C - leitura/escrita

PORTC - Registrador de Estado do Port C - leitura/escrita

PINC - Registrador das Entradas do Port C - leitura apenas

Cada bit desses 3 Registradores correspondem a uma única porta; exemplo: os bits mais baixos dos Registradores DDRB, PORTB e PINB são referentes ao pino PB0 (porta digital 8). Para conhecer o mapeamento completo de portas do Arduino e dos bits dos Registradores, acesse o diagrama correspondente ao seu chip: ATmega8, ATmega168. (Nota: Alguns bits de algumas portas podem ser usados para outras funcionalidades além de e/s (entrada/saida); seja cuidadoso para não alterar os bits correspondentes a essas portas)

Atenção! Nota do Renato Aloi! Não altere os bits da porta serial! Você pode desligar ela e vai ser difícil ligar ela de novo! Veja mais abaixo, continue lendo...

Exemplos

Se pegarmos os pinos do mapeamento acima, os Registradores referentes ao PortD controlam as portas digitais 0 até 7.

Você deve notar, entretanto, que as portas 0 e 1 já são usadas pela comunicação serial, para carregar programas e para depuração. Portanto, alterar os bits dessas portas deve ser evitado para não desligar a serial! Esteja avisado que estes procedimentos podem interferir no funcionamento da Serial e que você pode acabar não conseguindo mais carregar programas no Arduino!

DDRD é o registrador que configura a direção para o PortD (portas digitais 0-7 do Arduino). Os bits nesse Registrador controlam se as portas do PORTD estão configuradas como entradas ou saídas, por exemplo:

DDRD = B11111110;  // configura portas 1 ate 7 como saidas,

                   //e a porta 0 como entrada

DDRD = DDRD | B11111100;  // esta eh uma forma mais segura 

                   // de configurar os pinos 2 ate 7 como saida

                   // sem mudar as configuracoes dos 

                   // pinos 0 e 1 que sao da serial 

Vide operadores de bit nas páginas de referência The Bitmath Tutorial do Playground (traduzido para português por Renato Aloi).

PORTD é o Registrador dos estados das saídas. Por exemplo:

PORTD = B10101000; // registra valor HIGH 

                   // nas portas digitais 7,5,3

Você deverá ver 5V saindo nessas portas, mas só se você configurou o Registrador DDRD como saída, ou através da função pinMode().


PIND é o Registrador das entradas. E ele faz a leitura de todas as portas digitais de uma só vez!

Porque usar Manipulação Direta de Portas?

Retirado do The Bitmath Tutorial:

De forma geral, fazer esse tipo de acesso direto a portas não é uma boa ideia. Porque não? Aqui vão algumas razões:

• O código fica muito mais difícil de ler e de manter. Além de ser muito mais difícil para outras pessoas poderem entender ou reaproveitar seu código. Leva apenas alguns microsegundos para que o processador execute o código, mas você pode levar horas para encontrar algum defeito e consertá-lo!
• O código é menos "portável". Se você usar as funções digitalRead() e digitalWrite(), é muito mais fácil de escrever códigos que vão funcionar em todas as versões das placas Arduino. Já controlar diretamente os Registradores é diferente para cada tipo de microcontrolador.
• Não é difícil causar avarias por acidente enquanto programando e testando acesso direto às portas digitais. Executar a linha DDRD = B11111110; trocando o 0 final por 1, sem querer, ou por distração mudará a configuração do pino RX da serial para saída em vez de entrada e seu Arduino ficará "surdo" da serial.

Então você deve estar pensando: Legal! Nunca vou usar esse negócio então! Mas não é bem assim, existem muitas vantagens em se usar essa técnica de acesso direto às portas, tais como:

• Você pode querer mudar o estado (entre ligado e desligado) de uma porta muito rapidamente, em frações de microsegundo. Se você der uma olhada no código lib/targets/arduino/wiring.c, verá que as funções digitalRead() e digitalWrite() são compostas de uma dúzia de linhas, que ao serem compiladas formam algumas instruções de máquina. Cada instrução de máquina precisa de um ciclo de clock rodando a 16Mhz, que pode adicionar erros de tempo em circuitos críticos, como processamento de sinal, etc. Manipulação direta das portas pode fazer o mesmo serviço em muito menos ciclos de clock.
• Algumas vezes você precisa acionar várias portas digitais ao mesmo tempo, e não pode esperar acionar uma primeiro pra depois acionar a outra. Chamando a função digitalWrite(10,HIGH); seguida por digitalWrite(11,HIGH); fará com que a porta 10 primeiro fique em estado HIGH, para apenas vários microsegundos depois a porta 11 também ficar com estado HIGH. Se houver algum circuito externo que espere que ambas as portas fiquem ativas ao mesmo tempo, ele não funcionará. Mas usando acesso direto as portas, você pode configurar as portas para ficarem ativas ao mesmo tempo, com a mesma instrução PORTB |= B1100;
• Ou se você está sem memória FLASH, você pode usar essas tecnicas para fazer seu código ficar menor. Pois muito menos instruções serão geradas para alterar o estado das portas usando manipulação direta do que pelas funções. As vezes esses truques são a diferença que fazem seu programa caber na memória flash ou não!

Veja Também

• Mapeamento de Portas do Atmega 168/328

The text of the Arduino reference is licensed under a Creative Commons Attribution-ShareAlike 3.0 License. Code samples in the reference are released into the public domain.
Tradução livre do original https://www.arduino.cc/en/Reference/PortManipulation
Por Renato Aloi