Todo mundo sabe que, em binário, quando estamos trabalhando somente com 1 bit de precisão, 1+1 = 0. Mas, como fazer um circuito que calcule isto?

Se você leu os artigos anterior, aprendeu que a soma binária ocorre bit a bit, e o overflow é adicionado ao próximo elemento.

Um circuito somador precisa somar 2 valores binários. É necessário ainda, que o sistema avise quando ocorre um overflow. Considerando que nosso sistema é capaz de trabalhar apenas com valores de 1 bit (1 bit em cada uma das duas entradas, 1 bit de saida), vamos analizar a soma:

0+0=0, e não há overflow.

1+0 (ou 0+1), = 1, e não há overflow.

1+1=10. Como 10 são 2 bits, há overflow: 1+1=0 com overflow.

Logo,nosso circuito deve ser capaz de realizar a soma e avisar a ocorrência de um overflow.

Um desenho que se adequa as nossas necessidades é este:

Observe: 0+1:

E agora 1+1:

Este circuito realiza a soma de forma correta.  Porém, ele soma somente 2 bits, ele não é muito util. Seria interessante se desse para construir um circuito que, além dos 2 valores de entrada, recebesse  um terceiro valor de entrada. Se ligar-mos este terceiro valor de entrada na saida de overflow de outro circuito somador, teremos um circuito de soma genérico – basta apenas cascatear os circuitos para somar vários bits. E é isto que iremos fazer agora:

Um circuito somador completo possui esta caracteristica, e pode ser representado da seguinte forma:

Por questões de espaço não vou mostrar cada um dos estados possiveis.

A questão é a seguinte: Este somador soma 2 valores de 1 bit, emitindo o resultado com 1 bit e se houve ou nao overflow. Ele também possui uma terceira entrada, que representa o valor do “Overflow Anterior”. Se ligar-mos em série vários cirtuitos destes, podemos somar 2 valores de mais de 1 bit, como o seguinte circuito, que soma 2 valores (A e B) de 2 bits cada:

O desenho ficou um pouco confuso pois eu fui obrigado a reduzir para caber no post.

Para facilitar, colocarei 2 exemplo: A soma de 01 + 01:

Observe que o valor de Overflow é transferido para a entrada de overflow do proximo circuito – exatamente como se faz na soma manual. Mas, e quando 11+01 for somado? O resultado é 100, que é muito grande para a precisão de 2 bits que este circuito possui. Nesta situação, ocorre o seguinte:

Observe que o Overflow passou a ser 1, enquanto o resultado 00. Esta soma esta correta.

Para fazer um circuito capaz de somar 3, 4, 10, 1000, 10209193123 bits, basta ir interligando os circuitos.

É importante lembrar que, o mesmo circuito de soma, é usado para subtração – a subtração é a a mesma operação de soma, porém com o segundo valor multiplicado por -1 (ou seja: 2 – 5 é o mesmo que 2 + (-5)).

O logisim possui uma função pré-pronta para representar o somador (há também para a subtração, multiplicação e divisão), o simbolo é:

O mesmo circuito do somador de 2 bits pode ser feito da seguinte forma:

Que é bem mais simples de entender! O logisim possui a capacidade de fazer somadores de 2, 3, 4, até 32 bits nativamente. Se usarmos a técnica de combinação mostrada acima, é possivel criar circuitos para calcular qualquer quantidade de bits.

Em minha opinião, a representação gráfica torna mais intuitiva e fácil de entender o funcionamento de um circuito. E o uso de simuladores, como o Logisim, que permite a construção e simulação de circuitos lógicos, esta tarefa torna-se mais simples e até mesmo divertida!

Neste artigo iremos estudar alguns conceitos básicos, e nos próximos artigos iremos construir algumas estruturas básicas para a informática.

Primeiramente, é necessário entender os símbolos que representam as operações:

As 3 operações básicas, And, Or e Not, são representadas da seguinte forma:

À esquerda do simbolo ficam as entradas, à direita fica a saida.

As operações secundarias: Xor, Nand, Nor, xnor (xor negado), etc, são representadas da seguinte forma:

Novamente,  na esquerda ficam as entradas, na direita as saídas.

Quantas entradas cada operação pode ter? Depende da operação : Para todas elas (Exceto o not), o minimo é 2 entradas, o máximo é até o infinito (o simulador logisim limita o máximo até 5), e as saídas, depende da função: Todas estas tem somente uma saída.

Conhecendo as operações básicas, para construir um circuito é só juntar os pedacinhos.

Vamos fazer um “exercício?”

Todos conhecem o que é uma “chave hotel”. Para quem não sabe, uma chave hotel é usado para que 2 interruptores controlem uma mesma lampada: Imagine um corredor bem grande com uma lampada no meio. É só colocar um interruptor da chave hotel em cada ponta do corredor para ligar ou desligar a lampada, não importando qual interruptor seja utilizado.

Podemos representar este circuito, usando somente as 3 operações básicas (and, or e not) da seguinte forma:

“Chave A e Chave B” são os 2 interruptores. C é a lampada.

Torna-se simples acompanhar o que acontece com o circuito quando se tem um desenho explicando o circuito.

No caso do logisim, é possivel acompanhar o que acontece à cada operação, conforme a figura abaixo:

As linhas verdes mostram as trilhas por onde passa o 1, as pretas por onde esta passando 0.

Agora a chave está desligada

