código 1:
public static void main(String[] args) {
int i ;
int aux =0;
int par;
for( i = 0 ; i <= 200 ; i++ ){
if(i % 2 ==0){
par = i;
aux = par + aux;
System.out.println("Numero:" + par);
}
}
System.out.println("A soma dos numeros pares é:" + aux);
System.out.println("A média é dos numeros pares é:" + aux/101);
}
}
código 2:
public class VetorParJava {
int vetor[];
int nPar = 1;
public int[] VetorPAR(){
int i = 0;
this.vetor = new int[i];
for( i = 0 ; i <=200 ; i++){
if(i%2 ==0){
vetor[i] = i;
this.nPar ++;
}
}
return vetor;
}
public int SomaVetorPar(int vetor[]){
int total = 0;
for(int i = 0 ; i < vetor.length ; i++){
total = total + vetor[i];
}
return total;
}
}
domingo
sábado
Semáforo usando a função millis()
#define ledVm1 2//led vermelho do semaforo 1
#define ledAm1 3//led amarelo
#define ledVr1 4//led verde
#define ledVm2 5//led vermelho do semaforo 2
#define ledAm2 6//led amarelo
#define ledVr2 7//led verde
unsigned long inicio = 0;
int intervalo = 250;
int intervalo1 = 500;//tempo em milissegundos
int intervalo2 = 1000;//tempo em milissegundos
int intervalo3 = 1500;//tempo em milissegundos
int intervalo4 = 2000;//tempo em milissegundos
boolean stateV1 = false;
boolean stateA1 = false;
boolean stateVr1 = false;
boolean stateV2 = false;
boolean stateA2 = false;
boolean stateVr2 = false;
void setup()
{
pinMode(ledVm1, OUTPUT);
pinMode(ledAm1, OUTPUT);
pinMode(ledVr1, OUTPUT);
pinMode(ledVm2, OUTPUT);
pinMode(ledAm2, OUTPUT);
pinMode(ledVr2, OUTPUT);
}
void loop()
//caso o led vermelho de s1 estaja acesso vermelho de s2 apgado
{
Serial.print(inicio);
if(millis() - inicio <= intervalo1){
digitalWrite(ledVm1,HIGH);
digitalWrite(ledAm1,LOW);
digitalWrite(ledVr1,LOW);
digitalWrite(ledVm2,LOW);
digitalWrite(ledAm2,LOW);
digitalWrite(ledVr2,HIGH);
} if(millis() - inicio <= intervalo2){
digitalWrite(ledVm1,HIGH);
digitalWrite(ledAm1,LOW);
digitalWrite(ledVr1,LOW);
digitalWrite(ledVm2,LOW);
digitalWrite(ledAm2,HIGH);
digitalWrite(ledVr2,LOW);
} if(millis() - inicio <= intervalo3){
digitalWrite(ledVm1,LOW);
digitalWrite(ledAm1,LOW);
digitalWrite(ledVr1,HIGH);
digitalWrite(ledVm2,HIGH);
digitalWrite(ledAm2,LOW);
digitalWrite(ledVr2,LOW);
}if(millis() - inicio <= intervalo4){
digitalWrite(ledVm1,LOW);
digitalWrite(ledAm1,HIGH);
digitalWrite(ledVr1,LOW);
digitalWrite(ledVm2,HIGH);
digitalWrite(ledAm2,LOW);
digitalWrite(ledVr2,LOW);
}
if(millis()- inicio == 2000){
inicio = millis();
Serial.print(inicio);
}
}
Semáforo com Arduíno usando o laço for
int led_vermelho1 =2; //declaração das varaveis correspondente a cada led e setando os pinos
int led_amarelo1 =3;
int led_verde1 =4;
int led_vermelho2 =5;
int led_amarelo2 =6;
int led_verde2 =7;
void setup()
{
pinMode(led_vermelho1, OUTPUT); // setando os pinos como saída
pinMode(led_amarelo1, OUTPUT);
pinMode(led_verde1, OUTPUT);
pinMode(led_vermelho2, OUTPUT);
pinMode(led_amarelo2, OUTPUT);
pinMode(led_verde2, OUTPUT);
}
void loop()
{
for (int i=0;i<32000 color="#0000ff" font="" i="" nbsp=""> // estrutura de repetição que faz a contagem para acender os leds
if (i<4000 color="#0000ff" font="" nbsp=""> // condição que pega o intervalo entre zero e 4000
digitalWrite(led_vermelho2,LOW); //apaga led vermelho2
digitalWrite(led_amarelo1,LOW); //apaga led amarelo1
digitalWrite(led_vermelho1,HIGH); // acende lede vermelho1
digitalWrite(led_verde2,HIGH); // acende led verde2
}
if (i==4000 && i<8000 color="#0000ff" font="" nbsp="">//condição que trabalho com o intervalo entre 4000 e 8000
digitalWrite(led_vermelho1,HIGH); // acende o led vermelho1
digitalWrite(led_amarelo2,HIGH); // acende o led amarelo2
digitalWrite(led_verde2,LOW); // apaga o led verde2
}
If (i==8000 && i<16000 color="#0000ff" font=""> // condição que trabalha no intervalo entre 8000 e 16000
digitalWrite(led_vermelho1,LOW); // no intervalo acima apaga o led vermelho1
digitalWrite(led_amarelo2,LOW); // no intervalo acima apaga o led amarelo2
digitalWrite(led_verde1,HIGH); // acende o led verde1
digitalWrite(led_vermelho2,HIGH); // acende o led vermelho2
}
if (i==16000 && i<=32000){ // quando chegar no interval entre 16000 e 32000 faça:
digitalWrite(led_amarelo1,HIGH); //acende o led amarelo1
digitalWrite(led_verde1,LOW); // apaga o led verde1
digitalWrite(led_vermelho1,LOW); // apaga o led vermelho1
digitalWrite(led_vermelho2,HIGH); //acende o led vermelho2
digitalWrite(led_verde2,LOW); //apaga o led verde2
digitalWrite(led_amarelo2,LOW); //apaga o led amarelo2
} // fim do ultimo if
} // fim do for
} //fim da função
Conjunto de instruções 8051
Símbolos utilizados:
·
C: Flag de carry;
·
A: Acumulador;
·
PC: Contador de Programa;
·
DPTR: Ponteiro;
·
N: Endereço de 8 bits;
·
NN: Endereço de 16 bits;
·
#N: Constante de 8 bits;
·
Rn:
Registrador Rn (R0~R7) do banco atual de registradores;
·
@Ri:
Endereço é determinado pelo registrador Ri (R0 ou R1);
·
H:
indica que o valor está na base hexadecimal;
·
B:
indica que o valor está na base binária;
Instruções de movimentação de dados
De modo geral, quando o destino é o acumulador:
MOV
|
A,Rn
|
Move o registro Rn para
o Acumulador
|
MOV
|
A,N
|
Move o conteúdo da memória N para
o Acumulador
|
MOV
|
A,@Ri
|
Move o conteúdo da RAM endereçada
por Ri para o Acumulador
|
MOV
|
A,#N
|
Move a constante N para
o Acumulador
|
MOVC
|
A,@A+DPTR
|
Soma A + DPTR obtendo um endereço
de 16 bits na memória de programa. Carrega o acumulador
com o
conteúdo desta memória |
MOVC
|
A,@A+PC
|
Idem ao anterior, mas soma A + PC
|
MOVX
|
A,@Ri
|
Move o conteúdo da RAM endereçada
por Ri para o Acumulador
|
MOVX
|
A,@DPTR
|
Move RAM externa endereçada por
DPTR (endereço 16 bits) para o Acumulador
|
XCH
|
A,Rn
|
Troca entre si o conteúdo
do Acumulador e do Registro Rn
|
XCH
|
A,N
|
Troca entre si o conteúdo
da memória N com Acumulador
|
XCH
|
A,@Ri
|
Troca entre si a
RAM endereçada por Ri com Acumulador
|
XCHD
|
A,@Ri
|
Troca entre si o nibble
menos significativo do Acumulador e da RAM endereçada por Ri
|
·
Quando o destino é um registrador:
MOV
|
Rn,A
|
Move o Acumulador para o registro
Rn
|
MOV
|
Rn,N
|
Move o conteúdo da memória N para
o registro Rn
|
MOV
|
Rn,#N
|
Move a constante N para
o registro Rn
|
MOV
|
DPTR,#NN
|
Move constante NN para o DPTR
|
·
Quando o destino é um endereço direto:
MOV
|
N,A
|
Move o Acumulador para a memória
N
|
MOV
|
N,Rn
|
Move o registro Rn para a memória
N
|
MOV
|
N1,N2
|
Move o conteúdo da memória N2
para a memória N1
|
MOV
|
N,@Ri
|
Move RAM endereçada por Ri para a
memória N
|
MOV
|
N,#N
|
Move a constante N para
o conteúdo da memória N
|
PUSH
|
N
|
Incrementa o SP e então coloca a
memória no Stack
|
POP
|
N
|
Retira dado do Stack e coloca na
memória, depois decrementa SP
|
·
Quando
o destino é um endereço indireto:
MOV
|
@Ri,A
|
Move o Acumulador para a RAM
endereçada por Ri
|
MOV
|
@Ri,N
|
Move o conteúdo da memória N para
a RAM endereçada
por Ri |
MOV
|
@Ri,#N
|
Move a constante N para a RAM endereçada
por Ri
|
MOVX
|
@DPTR,A
|
Move Acumulador para a RAM
externa endereçada por
DPTR (endereço 16 bits) |
Instruções aritméticas
Quando o destino é o acumulador:
ADD
|
A,Rn
|
Soma
Rn ao Acumulador
|
ADD
|
A,N
|
Soma o conteúdo da posição de
memória N ao Acumulador
|
ADD
|
A,@Ri
|
Soma o conteúdo da RAM endereçada
por Ri ao Acumulador
|
ADD
|
A,#N
|
Soma a constante N ao Acumulador
|
ADDC
|
A,Rn
|
Soma Rn e o flag Carrry
ao Acumulador
|
ADDC
|
A,N
|
Soma o conteúdo da posição de
memória N e o flag Carry ao Acumulador
|
ADDC
|
A,@Ri
|
Soma o conteúdo da RAM endereçada
por Ri e o flag Carry ao Acumulador
|
ADDC
|
A,#N
|
Soma a constante N e flag Carry
ao Acumulador
|
SUBB
|
A,Rn
|
Subtrai Rn e o flag Carry
do Acumulador
|
SUBB
|
A,N
|
Subtrai o conteúdo da posição de
memória N e o flag Carry do Acumulador
|
SUBB
|
A,@Ri
|
Subtrai o conteúdo da
RAM endereçada por Ri e o flag Carry do Acumulador
|
SUBB
|
A,#N
|
Subtrai a constante N e o
flag Carry do Acumulador
|
INC
|
A
|
Soma
1 ao Acumulador
|
DEC
|
A
|
Subtrai
1 do Acumulador
|
DA
|
A
|
Ajuste
decimal do Acumulador
|
DIV
|
AB
|
Divide A e B, resultado: A inteiro e B
resto
|
MUL
|
AB
|
Multiplica A e B, resultado: BA
|
Cabe
ressaltar que nas operações de adição, subtração e incremento o flag de carry e
de overflow são alterados. As operações de multiplicação e divisão zeram o
flag de carry, e no caso da multiplicação, a flag de overflow é modificada.
Além disso, a instrução de ajuste decimal também modifica a flag de carry.
Quando o destino é um registrador:
INC
|
Rn
|
Soma
1 ao Rn
|
DEC
|
Rn
|
Subtrai
1 de Rn
|
Instruções
Lógicas
Quando o destino é o acumulador:
ANL
|
A, Rn
|
Operação “E” entre Rn e Acumulador
|
ANL
|
A,N
|
Operação “E” entre o conteúdo da memória N e o
Acumulador
|
ANL
|
A,@Ri
|
Operação “E” entre RAM endereçada por Ri e
Acumulador
|
ANL
|
A,#N
|
Operação “E” entre a constante N e Acumulador
|
ORL
|
A,Rn
|
Operação “OU” entre Rn e Acumulador
|
ORL
|
A,N
|
Operação “OU” entre memória N e Acumulador
|
ORL
|
A,@Ri
|
Operação “OU” entre RAM endereçada por Ri e
Acumulador
|
ORL
|
A,#N
|
Operação “OU” entre constante N e Acumulador
|
XRL
|
A,Rn
|
Operação “OU EXCLUSIVO” entre Rn e Acumulador
|
XRL
|
A,N
|
Operação “OU EXCLUSIVO” entre o conteúdo da memória
N e Acumulador
|
XRL
|
A,@Ri
|
Operação “OU EXCLUSIVO” entre RAM endereçada por Ri
e Acumulador
|
XRL
|
A,#N
|
Operação “OU EXCLUSIVO” entre constante N e Acumulador
|
Quando o destino é um endereço direto:
ANL
|
N,A
|
Operação “E” entre Acumulador e memória N
|
ANL
|
N,#N
|
Operação “E” entre constante N e memória N
|
ORL
|
N,A
|
Operação “OU” entre Acumulador e conteúdo da memória
N
|
ORL
|
N,#N
|
Operação “OU” entre constante N e conteúdo da
memória N
|
XRL
|
N,A
|
Operação “OU EXCLUSIVO” entre Acumulador e conteúdo
da memória N
|
XRL
|
N,#N
|
Operação “OU EXCLUSIVO” entre a constante N e o
conteúdo da memória N
|
Operação sobre o
acumulador:
RL
|
A
|
Faz A
= 0
|
CPL
|
A
|
Inverte o estado dos bits do Acumulador
|
SWAP
|
A
|
Troca os nibbles do Acumulador
|
RL
|
A
|
Rotação do Acumulador para esquerda
|
RLC
|
A
|
Rotação do Acumulador para esquerda através do flag
Carry
|
RR
|
A
|
Rotação do Acumulador para direita
|
RRC
|
A
|
Rotação do Acumulador para direita através do flag
Carry
|
Instruções Booleanas e de Desvio
Operações utilizando o endereçamento de
bits:
LR
|
bit
|
Zera
o bit endereçado
|
SETB
|
bit
|
Seta
o bit endereçado
|
CPL
|
bit
|
Inverte o estado do bit endereçado
|
MOV
|
bit,C
|
Move o flag Carry para o bit endereçado
|
JB
|
bit,N
|
Desvia se o bit endereçado estiver setado
|
JNB
|
bit,N
|
Desvia se o bit endereçado estiver zerado
|
JBC
|
bit,N
|
Desvia se o bit endereçado estiver setado e depois
zera o bit
|
Operações sobre o flag de Carry:
CLR
|
C
|
Zera
o flag Carry
|
SETB
|
C
|
Seta
o flag Carry
|
CPL
|
C
|
Inverte o estado do flag Carry
|
MOV
|
C,bit
|
Move o bit endereçado para o flag
Carry
|
ANL
|
C,bit
|
Operação “E” entre o
bit endereçado e o flag Carry
|
ANL
|
C,/bit
|
Operação “E” entre o complemento
do bit endereçado e o flag Carry
|
ORL
|
C,bit
|
Operação “OU” entre o
bit endereçado e o flag Carry
|
ORL
|
C,/bit
|
Operação “OU” entre o complemento
do bit endereçado e o flag Carry
|
JC
|
N
|
Desvia se o flag Carry
estiver setado
|
JNC
|
N
|
Desvia se o flag Carry
estiver zerado
|
Instruções
de Salto
Instruções
de salto incondicional são bastante simples. Basicamente, um endereço alvo é
utilizado para alterar o fluxo de execução, isto é, o contador de programa. Na
figura são mostradas as instruções capazes de alterar o fluxo de execução do
programa, com exceção da instrução NOP, que não realiza nenhuma operação.
As instruções JMP e CALL possuem as
seguintes variações:
ACALL
|
N
|
Chama sub-rotina
numa faixa de 2 Kbytes da atual posição
|
LCALL
|
NN
|
Chama sub-rotina
em qualquer posição da memória de programa
|
AJMP
|
N
|
Desvia para outro
endereço numa faixa de 2 Kbytes da atual posição.
|
LJMP
|
NN
|
Desvia para qualquer
posição da memória
|
SJMP
|
N
|
Desvio curto relativo
|
Outras
duas instruções que alteram o valor do contador de programa são as de retorno
de sub-rotina e retorno de interrupção.
RET
|
Retorna da sub-rotina
|
|
RETI
|
Retorna da interrupção
|
O
desvio também pode ser tomado com base no resultado de uma comparação. Nesse
caso, o desvio é dito condicional.
CJNE
|
A,N,N
|
Compara e desvia se o Acumulador for diferente do
conteúdo da memória N
|
CJNE
|
A,#N,N
|
Compara e desvia se o Acumulador for diferente da
constante N
|
CJNE
|
Rn,#N,N
|
Compara e desvia se o Rn for diferente da constante
N
|
CJNE
|
@Ri,#N,N
|
Compara e desvia se a RAM endereçada por Ri for
diferente da constante N
|
DJNZ
|
N,N
|
Decrementa o conteúdo da memória N e desvia se for
diferente de “zero”
|
DJNZ
|
Rn, N
|
Decrementa Rn e desvia se for diferente de “zero”
|
JZ
|
N
|
Desvia se o Acumulador for “zero”
|
JNZ
|
N
|
Desvia se o Acumulador “não for zero”
|
Cabe ressaltar que as instruções CJNE
modificam a flag de carry.
Assinar:
Postagens (Atom)