Bit é a sigla para Binary Digit, que em português significa digito binário, ou seja, é a menor unidade de informação que pode ser armazenada ou transmitida. É geralmente usada na computação, teoria da informação e processamentos de dados. Um bit pode assumir somente dois estados (valores) o 0 ou 1.
Quando eu (Jacobson) particularmente me refiro a computadores, estou me referindo à qualquer sistema que contenha um "cérebro com uma memória digital" exemplo. processador ou microcontrolador. Os dois são idealizados para armazenar instruções em múltiplos de bits que são denominados bytes. No início, byte tinha tamanho variável, mas atualmente tem oito bits, os quais são chamados de octetos. Existem também alguns termos para referir-se a multiplos de bits, como Kilobit, Megabit Kb, Mb, e Gb.
Fisicamente, o valor de um bit é armazenado como uma carga elétrica acima ou abaixo de um nível padrão em um único capacitor dentro de um dispositivo de memória. Mas, bits podem ser representados fisicamente por vários meios, como pela eletricidade, fibras ópticas, rede wireless etc.
Um byte é um dos tipos de dados integrais em computação, é usado para especificar o tamanho ou quantidade da memória ou da capacidade de armazenamento de um dispositivo, independentemente do tipo de dados armazenados. A codificação padronizada de byte foi definida como sendo de 8 bits. O byte de 8 bits é mais comumente chamado de octeto no contexto de redes de computadores e telecomunicações.
A importância de bits e bytes se deve ao fato de tudo na informática ser medido através de bits e bytes.
11001011 01000110
SISTEMAS DE NUMERAÇÃO
Conjunto de dígitos (símbolos) separados e distintos que
podem ser combinados e assim representar infinitas
quantidades.
Em geral são sistemas posicionais, ou seja, o valor de cada
dígito depende da posição que ele ocupa no número.
Sistema Decimal
É composto de dez dígitos: 0, 1, 2, ...., 8, 9 (Base 10)
5986,32 = 5x103+9x102+8x101+6x100+3x10-1+2x10- 2
Sistema Binário
É composto de dois dígitos: 0 e 1 (Base 2)
(1011,01)2=1x23 + 0x22 + 1x21 + 1x20 + 0x2-1 +1x2- 2= (11,25)10
Sistema Octal
É composto de oito dígitos: 0, 1, 2, ..., 6, 7 (Base 8)
(1775,3)8 = 1x83 + 7x82 + 7x81 + 5x80 + 3x8-1= (1021,375)10
Sistema Hexadecimal
Composto de dezesseis dígitos: 0,1,..,9, A, B,...,E, F(Base 16)
(9FA)16 = 9x162 + 15x161 + 10x160 = (2554)10
3
Conversão de Decimal para outras Bases
Dividir a parte inteira do no. a ser convertido pelo no. de base
(2, 8 ou 16), até o último quociente inteiro, que será o bit mais
significativo do no. já convertido. Os bits seguintes serão os
restos obtidos nas divisões, obedecendo a seqüência: do
último ao primeiro resto.
Multiplicar parte fracionária pelo no. de base, extrair do
produto a parte inteira, que é o bit mais significativo, e
multiplicar o restante novamente pelo no. de base. Repetir
esta operação até que se obtenha zero (e o resultado é
exato) ou até que se chegue a uma repetição (que é uma
dízima) ou ainda a resultados não exatos (nem zero, nem
dízima).
Exemplos:
Base 10 para Base 2: (67,625)10 = (?)2
Parte inteira
67 2 (67)10 = (1000011)2
67 / 2
1 33 / 2
1 16 / 2
0 8 / 2
0 4 / 2
0 2 / 2
0 1
Parte Fracionária
0,625 0,250 0,500 (0,625)10=(0,101)2
x2 x2 x2
1,250 0,500 1,000 (67,625)10=(1000011,101)2
4
Base 10 para Base 8: (92,635)10 = (?)8
Parte inteira
92 8
4 11 8
3 1
Parte Fracionária
0,635 0,08 0,64 0,12 0,96 0,68 0,44 0,52
x8 x8 x8 x8 x8 x8 x8 x8
5,080 0,64 5,12 0,96 7,68 5,44 3,52 4,16
(92,635)10 = (134,50507534...)8
Base 10 para Base16: (1000,635)10 = (?)16
Parte Inteira
1000 /16 mas (14)10 = (E)16
8 62/16
14 3
Parte Fracionária
0,635 0,16 0,56 0,96 0,36 0,76 0,16
x16 x16 x16 x16 x16 x16 x16
10,160 2,56 8,96 15,36 5,76 12,16 2,56 repet.
(1000,635)10 = (3E8,A28F5C28F5C..)16
CONVERSÃO PARA BASE BINÁRIA
Toda a informação relevante você encontra neste arquivo em PDF. Estude-o!
24LC512
Em produção
A Microchip Technology Inc. 24LC512 é uma PROM serialmente eletratável serial (EEPROM) de 512Kb (64K x 8),
capaz de funcionar em uma ampla faixa de tensão (2.5V a 5.5V). Ele foi desenvolvido para aplicações avançadas de baixa
potência, como comunicações pessoais e aquisição de dados. Este dispositivo também possui capacidade de gravação de
página de até 128 bytes de dados. Este dispositivo é capaz de lições aleatórias e seqüenciais até o limite de 512K. As
linhas de endereço funcional permitem até oito dispositivos no mesmo barramento, para um espaço de endereço de até 4
Mbit. Este dispositivo está disponível nos pacotes DIP, SOIJ e DFN padrão de 8 pinos.
Datasheet 24LC512
Sou um parágrafo. Clique aqui para adicionar e editar seu próprio texto. É fácil.
PARA VOCÊ ESTUDANTE DE PROGRAMAÇÃO
DIRETIVA DE COMPILAÇÃO PARA O COMPILADOR CCS
Diretiva #byte:
#byte tris = 0x86 - É uma diretiva para criação de variável, atribuindo a variável um endereço de
memória. Pode-se criar um nome e atribui o endereço de um registrador do PIC, utilizando este nome no programa
indicando o registrador endereçado.
Diretiva #bit:
#bit rb4 - 0x06.4 - É uma diretiva para criação de uma variável, atribuindo a variável um endereço de um bit
específico onde se encontra o registrador indicado. É utilizado quando se quer monitoras o bit do registrador
indicado.
Diretiva #define:
#define acende output_high - É uma diretiva para criação de constante atribuindo um valor ou um comando.
Essa diretiva é para chamar um comando usando apenas um nome, ou atribuir um valor fixo a uma constante.
#define TRISB (int*) 0x86 - Essa diretiva cria uma variável de ponteiro de nome TIRSB , declara que é um dado do tipo
inteiro e atribui um endereço 0x86 ou aponta para um endereço. Na função ele deve ser chamado da seguinte forma:
*TRISB - É obrigatório o uso do asterisco (ponteiro) antes do nome, é este asterisco que vai apontar para o
endereço especificado na diretiva
A diretiva define, É uma das mas importantes, porque ele pode criar uma constante. Ex: #define numero 255. Ela
pode ser usada no lugar de um comando Ex: #define liga oputput_h.igh Ou como vimos acima como ponteiro Ex:
#define TRISB (int*)0x86.
Diretiva #device:
#device ADC = 10 - Essa diretiva ativa o conversor AD. Ela diz ao compilador para usar uma conversão de 10 bit.
Um número vai depender do PIC utilizado.
EXEMPLO DE CÓDIGO – 2 SEG. COM TIMER 0
#byte intcon = 0x0B // end. do intcon que contém a flag de estouro do tmr0.
#bit T0IF = intcon.2 // flag de estouro do timer 0 (T0IF = bit2).
void main(){
int cont = 31; // variável que armazena a quantidade de estouros do timer.
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256);
/*configurando o timer para trabalhar
como temporizador e prescaler em 256.*/
set_timer0(0); // valor inicial para contagem do timer, neste caso zero.
while(true) {
if(T0IF){ // se t0if for igual a 1, ou seja, se houve um estouro de timer...
T0IF = 0; // zera a flag do bit t0if para poder sinalizar um novo estouro.
cont--; // decrementa a variável cont, que tinha o valor inicial de 31.
if(cont==0) { // verifica se o valor da variável cont já chegou em zero.
output_toggle(pin_b0); // caso sim, inverte o nível do pino rb0.
cont = 31; // 31 em cont para que ela possa retornar.
}
}
}
} ******Fim do prigrama*******
DEDUÇÃO DA RESOLUÇÃO DO TIMER 0
de acordo com om registrador do 16F628A em seu Datasheet
R = 1/(4000000/4)*(256 -0)*255 = 0,065s ou 65ms.
*************************************************
ESTOURO DO TIMER 0 ATRAVÉS DA EQUAÇÃO
Tet= R*n
para 2 SEG.
onde:
Tet= tempo de estouro do timer (desejado)
R = resolução (tempo de estouro calculado com fórmula anterior).
n = número de repetições de estouros para que atinja o valor desejado no timer com prescaler de 255
Tet= R*n
2= 0,065*n
n = 2/0,065
n = 30,8.
Ou seja, 31 estouro ou transbordamento para temporização de 2 seg.
Clique na imagem para baixar o Programmer Pic Kit3 stand Alone
CRISTAL OSCILADOR DE QUARTZO E RESSONADOR
Come é a execução de um programa em "C" ?
COMPILADOR MICRO C PRO FOR PIC
// Botão de retenção
// COMPILADOR: Micro C Pro for PIC MICROCHIP
// MCU: PIC16F84A => CLOCK 4MH
// DATA: 30/12/2017
// AUTOR: JACOBSON DA G. FERREIRA
#define S1 RB0_bit // mapeamento
#define LED RB1_bit // mapeamento
short int estado = 0; // variável de controle global
void main()
{
TRISB = 0x01; // Registrador TRIS RB1 saída e RB0 entrada
PORTB = 0x01; // Registrador PORT pinoRB1 low e RB0 high
OPTION_REG.f7 = 0; // Registrador OPTINREG
while(1)
{
if( (!S1) && !estado)
{
delay_ms(30);
LED = ~LED;
estado = 1;
}
if( (S1) && estado)
{
delay_ms(30);
estado = 0;
}
}
}
*********************************************************
COMPILADOR ARDUINO
// BOTÃO DE RETENÇÃO
// DATA DE CRIAÇÃO: 10/12/2017
// MODIFICADO POR: JACOBSON DA G.FERREIRA
#define botao 8
#define led 2
boolean estado = 0;
void setup()
{
pinMode(13, 0x01);
pinMode(botao,INPUT_PULLUP);
pinMode(led, OUTPUT);
digitalWrite(led, LOW);
}
void loop()
{
if( !digitalRead(botao) && !estado )
{
digitalWrite(led,!digitalRead(led));
delay(50);
estado = 1;
}
if(digitalRead(botao) && estado )
{
delay(50);
estado = 0;
}
}
###################################################
COMPILADOR CCS
// Botão de retenção
// COMPILADOR: PIC C COMPILER (CCS)
// MCU: PIC16F84A => CLOCK 4MHz
// DATA: 30/12/2017
// AUTOR: JACOBSON DA G. FERREIRA
#include <16f84a.h>
#user delay(clock = 40000)
#fuses XT, NOWDT, NOMCLR, NOPROTECT, NOLVP, PUT
#use fast_oi (b)
short int estado = 0; // variável global
void nivel(); // prtótipo de função
// Não foi utilizado mapeamento de hardware porem poderá usa-lo
void main ()
{
set_tris_b(0x01); // pino RB0 entrada do botão
output_b (0x00);// inicialização em zero
output_b_pullup; // Habilita resistores internos
nivel();
}
while(TRUE)
{
void nivel() // chamada da função
{
if ( !input( pin_b0 ) && !estado ) //testa botão
{
delay_ms( 50 );
output_toggle( pin_b7 ); //inverte estado do pino RB7
estado = 1; //a variável passa a ser 1 agora
}
if ( input( pin_b0 ) && estado == 1 ) //testa botão
{
delay_ms( 50 );
estado = 0; // a variável retorna à zero
}
}
}
***********************************************************
// DATA:08/01/2018
// Wagner Rambo Modificado por Jacobson
// Softwarer: Micro C pro for Pic
// Ocupação de memória RAM 4% ROM 15%
#define S2 RA0_bit
#define S1 RA1_bit
#define LED2 RA2_bit
#define LED1 RA3_bit
#define buzzer RB7_bit
unsigned char control = 0x01, out0, out1, out2, out3;
int cont;
void Beep(void);
void main()
{
char i = 0x00;
CMCON = 0x07;
TRISA = 0X03;
TRISB = 0X00;
PORTA = 0x00;
PORTB = 0x00;
Beep();
while(1)
{
if (S1 == 0x00 && control == 0x01)
{
LED2 = ~LED2;
delay_ms(500);
}
else if (S2 == 0x00 && control == 0x01)
{
out0 = LED2;
control = 0x02;
Beep();
delay_ms(500);
Beep();
}
if (S1 == 0x00 && control == 0x02)
{
LED1 = ~LED1;
delay_ms(500);
}
else if (S2 == 0x00 && control == 0x02)
{
out1 = LED1;
control = 0x03;
Beep();
delay_ms(500);
Beep();
}
if (S1 == 0x00 && control == 0x03)
{
LED2 = ~LED2;
delay_ms(500);
}
else if (S2 == 0x00 && control == 0x03)
{
out2 = LED2;
control = 0x04;
Beep();
delay_ms(500);
Beep();
}
if (S1 == 0x00 && control == 0x04)
{
LED1 = ~LED1;
delay_ms(500);
}
else if (S2 == 0x00 && control == 0x04)
{
out3 = LED1;
control = 0x05;
Beep();
delay_ms(500);
Beep();
}
if(control == 0x05)
{
//nota_DO();
for(i = 0; i < 4; i++)
{
LED1 = 0x01;
LED2 = 0x01;
Beep();
delay_ms(100);
LED1 = 0x00;
LED2 = 0X00;
Beep();
delay_ms(100);
}
control = 0x01;
RB0_bit = out0;
RB1_bit = out1;
RB2_bit = out2;
RB3_bit = out3;
}
}
}
void Beep()
{
for(cont = 0; cont < 80; cont++)
{
RB4_bit = 1;
delay_ms(1);
RB4_bit = 0;
delay_ms(1);
}
}
Circuito montado em protoboard do código acima com sua fonte de cinco volts
millis()
Realmente a compreensão do funcionamento da função Millis()
é a princípio meio confusa, mas eu preparei um GIF que ajuda muito a compreender o tratamento desta função