É simples. Simples mesmo. Baixe e brinque com o LogiSim, você entenderá facilmente todas estas operações. O programa ainda conta com mecanismos para transformar tabelas-verdade em circuitos (este circuito da lampada foi gerado desta forma). Nos proximos capitulos irei falar sobre alguns elementos básicos da informática, como mecanismos somadores, decodificadores, multiplexadores, e sobre memórias (flip flops, registradores, memórias) e explicarei para que serve o “Clock” do sistema (isso mesmo, para que servem todos os megahertz dos processadores dos nossos pcs!)

A função NAND e NOR são, respectivamente, a função AND negada, e OR negado:

A NAND B = NOT (A AND B)
A NOR B = NOT (A OR B)

Por que estas duas funções são importantes?

Porque usando apenas a função NAND ou a função NOR, é possivel fazer QUALQUER CIRCUITO. De fato, é possivel fazer um processador usando somente NAND.

A função NOT A, por exemplo, é o mesmo que A NAND A.
A função A OR B é o mesmo que (A NAND A) NAND (B NAND B).
A função A AND B é o mesmo que (A NAND B) NAND (A NAND B).

Mas, qual a vantagem em transformar “OR” e “AND” em “NAND”?

É que, apesar da equação ser maior, os custos de produção de chips usando somente NAND são menores – o fato é que, a construção de um circuito NAND é muito simples, e é bem mais simples fazer um circuito usando sempre o mesmo componente do que usando componentes variados, mesmo que seja necessário um numero maior de componentes. Só para constar: A NAND B retorna falso somente se A e B forem verdadeiros. O NOR é o contrario: Retorna verdadeiro somente se A e B forem falsos.

A função XOR é super importante para criptografia, e funciona da seguinte forma:

A XOR B.
Se A = B, então retorna falso.
Se A for diferente de B, retorna verdadeiro.

A função XOR tem uma propriedade matemática importantissima, que é representada pelas equações abaixo:

A XOR B = C.
A XOR C = B
C XOR B = A

No proximo artigo contruiremos circuitos lógicos, o que vai facilitar a compreensão destas funções.

As operações AND e OR são:

Associativas:

A OR ( B OR C) = (A OR B) OR C = A OR B OR C
A AND (B AND C) = (A AND B) AND C = A AND B AND C

Comutativas:

A OR B = B OR A
A AND B = B AND A

Distribuitivas:

A OR (B AND C) = (A OR B) AND (A OR C)
A AND (B OR C) = (A OR B) AND (A OR C)

Idempotentes:

A AND A = A
A OR A = A

Absorvitivas:

A OR (A AND B) = A
A AND (A OR B) = A

Outros fenômenos que eu não sei o nome mas são verdades:

NOT NOT A = A

A AND 0 = 0
A AND 1 = A

A OR 1 = 1
A OR 0 = A

Existe também as chamadas “Leis De Morgan”, ou “Teorema De Morgan”. De Morgan é o nome do inventor das regras – Augustus De Morgan (wikipedia) – que permitem transformar o OR em AND sem alteração do resultado. As regras funcionam da seguinte forma:

NOT ( A OR B) é o mesmo que (NOT A) AND (NOT B)
NOT ( A AND B) é o mesmo que (NOT A) OR (NOT B)

Na álgebra booleana não existem números: Existem variáveis lógicas, que podem ser ou Verdadeiras, representadas por 1, ou Falsas, representadas por 0. .

Como dito nos artigos anteriores, computadores só entendem se algo esta ligado ou desligado  (1 e 0). Se considerarmos o valor de “ligado” como sendo verdadeiro, e o “Desligado” como sendo falso, podemos criar uma máquinas capazes de tomar decisões.

Existem 3 operações booleanas: A função AND (e), a OR (ou) e a NOT (negação).

A função AND e a OR recebem 2 valores lógicos, retornando um valor lógico.

A função AND retorna verdadeiro se os dois valores recebidos forem verdadeiros. Caso um dos valores, ou os 2 valores seja falso, seu resultado será falso.

A função OR retorna falso se os dois valores de entrada forem falsos. Se qualquer valor de entrada for verdadeiro, ou se os 2 valores forem verdadeiros, seu resultado será verdadeiro.

A função NOT recebe somente um valor. Sua resposta será sempre o oposto da entrada: ou seja: NOT 1 =0, e NOT 0 = 1.

Complicado? As seguintes tabelas ajudarão a explicar:

É importante saber de cor estas tabelas – o que não é dificil né?

Existe uma precedência de operadores: Primeiro calcula-se o NOT. O resto dos operadores calcula-se na ordem que esta escrito. Se alguma operação estiver entre parentes, calcula-se ela antes… exatamente como na matematica convencional que todos aprenderam na escola.

Vamos calcular umas operações simples:

por exemplo:

Calculando 1 AND 0.

O valor1 é 1. O valor 2 é 0. Olhando na tabela verdade da função AND, veremos que para valor1 como 1 e valor 2 com 0, o resultado é 0.

Portanto:

1 AND 0 = 0.

Calculando 0 OR 1.

Olhando na tabela verdade da funcao OR, veremos que para valor1 como 0 e valor2 como 1, o resultado é 1.

e NOT 1? O resultado é 0 (olhe na tabela verdade…)

Agora, a grande pergunta: Para que isto pode ser util para nossa vida? Simples:

Imagine que alguem esteja desenvolvendo um mecanismo para manter a agua aquecida. O circuito é composto por 2 sensores (A e B )e uma resistencia (C).

O sensor A mede a temperatura da agua. Sempre que a temperatura estiver abaixo de 50 graus, este sensor envia um sinal elétrico. Quando a agua ultrapassa os 50 graus, o sensor para de enviar o sinal.

O sensor B mede o nivel de agua, enviando sinal elétrico se o nivel está abaixo da metade do recipiente. Quando a agua estiver acima da metade, ele para de enviar sinal.

Desejamos um circuito que ligue a resistência (seja 1) sempre que a água estiver abaixo de 50 graus E o nível de água estiver acima da metade. (para simplificar, considere que a água nunca vai ficar exatamente na metade do recipiente: Ou esta acima, ou esta abaixo da metade).

Observe o enunciado: A palavra E indica que as DUAS condições precisam ser verdadeiras, logo, usaremos uma função AND.

No momento, nossa equação está desta forma:

<condição1> AND <condição2>.

Vamos determinar que elementos servem para nossas condições 1 e 2. Primeiro pela condição 1:
A condição 1 diz que: “A agua deve estar abaixo de 50 graus”.

Sabemos que as seguintes afirmações são verdadeiras:

1) O sensor A será verdadeiro se a agua estiver abaixo de 50 graus.
2) O sensor B será verdadeiro se a agua estiver abaixo da metade.

A primeira afirmação (sobre o sensor A) é verdadeira e funciona para nossa primeira condição. Como o sinal enviado por A serve para a nossa condição 1, usaremos ele na equação.
Nossa equação agora está desta forma:

A AND <condição2>.

Vamos determinar a condição 2

A condição diz que:

“E o nível de água estiver acima da metade.”

Não existe um sensor que retorne verdadeiro se a água estiver acima da metade, porém, o sensor B retorna verdadeiro se a agua estiver abaixo da metade. É Obvio que, se a agua está abaixo da metade, é porque não está acima da metade. Assim como se a agua não está acima da metade, é porque ela esta abaixo da metade. Portanto, dizer que “E o nivel da agua estiver acima da metade”, é o mesmo que dizer “E o nivel da agua NÃO estiver abaixo da metade”.

Como o sensor B é verdadeiro se a agua estiver abaixo da metade, ao negarmos o sensor, obteremos um valor verdadeiro quando a agua estiver acima da metade, portanto, a condição 2 é NOT B.

Portanto, a equação que resolve o nosso problema de aquecimento da água é a seguinte:

A AND NOT B.

Vamos verificar?

Se a agua estiver abaixo de 50 graus e o nivel da agua estiver abaixo da metade: Ou seja: A=1 e B=1.

A AND NOT B.

1 AND NOT 1

Calculando NOT 1, obtemos 0.

1 AND 0.

O resultado de 1 AND 0 é 0, portanto, a resistencia NÃO ligará.

E se a agua estiver acima de 50 graus e o nivel estiver acima da metade? Ou seja, A=0, B=0

A AND NOT B.

0 AND NOT 0

calculando o NOT 0, obtemos 1:

0 AND 1. Que é igual a 0. A resistencia não ligará.

E se a agua estiver abaixo de 50 graus e o nivel acima da metade? Ou seja, A=1, B=0?

A AND NOT B

1 AND NOT 0

calculando o NOT 0, obtemos 1.

1 AND 1, que é igual a 1, ou seja, a resistencia ligará.

E, finalmente: E se a agua estiver acima de 50 graus e o nivel abaixo da metade? A=0, B=1

A AND NOT B

1 AND NOT 1

1 AND 0, que é 0. A resistência não ligará.

Como podemos observar, a equação realmente resolveu nossos problemas.

É claro que ficar interpretando texto para chegar a uma conclusão é meio complicado, existe métodos para resolver isto de forma mais simples e objetiva.

No proximo artigo veremos algumas regrinhas e propriedades destas estas operações.

É relativamente simples: 1 + 1 = 10!

Bom… acho que uma explicação mais detalhada é melhor

As operações de soma a subtração em binário são muito parecidas com as operações de soma e subtração convencionais: Soma-se (ou subtrai-se) os 2 números, começando pela direita, se “sobra” um numero, coloca ele no próximo algorismo (ou, na subtração, se pede “emprestado”):

Fazendo somas decimais passo a passo:

49 + 28.

Soma-se o 9 com o 8. O resultado é 17. Como 17 é maior que 10, “guardamos” o que sobra para  soma dos próximos algorismos.

Em seguida, soma-se o 4 e o 2. O resultado é 6. Como na soma dos algorismos anterior havia “sobrado” um numero, adiciona-se este numero ao 6, ou seja, 6+1=7. O resultado é 77.

A subtração é mesma coisa:

23 – 15.

Calcula-se 3 – 5. Como 3 é menor que 5, ele “pede emprestado” um numero para o 2. Então calcula-se 13-5, que é 8.

Na subtração do segundo algorismo, o 2, que “emprestou” para o 3, passou a ser 1. Então, 1 – 1 = 0. O resultado da conta é 8.

Não fiz desenho pois todo mundo já deve ter aprendido isto na escola!

Em binário, há somente 2 dígitos: 0 e 1. Porém a soma funciona da mesma forma que na álgebra normal. Devemos lembrar sempre que:

0+0 = 0
0+1 = 1
1+0 = 1
1+1 = 10.

Repare no ultimo calculo: 1+1 = 10. O “1″ do 10 é justamente o que sobra do calculo de 1+1. Este “1″ que sobrou é chamado de “Carry”.

Um ponto a ser observado é que em binário é comum ocorrer um verdadeiro “Efeito dominó” de sobras durante a soma. O que quero dizer com efeito “dominó”: Em decimal, a soma  9999 +1, como 9+1 = 10, na soma do primeiro algorismo vai sobrar um valor, que deve ser acrescentado ao segundo algorismo. Porém, esta soma também causará uma sobra, que será adicionada ao terceiro… que também causará a sobra que deverá ser adicionada ao quarto algorismo, que também sobrará e, finalmente, um quinto algorismo deverá ser adicionado, gerando a resposta 10000. Como em binário só temos 2 dígitos, este “efeito dominó” ocorre muito frequentemente. Só coloquei este alerta pois já vi casos de pessoas que, realizando exercícios, ao somar em binário acharam que o calculo estava errado por causa do efeito dominó.

continuando:

O procedimento da soma é igual na soma decimal, porém, com só 2 valores possíveis: 0 e 1.

exemplo:
10101001 + 00110011 = 11011100

Ta ali a soma. Os numeros em vermelhos são as “sobras” da soma dos algarismos anteriores. Exatamente como a soma convencional, porém usando só 0 e 1!

Se no ultimo algorismo também “sobrasse” 1, era só colocar mais um algorismo no final, exemplo:

11111111 + 00000001 = 100000000
Nós, humanos, podemos ir adicionando numerosinhos enquanto houver espaço no papel. Computadores não tem este luxo: Se o computador que realizar a soma que fiz de de 11111111 + 1 não conseguir trabalhar com mais de 8 bits, o resultado seria 00000000 e um erro de overflow!. (Overflow é quando o resultado de um calculo é muito grande para a máquina). Se a soma fosse 11111111 + 00000010, o resultado seria 00000001 com erro de overflow.  Efetivamente, 255 + 2 = 1 com aviso de erro de overflow.

É importante lembrar que, se estamos trabalhando com números de 8 bits, serão sempre 8 bits a resposta. Se estivermos trabalahndo com numeros de 16bits, a resposta será sempre 16bits! Se o resultado ultrapassar o numero de bits, então ocorre um overflow.

O maior numero possivel de representar dado um determinado numero de bits binários é dada pela seguinte equação:

(2^N)-1. Aonde N é o numero de bits. Para 8 bits, o valor é( 2^8)-1 ou seja: 256-1, ou 255. Valores entre 0 e 255 são válidos.

Não vou falar de subtração agora, pois preciso falar de números negativos e um fato sobre computadores.

Nós, humanos, sabemos diferenciar um numero positivo de um numero negativo porque, no numero negativo, existe um sinal de “menos”(-) antes do numero. Lembra quando eu disse que computadores só conhecem 0 e 1? então… eles não conhecem numeros com sinais de menos…

Se vocês se lembram da escola, 5 + (-3) é o mesmo que 5 – 3, e, obviamente, 5 -3 é o mesmo que 5 + (-3). Ou seja: A subtração de um A por um numero B é o mesmo que somar A com o B negativo. Esta propriedade matemática também se aplica em binário, e por isto, computadores não sabem subtrair! Eles só somam. Para subtrair, A de B, eles transformam B em um numero negativo,e em seguida, somam. Mas, como computadores sabem quando um numero é negativo?

Quando a infomática surgiu, um número negativo era o mesmo numero positivo porém invertido: O numero dez, em binário, é 00001010. O dez negativo é 11110101. O sistema diferencia um numero positivo de um negativo pelo “1″ no bit mais significaivo (o mais à esquerda). Este método, chamado de “Complemento de um”, funciona bem, o problema é que existe uma ambiguidade: E o numero zero? 00000000 e 11111111 represemtam 0.

E isto é um GRANDE problema, pois não existe “Zero negativo”.

Para solucionar isto, foi criado o “Complemento de dois”, que funciona assim:

Sempre que ocorre uma conversão de positivo para negativo ou vice versa, além da inversão de digitos, ocorre a soma de 1 ao valor resultante.No caso, o numero zero ficara 11111111 + 1 = 00000000.

Então, se dez positivo é 00001010, dez negativo é 11110101 + 1 = 11110110.

Para transformar dez negativo em dez positivo, basta repetir o processo: 11110110 -> 00001001 + 1 = 00001010.

Vamos testar: dez positivos somados com dez negativos, deve ser zero (10 + (-10)) = 10-10 = 0.

00001010 + 11110110 = 100000000. O 1 que sobrou é descartado pelo sistema. Isso funciona sempre. O sistema faz testes para detectar Overflows durante a soma. O teste é simples: Se os 2 ultimos bits de “vai um” (Carry) forem 1 e 1 ou 0 e 0, a troca de sinal ocorreu de forma válida. Se for 0 e 1 ou 1 e 0, então ocorreu um overflow.

Quando se lida com complemento de 2, o intervalo numérico representado dado um numero de bits é o seguinte:

De -2^(N-1) até (2^(N-1))-1. Ou seja: Para 8 bits, o intervalo vai de -2^(8-1) até (2^(8-1))-1, que é o mesmo que -2^7 até (2^7)-1, que é o mesmo que -128 até 127.

Na wikipedia, em ingles, tem uma explicação completa e detalhada sobre o complemento de 2.

Como foi possivel perceber, com 1 byte é possivel representar números entre 0 e 255, ou entre -128 e 127.

Como o sistema sabe quando um byte deve ser considerado como sendo entre 0 e 255 ou -128 e 127? Simples: Ele não sabe. O programa em execução é o responsável por definir se o byte é Unsigned (entre 0 e 255) ou Signed (entre -128 e 127).

Espero que este texto não tenha ficado muito confuso – foi o melhor que eu pude fazer para este tópico. O próximo artigo será mais legal: Falará sobre operações booleanas : And, Or, Xor, Not

O que pretendo  nestes artigos é mostrar como o processamento da informação ocorre, mostrando operações binárias básicas, mostrando como os computadores somam e subtraem, como eles sabem quando um número é negativo ou positivo, como a memória funciona, e por ai vai.

Mas antes de eu falar em qualquer coisa relacionada com “Algebra booleana”, vamos entender bases numéricas:

Quando se está na escola, aprende-se que 2+2 são 4, 3+5 é 8, 2-1 = 1, etc. A soma e subtração são as operações mais básicas possíveis na matemática comum. A partir delas obtemos a multiplicação (3×4 = 3+3+3+3 = 12), divisão (12 dividido por 3 = quantas vezes eu subtraio 3 de 12)…

Computadores também somam e subtraem, multiplicam e dividem, mas, estas operações não são “básicas” para eles.

Primeiro, vamos analisar o mundo através dos “olhos” de um computador:

Para nós, humanos, os números vão de 0 a 9, e podemos combinar eles para fazer números maiores: 10, 122, 1444…..

Antes de continuar, preciso que o leitor entenda a seguinte simbologia – quem conhece programação ja deve estar acostumado com isto, quem não conhece, bom… hora de conhecer…

• Sinal de + é a soma….
• Sinal de – é subtração…
• Sinal de * (asterisco) é multiplicação: 3*4 = 3 vezes 4 = 12
• Sinal de / é divisão: 12/3 = 12 divido por 3 = 4
• Sinal de  ^ é expoente: X^2 = X ao quadrado (X²). X^(2+x) é o mesmo que
• A palavra MOD é o resto da divisão: 13 MOD 3 = 1 (pois 13/3 = 4 e resta 1)

Então, conhecendo esta simbologia, podemos continuar.

Podemos representar qualquer numero na base decimal (a que a gente usa, com numeros de 0 a 9) com a seguinte equação:

A(n+1)*X^(n+1)+An*X^n

Aonde n é a posição do numero (unidade = 0, dezena = 1, centena = 2…), e A o algorismo correspondente a posição do numero (valor de 0 a 9). e X é sempre 10 (ja que estamos trabalhando com base 10).

O numero 6 pode ser representado assim:

A0*X^0

=6*X^0

=6*10^0 (qualquer numero elevado a 0 é 1, então 10^0 = 1)

= 6*1

= 6

O numero 9542 pode ser representado assim

A3*X^3 + A2*X^2 + A1*X^1 + A0*X^0

= 9*X^3 + 5*X^2 + 4*X^1 + 2*X^0.

X é 10 (como eu havia dito antes), então:

= 9*10^3 + 5*10^2 + 4*10^1 +2*10^0

= 9*1000 + 5* 100 + 4*10 +2*1

= 9000+500+40+2

= 9542

Como demonstrei, é possível decompor um numero decimal. Porque isto é importante? Simples: Esta formula que mostrei é “genérica” e serve para converter números de qualquer base para decimal. Nós humanos que calculamos com base 10 decompomos desta forma.

Mas, computadores, não possuem o luxo de trabalhar com dígitos de 0 a 9 em seus circuitos. Seus circuitos só conseguem entender 2 números: 1 e 0. Assim como uma lampada tem 2 estados: Acesa ou Apagada, um computador só conhece 2 estados: Ligado ou Desligado. Ligado é representado pelo digito 1, desligado pelo digito 0. Esta informação de 0 ou 1 denominamos de BITs.

Assim como nós, humanos, agrupamos números para representar números maiores (10, 30, 433…), computadores também podem agrupar seus “números” para representar números maiores, como, por exemplo, o seguintes números binários: 1, 10, 111, 1010, 10101…

A formula que usei para decompor números decimais pode ser aplicada em números binários para converter-los para decimal:

por exemplo:

A(n+1)*X^(n+1)+An*X^n

Aonde n é a posição do bit (sendo 0 o bit mais a direita) e A o algorismo correspondente a posição do numero (valor de 0 a 1). e X é sempre 2 (ja que estamos trabalhando com base 2).

O numero binário 1 pode ser convertido para decimal da seguinte forma:

A0*X^0.

=1*X^0

X = 2 (pois a base é 2)

=1*2^0

=1*1

=1

… o exemplo foi bobinho e deu na mesma… vamos tentar com outro numero:

Convertento o numero binário 10 para decimal:

A1*X^1 + A0*X^0

=1*X^1 + 0*X^0

X = 2 (pois a base é 2)

=1*2^1 + 0*2^0

= 1*2 + 0*1

= 2+0

=2

Para converter o numero 10101101 o processo é o mesmo:

A7*X^7 + A6*X^6 + A5*X^5 + A4*X^4 + A3*X^3 + A2*X^2 + A1*X^1 + A0*X^0

= 1*X^7 + 0*X^6 + 1*X^5 + 0*X^4 + 1*X^3 + 1*X^2 + 0*X^1 + 1*X^0

Todo numero multiplicado por 0 é 0. então:

= 1*X^7 + 0 + 1*X^5 +0+ 1*X^3 + 1*X^2 + 0 + 1*X^0

= 1*X^7 + 1*X^5 + 1*X^3 + 1*X^2 + 1*X^0

X = 2 (pois a base é 2)

= 1*2^7 + 1*2^5 + 1*2^3 + 1*2^2 + 1*2^0

= 1*128 + 1*32 + 1*8 +1*4 +1*1

= 128 + 32 + 8 + 4 + 1

= 173

Então: 10101101 em binário é 173 em decimal. Se estiverem duvidando, calculem na calculadora do windows (ela tem conversão de base).

Para converter de decimal para binário, é só ir dividindo o valor a ser convertido por 2 e ir colocando o resto da divisão por no numero, considerando o resultado da divisão na ultima divisão. Complicou? Simples:

Para converter 173 em binário:

173 / 2 = 86 restando 1

86 / 2 = 43 restando 0

43 / 2 = 21 restando 1

21 / 2 = 10 restando 1

10 / 2 = 5 restando 0

5 / 2 = 4 restando 1

4 /2 = 2 restando 0

2 / 2 = 1 restando 0

Então: O primeiro algarismo é o resto da primeira divisão: 173/2 = 1. O segundo algorismo é o resto da 2a divisão: 86/2, 0. E assim segue até a penultima divisão. na penultima divisão teremos o seguinte numero:

xy0101101

Observe que há um xy ali: Na ultima divisão determinaos estes valores: O resultado e o resto da divisão. sao o y e o x respectivamente: Então, 2/2 é igual a 1 (y) restando 0 (x). Substituindo temos:

010101101. Como o zero “a esquerda” não tem valor, o resultado é: 10101101.

Na infomática, um numero “0 ou 1″ é um BIT. Um conjunto de 8 bits é um Byte. Por que 8 bits = 1 byte? Por que não 9, 10…? Nenhum motivo em especial… talvez seja porque a pessoa que estava estudando como fazer um computador, há muito tempo atras, estava desenhando o circuito da máquina, tinha terminado o desenho de 8 fios para levar os bits, ai olhou pro relógio, viu que ja estava acabando o expediente, era 6a deira e ela falou “Ah, vou para casa que tem feriadão, vai ficar com 8 bits mesmo”… E deste então, o byte é a unidade padrao usada para armazenamento é o byte….

Um belo dia, alguém ficou cansado de escrever “10101010, 10101111, 10111111″ quando queria demonstrar bytes, e resolveu inventar o numeros Hexadecimais. Desde então,na informática, é comum encontrarmos valores como:

0×33, 0xFF, 0x3A, 0×41.

Estes são números hexadecimais. Os números Hexadecimais vão de 0 até F, ou seja: 0, 1, 2, 3, 4, 5, 6, 7,8 , 9, A, B, C, D, E, F (Tenha a mente aberta: Em hexadecimal, A, B, C, D, E, F são números! Assim como X e I são números romanos, A até F são números em hexadecimal), e representam o seguinte:

Números hexadecimais d e 0 a 9, são números de 0 a 9 em decimal (duh…)

os números A, B, C, D, E, F representam 10, 11, 12, 13, 14, 15 respectivamente. O prefixo 0x serve para indicar que aquele valor é um valor hexadecimal.

É possível usar a mesma fórmula para converter binário para decimal, para converter hexadecimal para decimal, por exemplo: Convertendo FC para decimal:

Lembrando que F=15 e C=12. Lembrando também que a base é 16

A1*X^1 + A0*X^0

F*X^1 + C*X^0

F=15, C=12

15*X^1 + 12*X^0

X = 16 (base 16)

= 15*16^1 + 12*16^0

= 15*16 + 12*1

= 240 + 12

= 252

É possível converter de decimal para hexadecimal usando a mesma seqüencia de divisão que demonstrei para binário: Para converter 425 para hexadecimal é simples:

425 / 16 = 26 RESTANDO 9

26 / 16 = 1 RESTANDO 10 (10 é A em hexadecimal)

1 / 16 = 0 RESTANDO 1.

Portanto,o numero é 01A9

A ultima representação é Octal: O principio é o mesmo da hexadecimal, porém com base 8 e numeros de 0 a 7. 10 em octal é 8 em decimal. 20 em octal é 16 em decimal. As formulas de conversão funcionam para octal também (elas funcionam para todas as bases). Desta vez não vou fazer um exemplo.

Sem duvida, o meio de representação mais usado é o Hexadecimal. E por que? simples: 2 digitos hexadecimais equivalem a 1 byte. Observe: Cada digito hexadecimal pode representar numeros entre 0 e 15. 4 bits também podem representar numeros entre 0 e 15.

Repare a seguinte relação:

Hexadecimal 0 = 0000 Binario
Hexadecimal 1 = 0001 Binario
Hexadecimal 2 = 0010 Binario
Hexadecimal 3 = 0011 Binario
Hexadecimal 4 = 0100 Binario
Hexadecimal 5 = 0101 Binario
Hexadecimal 6 = 0110 Binario
Hexadecimal 7 = 0111 Binario
Hexadecimal 8 = 1000 Binario
Hexadecimal 9 = 1001 Binario
Hexadecimal A = 1010 Binario
Hexadecimal B = 1011 Binario
Hexadecimal C = 1100 Binario
Hexadecimal D = 1101 Binario
Hexadecimal E = 1110 Binario
Hexadecimal F = 1111 Binario

Como cada digito hexadecimal é 4 bits, 2 digitos hexadecimal representam 1 byte, que é a unidade de informação usada pelos computadores. Devido a essa relaçao exata, é possivel converter “no olhometro” de binário para hexadecimal e vice versa, por exemplo, o byte 10011101, para converter para hexadecimal, basta agrupar em grupos de 4 bits: 1001 1101, e ai ver na tabela: 1001 = 9, 1101 = D, portanto, 10011101 = 9D. Simples não?

A camada física não se importa com a informação que vai ser enviada, com os protocolos de rede, enlace, etc, usados. Para ela, o que importa são fatores como “Qual freqüência de rádio vou encaminhar os dados”, ou “Quantos volts representam o bit 1, quantos representam o bit 0″, ou “O canal está livre para que eu possa transmitir?”. Se alguém já usou internet discada, o barulho do modem é a camada física trabalhando.

É importante notar que muitos autores (inclusive a cisco e o Tanebaum) consideram a camada física como sendo parte da camada de enlace. Em minha opinião, esta definição é incorreta. Apesar de ser fato de que todos os dados relevantes para a rede funcionar estão nas 4 camadas que descrevi anteriormente, considerar a camada física como sendo parte da camada de enlace é, em minha opinião, um erro – eu entendo que a camada de enlace é capaz de identificar os equipamentos alcançáveis diretamente pelo meio físico, porém ela não é capaz em determinar como a transmissão ocorrerá – ela apenas identifica logicamente equipamentos físicos, e nada mais. Porém, quando se trabalha com máquinas virtuais rodando no mesmo computador, a comunicação entre elas ocorre sem a necessidade da camada física – os dados nunca saem fisicamente do computador, e mesmo assim, há rede – o que torna a camada física uma camada opcional para a transmissão dos dados.

A camada física também pode (e deve!) fazer verificação de erros que podem ocorrer durante a transmissão, tais como interferências durante uma transmissão wireless, compensar as perdas elétricas causadas pela resistência dos fios em um cabo de rede, e qualquer outro fenômeno que possa interferir durante a transmissão. Isto pode ser feito por implementações em meio físico, ou através da adição de informações adicionais durante a transmissão.

Um outro fator importante de é que, enquanto a camada de enlace simplesmente descarta os pacotes inválidos, a camada física pode ser mais seletiva: Como a camada física conhece mais sobre o meio físico do que a camada de enlace, ela pode adicionar mais informações aos dados enviados para permitir correção de erros – imagine dados devam ser enviados a um satélite. Leva muito tempo até a informação chegar efetivamente ao satélite, e muitos dados podem ser corrompidos. Pode ser mais vantagem para a camada física encapsular os dados em um outro protocolo que permita que o destinatário corrija alguns erros, do que simplesmente re-encaminhar a informação – de qualquer forma, este processo será invisível para a camada de enlace.

Não vou escrever muito sobre a camada fisica, nem descrever “como funciona”, pois eu também não sei quais os padrões usados para cada tipo de transmissão.

Nos proximos artigos sobre redes falarei sobre protocolos arp, dns, icmp, e em seguida sobre firewall, roteador, proxy. Mas isto ficará para março

A função da camada de enlace é esta: Permitir a identificação, e encaminhamento de dados para equipamentos localmente conectados. É a ultima etapa antes dos dados “deixarem” o computador e embarcarem na grande viagem até o destino final.

A camada de enlace é a responsável pela identificação física dos equipamentos conectados diretamente e ela. Para a camada de enlace, ainda não importa o meio de transmissão: Radio, cabo, fibra, o que importa é que o destino seja alcançável diretamente pelo meio físico. Quando a informação chega até a camada de enlace, é sinal de que o processador do computador ja encaminhou a informação até o dispositivo de saida (placa de rede), e é este dispositivo que fará o processo de enlace.

Cada equipamento na rede é identificado por um número chamado de MAC ADDRESS. (Media Access Control Address). Este numero é composto por 6 bytes, e deve ser único em cada rede.

É este endereço que determina o destino físico de uma informação: Para um pacote IP destinado a um computador na mesma rede chegar efetivamente ao computador, endereço MAC de destino deste pacote deve ser o do computador com a IP de destino. Um pacote IP com destino a outra rede, deve ser encaminhado para o Mac Address do roteador que irá encaminhar o pacote. O Mac Address é determinado pelo fabricante da placa de rede, seguindo o seguinte formato: nn:nn:nn:ff:ff:ff.

nn:nn:nn é um numero aleatório, escolhido pelo fabricante. ff:ff:ff é um numero que identifica o fabricante. Para o sistema estes valores não fazem a menor importância – o importante é que não haja duas placas com mesmo mac adress na rede. É possível alterar o valor do mac address via software – no windows tem uma opção nas configurações de rede, e no linux o próprio comando ifconfig já traz esta opção.

O endereço FF:FF:FF:FF:FF:FF é especial – significa que a informação deve ser entregue a todos os computadores (endereço de BroadCast).

A camada de enlace adiciona as seguintes informações ao pacote:

<Mac Address de destino><Mac Address de Origem><Tipo de pacote (Ethertype)><dados><crc32 do pacote>

Mac Address de destino e origem é auto-explicativo.

Tipo de pacote (EtherType) serve para indicar qual protocolo foi usado nos dados (se os dados são um pacote IP, o tipo será 0×0800)

Dados são os dados a serem enviados…

e Crc32 do pacote, é um valor gerado apartir de um calculo que envolve todos os dados de todo o pacote enviado. Este valor serve para detecção de erros de transmissão.

Quando a camada de enlace recebe um pacote de dados, ela verifica se ela é a destinatária – se ela não for, o pacote é descartado.

Em seguida, ela calcula o CRC32 do pacote verifica se o valor calculado é igual ao valor do CRC32  informado pelo pacote. Se não for, o pacote é descartado.

Se o pacote não foi descartado nas duas etapas acima, os dados de enlace são removidos e o pacote é entregue ao protocolo de rede adequado, definido por ethertype.

É importante ressaltar que em 99% dos casos quem faz todo este trabalho de adicionar o cabeçalho e verificar o cabeçalho é a placa de rede do computador. Quando os dados chegam até a camada de enlace, é porque o processador já encaminhou o pacote de dados e o endereço de destino até a placa de rede.

Vamos ver como uma informação vinda da camada de rede é enviada para o endereço de enlace correto, usando como exemplo uma rede convencional (essa que se tem em casa ou nas empresas).

Para este exemplo, consideraremos as seguintes informações:

A rede é 10.1.1.0/24, a IP do roteador padrao é 10.1.1.1, e possui mac address 00:00:00:00:01.
O computador 10.1.1.2 possui mac address 00:00:00:00:00:02 e quer enviar uma informação para o computador 10.1.1.5 de mac address 00:00:00:00:00:03.

Hub é um equipamento que liga fisicamente várias placas de rede, e seu funcionamento consiste em, simplesmente, enviar para todas as suas partas de conexão o mesmo sinal – ou seja – a informação enviada por um computador chega em todos os computadores – todos estes equipamentos estão conectados em uma HUB.

Para o computador 10.1.1.2 enviar dados para 10.1.1.5, a primeira coisa a ser feita é a camada de rede detectar se o 10.1.1.5 esta na mesma rede de 10.1.1.2. Neste caso, eles estão na mesma rede.

Pare efetivar a conexão, a camada de rede precisa saber qual o destino fisico deste pacote, e para isto ela instrui a camada de enlace para que envie um pacote de dados, destinado para o endereço físico FF:FF:FF:FF:FF:FF perguntando :”Quem é a máquina com IP 10.1.1.5?”

Como esta informação foi encaminhada por broadcast, ela atingirá a camada de rede de todos os computadores da rede. Os computadores que não são possuem a IP 10.1.1.5 simplesmente ignorarão a mensagem. Já o computador que possui esta ip responderá com “Eu sou o computador 10.1.1.5 e meu Mac Address é 00:00:00:00:00:03″.

Agora que a camada de rede de 10.1.1.2 conhece o Mac Address de 10.1.1.5, ele instrui a camada de enlace para que envie as informações para o mac address 00:00:00:00:00:03 informando que a camada de rede adequada para este pacote é a IP, para isto, informa que o EtherType é do tipo 0×0800.

A camada de enlace adiciona os cabeçalhos adequados, realiza o calculo do CRC32, e encaminha a informação para a camada física, que se encarrega de transmitir, fisicamente, a informação. No momento em que a camada de enlace encaminha para a camada física, a informação “saiu” do computador e foi para a rede. Observe que, em nenhum momento, a camada de enlace se preocupou em QUAL será o meio físico, apenas em qual o destinatário físico!

Como nossas maquinas estão conectadas em uma HUB, que simplesmente replica a informação recebida em uma porta para toda as outras, todos os computadores irão receber o pacote encaminhado. O que acontece então:

A placa de rede do  roteador (ip 10.1.1.1 e Mac Address 00:00:00:00:00:01) receberá um pacote de dados destinado ao Mac Address 00:00:00:00:00:03. Como o pacote não é encaminhado à ele, o pacote será descartado.

A placa de rede do computador de ip 10.1.1.5 cujo Mac Address é 00:00:00:00:00:03, também receberá um pacote destinado ao Mac Address 00:00:00:00:00:03. Ao verificar que ele é o destinatário, a placa fará o calculo do CRC32. Caso esteja correto, repassará o pacote para a camada de rede indicada em ethertype, para que esta tome as providencias cabíveis.

Mas, e se o computador 10.1.1.2 quiser enviar um pacote de dados para a ip 200.10.10.10? Esta IP está em outro local do mundo, e, obviamente, não está na mesma rede fisica de 10.1.1.2, o que acontece? Simples:

Quando a camada de rede de 10.1.1.2 detectar que 200.10.10.10 não pertence à mesma rede, ele deve endereçar este pacote para 200.10.10.10, porém deve encaminhar o pacote, fisicamente, para o roteador padrão.

Neste caso, o computador 10.1.1.2 envia o pacote para a Mac Address do roteador 10.1.1.1 (Mac Address 00:00:00:00:00:01).

A placa de rede (camada de enlace) do roteador receberá um pacote destinado à 00:00:00:00:00:01 e encaminhará (sem as informações de enlace) para a camada de rede. Por ser um roteador, ao detectar que ele não é o destinatário do pacote, ele reencaminhará, usando o mesmo processo, para outro roteador. Observe que, como os dados de enlace valem somente para uma rede fisica. Como roteadores fazem a ligação entre redes na camada de rede, para cada rede que os dados transitam são usados cabeçalhos de enlace diferentes (resumindo: Dados de enlace não atravessam os roteadores).

Além de identificar cada equipamento na rede fisicamente, a camada de enlace pode prover outros serviços, como criptografia (usada em redes wireless), multiplexação, controle de erros, dependendo da necessidade, sendo que, geralmente, todas estas operações são “invisiveis” para as outras camadas.