Klawiatura 3 przyciski Murawa:

#include <REG51.H>

//1111 1110

//1111 1101

//1111 1011

//1111 0111

unsigned char code Tab[4] = {0xFE,0xFD,0xFB,0xF7};

unsigned char data Ind;

unsigned char bdata Key;

unsigned char data KOD;

sbit K4 = Key^4;

sbit K5 = Key^5;

sbit K6 = Key^6;

void ISR_T0 (void) interrupt 1 {

P1 = Tab[Ind];

Key = P1;

if ((K4 & K5 & K6) == 0)

{

KOD = Key;

}

Ind++;

if(Ind == 4) {Ind=0;}

}

void Init(void){

KOD = 0;

Key = 0;

Ind = 0;

TMOD = 0x02;

TL0 = 0xFF;

TH0 = 0xFF;

ET0 = 1;

EA = 1;

TR0 = 1;

}

void main (void) {

Init();

while (1) {

if (KOD == 0xBE) { P0 = 0xFB; KOD = 0; }

if (KOD == 0xEE) { P0 = 0xFD; KOD = 0; }

}

}

******************************************
Wyświetlacz Kazia 1 ekran

#include <REGX52.H>

#define Wys P1

#define _A 0xFE //1111 1110

#define _B 0xFD //1111 1101

#define _C 0xFB //1111 1011

#define _D 0XF7 //1111 0111

#define _E 0xEF //1110 1111

#define _F 0xDF //1101 1111

#define _G 0xBF //1011 1111

#define _H 0x7F //0111 1111

char code tab[10]= {

_A&_B&_C&_D&_E&_F, //0

_B&_C, //1

_A&_B&_D&_E&_G, //2

_A&_B&_C&_D&_G, //3

_B&_C&_F&_G, //4

_A&_C&_D&_F&_G, //5

_A&_C&_D&_E&_F&_G, //6

_A&_B&_C, //7

_A&_B&_C&_D&_E&_F&_G, //8

_A&_B&_C&_D&_F&_G //9

};

void opoznienie(unsigned int czas){

unsigned int i;

while(czas>=1){

for(i=0; i<8000; i++);

czas--;

}

}

void main(){

char licz;

while(1)

{

Wys=tab[licz];

opoznienie(15);

licz++;

if(licz>9) licz=0;

}

}

******************************************
Przesyłanie z uC na drugi i wyświetlanie

#include <REGX52.H>

#define Wys P1

#define _A 0xFE //1111 1110

#define _B 0xFD //1111 1101

#define _C 0xFB //1111 1011

#define _D 0XF7 //1111 0111

#define _E 0xEF //1110 1111

#define _F 0xDF //1101 1111

#define _G 0xBF //1011 1111

#define _H 0x7F //0111 1111

char code tab[10]= {

_A&_B&_C&_D&_E&_F, //0

_B&_C, //1

_A&_B&_D&_E&_G, //2

_A&_B&_C&_D&_G, //3

_B&_C&_F&_G, //4

_A&_C&_D&_F&_G, //5

_A&_C&_D&_E&_F&_G, //6

_A&_B&_C, //7

_A&_B&_C&_D&_E&_F&_G, //8

_A&_B&_C&_D&_F&_G //9

};

void opoznienie(unsigned int czas){

unsigned int i;

while(czas>=1){

for(i=0; i<8000; i++);

czas--;

}

}

void main(){

char licz;

while(1)

{

Wys=tab[licz];

opoznienie(15);

SBUF=tab[licz];

REN=1;

Wys=SBUF;

opoznienie(15);

licz++;

if(licz>9)licz=0;

}

}

#include <REGX52.H>

#define Wys P1

#define _A 0xFE //1111 1110

#define _B 0xFD //1111 1101

#define _C 0xFB //1111 1011

#define _D 0XF7 //1111 0111

#define _E 0xEF //1110 1111

#define _F 0xDF //1101 1111

#define _G 0xBF //1011 1111

#define _H 0x7F //0111 1111

char code tab[10]= {

_A&_B&_C&_D&_E&_F, //0

_B&_C, //1

_A&_B&_D&_E&_G, //2

_A&_B&_C&_D&_G, //3

_B&_C&_F&_G, //4

_A&_C&_D&_F&_G, //5

_A&_C&_D&_E&_F&_G, //6

_A&_B&_C, //7

_A&_B&_C&_D&_E&_F&_G, //8

_A&_B&_C&_D&_F&_G //9

};

void main(){

while(1){

if(RI==1){

RI=0;

REN=1;

Wys=SBUF;

}}}

******************************************

Wys. Kazia 2 elementowy

#include <REGX52.H>

#define _A 0xFE

#define _B 0xFD

#define _C 0xFB

#define _D 0xF7

#define _E 0xEF

#define _F 0xDF

#define _G 0xBF

#define _H 0x7F

void czekaj(char z){

char i,x;

for(i=0;i<z;i++){

for(x=0;x<60;x++){;}

}

}

void main(){

char code cyfry[10]={

_A&_B&_C&_D&_E&_F, //0

_B&_C, //1

_A&_B&_G&_E&_D, //2

_A&_B&_C&_G&_D, //3

_F&_B&_G&_C, //4

_A&_F&_G&_C&_D, //5

_A&_F&_G&_E&_D&_C, //6

_A&_B&_C, //7

_A&_B&_C&_D&_E&_F&_G, //8

_A&_B&_C&_D&_F&_G //9

};

unsigned int i=0, j=0, k=0;

P2=0x01; //2 - dziala lewy wyswietlacz, 1 - dziala prawy wyswietlacz

for(;;){

for(k=0;k<10;k++){

P2=0x01;

P1=cyfry[i];

czekaj(100);

P2=0x00;

P2=0x02;

P1=cyfry[j];

czekaj(100);

P2=0x00;

}

i++;

if(i>9){

i=0;

j++;

}

if(j>9) j=0;

}

}

Klawiatura przy połączeniu szeregowym

unsigned char code Znaki[16]= {0x3F,0x06,0x5B,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x49,0x76,0x40,0x70,0x48,0x5C};//{0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};

unsigned char code Tab[4] = {0xFE,0xFD,0xFB,0xF7};

unsigned char data licznik;

unsigned char bdata Klucz;

unsigned char bdata ostatni=0x00;

sbit K1 = Klucz^4;

sbit K2 = Klucz^5;

sbit K3 = Klucz^6;

sbit K4 = Klucz^7;

void interr (void) interrupt 1

{

Klucz = P0;

if (((K1 & K2 & K3 & K4) == 0) && ostatni!=Klucz){

//dla FE

if(Klucz==0xEE){P2=Znaki[7]; SBUF=Znaki[7];}

if(Klucz==0xDE){P2=Znaki[8]; SBUF=Znaki[8];}

if(Klucz==0xBE){P2=Znaki[9];SBUF=Znaki[9];}

if(Klucz==0x7E){P2=Znaki[10];SBUF=Znaki[10];}

//dla FD

if(Klucz==0xED){P2=Znaki[4];SBUF=Znaki[4];}

if(Klucz==0xDD){P2=Znaki[5];SBUF=Znaki[5];}

if(Klucz==0xBD){P2=Znaki[6];SBUF=Znaki[6];}

if(Klucz==0x7D){P2=Znaki[11];SBUF=Znaki[11];}

//dla FB

if(Klucz==0xEB){P2=Znaki[1];SBUF=Znaki[1];}

if(Klucz==0xDB){P2=Znaki[2];SBUF=Znaki[2];}

if(Klucz==0xBB){P2=Znaki[3];SBUF=Znaki[3];}

if(Klucz==0x7B){P2=Znaki[12];SBUF=Znaki[12];}

//dla F7

if(Klucz==0xE7){P2=Znaki[15];SBUF=Znaki[15];}

if(Klucz==0xD7){P2=Znaki[0];SBUF=Znaki[0];}

if(Klucz==0xB7){P2=Znaki[14];SBUF=Znaki[14];}

if(Klucz==0x77){P2=Znaki[13];SBUF=Znaki[13];}

ostatni=Klucz;

}

else

{

P0 = Tab[licznik];

licznik=(licznik+1)%4;

}

}

void Init(void){

SCON = 0x50; // Ustaw rejestr kontroli portu szeregowego

// Tryb 1: 8-bit uart, zmienna predkosc transmisji

// REN = 0: odbiornik wylaczony

//PCON &= 0x7F; // SMOD = 0: predkosc transmisji x 1

PCON |= 0x80; // SMOD = 1: predkosc transmisji x 2

TMOD &= 0xCF; // 8 bit Timer1 z automatycznym przeladowywaniem

// wyzeruj bity M1 i M0

TMOD |= 0x20; // ustaw bit M1

TH1 = 0xFF; // ustaw wartosc poczatkowa rejestru TH1

TL1 = 0xFF; // ustaw wartosc poczatkowa rejestru TL1

// predkosc 12800 dla czestotliwoasci 2.4576 MHz

TR1 = 1; // start timer 1

TI = 1; // ustaw flage TI gotowosci do nadawania

licznik = 0; // inicjuj wartosc zmiennej

Klucz = 0; // inicjuj wartosc zmiennej

TMOD &= 0xF2; // 0010 1111 - M1 = 0, Gate = 0

TMOD |= 0x02; // 0010 0000 - M0 = 1 ustawiam tryb 1 licznika T0)

// C/T = 0 aktywnosc na impulsy zegarowe)

TH0 = 0x00; // ustalenie poczatkowej wartosi licznika Timer 1

TL0 = 0x00; // Timer 16 bitowy

TCON |= 0x10; // 0001 0000 - ustawienie bitu TR0 na 1

// wlaczenie Timera 0

IE |= 0x02; // 0000 1000 (ustawienie bitu ET1 na 1)

EA = 1;

}

void main (void){

Init();

while (1) {;}

}

Liczby od 0 do 99

unsigned char code Kod[10]={0x3F,0x06,0x5B,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};

unsigned char licznik;

unsigned char xdata D _at_ 0xFEFF;

unsigned char xdata J _at_ 0xFDFF;

void interr(void) interrupt 0{

licznik++;

if(licznik==100)

licznik=0;

}

void Init(void){

licznik=0;

J=0;

D=0;

IT0 = 1;

EX0 = 1;

EA = 1;

}

void main(void){

Init();

while(1){

J=Kod[licznik%10];

D=Kod[licznik/10];

}

} 

unsigned char code tab[4] = {0xFE,0xFD,0xFB,0xF7};

unsigned char data ind;

unsigned char bdata kolumna;

unsigned char data cyferka;

sbit K4 = kolumna^4;

sbit K5 = kolumna^5;

sbit K6 = kolumna^6;

sbit K7 = kolumna^7;

unsigned char naWyswietlacz(unsigned char cyferka)

{

if(cyferka == 0xEE) return 0x07;

else if(cyferka == 0xED) return 0x66;

else if(cyferka == 0xEB) return 0x06;

else if(cyferka == 0xE7) return 0x39;

else if(cyferka == 0xDE) return 0x7F;

else if(cyferka == 0xDD) return 0x6D;

else if(cyferka == 0xDB) return 0x5B;

else if(cyferka == 0xD7) return 0x3F;

else if(cyferka == 0xBE) return 0x6F;

else if(cyferka == 0xBD) return 0x7D;

else if(cyferka == 0xBB) return 0x4F;

else if(cyferka == 0xB7) return 0x09;

else if(cyferka == 0x7E) return 0x49;

else if(cyferka == 0x7D) return 0x76;

else if(cyferka == 0x7B) return 0x40;

else if(cyferka == 0x77) return 0x46;

}

void ISR_T0(void) interrupt 1

{

P0 = tab[ind];

kolumna = P0;

if ((K4 & K5 & K6 & K7) == 0)

{

cyferka = kolumna;

P2 = naWyswietlacz(cyferka);

}

ind++;

ind %= 4;

}

void init(void)

{

TMOD = 0x02;

TL0 = 0xFF;

TH0 = 0xFF;

ET0 = 1;

EA = 1;

TR0 = 1;

ind = 0;

cyferka = 0;

kolumna = 0;

P2 = 0;

}

void main(void)

{

init();

while(1)

{;}

} 

******************************************
1. na P1 zapalic diode podlaczona katodą (wyswietlic binarnie swój numer) - u nas 3.

#include <REGX52.h>

void main(void)
  {     while(1)
     {   P1 = 0xFC; }
  }

******************************************
2. na P1 zapalic diode podlaczona anodą (wyswietlic binarnie swój numer) - u nas 3.

#include <REGX52.h>
void main(void)  {

     while(1){P1 = 0x03; }
  }

******************************************
4. na P0 zapalic wyswietlacz podlaczony katodą (wyswietlic swoj numer) 5

#include <REGX52.h>
unsigned char xdata rejestr _at_0x8000;
void main(void){
     while(1){ rejestr = 0x05;}
  }

******************************************

Napisz program zwiększający o dwa liczbę A , zdefiniowaną w pamięci kodu pod adresem 0x55;wynik zapisz w zmiennej umieszczonej pod adresem 0x55 w zewnetrznej pamięci danych:

#include<regx51.h>
unsigned char code A _at_ 0x55;
unsigned char xdata B _at_ 0x55;
void main(void) {
B=A+2;
while(1){;}
}

******************************************
Napisz uzywając dyrektywę sbit funkcję równoważną podanej
unsigned char data Key,Key1;
void ISR_Timer1(void)interrupt 3
{ Key = P1;
Key1 = Key;
Key1 &= 0x3C;
Key1 = (Key1>>2);
if(Key1 != 15){P2=Key;}
}
******************************************
ODP:

SBit Key1^2; SBit Key1^3; SBit Key1^4; SBit Key1^5;

void ISR_Timer1 (void) Interupt 3 {
Key = P1;
Key1 =Key;
Key1 &=0x3C;
if ((Key1^2 & Key1^3 & Key1^4 & Key1^5) != 1) {P2 = Key;}
}

Dla podanego schematu napisz program wyświetlający binarnie na diodach liczbę wciśnięć przycisków P1 i P2, przy czym P1 zwiększa/od zera/ , a P2 zmniejsza /do zera/ wartość wyświetlaną. Do obsługi przycisków użyj przerwań.


na schemacie był mikrokontroler a do portu P1 podłączone 8 diod chyba katodami i do portu P3.2 przycisk P1,a do P3.3 przycisk P2.

#include<regx51.h>
void Init(void) {
P1=0xFF;// jedynki na porcie powodują wygaszenie
EX0=1;
EX1=1;
EA=1; }
void ISR_INT0(void) interrupt 0 {
P1--; }
void ISR_INT1(void) interrupt 2 {
P1++; }
void main(void) {
Init();
while(1){;}
}

naciskamy 3 przyciski

1 diody zapalaja sie cyklicznie w lewo(INT0)
2 diody zapalaja sie cyklicznie w prawo(INT1)
3 gasimy diody(T0)

czwarte przerwanie zajmuje sie cała praca( przerwanie od timera 1)


#include <REGX51.H>


#define Time 250


unsigned char xdata Led _at_ 0x8000;
unsigned char index,Select,dzielnik;

unsigned char code Lewo[8] = { 0xFE, // 1 1 1 1 1 1 1 0
0xFD, // 1 1 1 1 1 1 0 1
0xFB, // 1 1 1 1 1 0 1 1
0xF7, // 1 1 1 1 0 1 1 1
0xEF, // 1 1 1 0 1 1 1 1
0xDF, // 1 1 0 1 1 1 1 1
0xBF, // 1 0 1 1 1 1 1 1
0x7F // 0 1 1 1 1 1 1 1
};

unsigned char code Prawo[8] = { 0x7F, 0xBF,0xDF, 0xEF, 0xF7 ,0xFB, 0xFD, 0xFE};

void ISR_Init(void) {
IT0 = 1; //INT 0 i INT1 na zbocze opadające
IT1 = 1; //
EX0 = 1; //włączenie przerwań INT0 i INT1
EX1 = 1; //
TH0 = 0xFF; //wartości rejestrów
TL0 = 0XFF; /////////////////
TH1 = 0x10; ///////////////
TL1 = 0x10; /////////////////
ET0 = 1; //właczenie przerwań od timerów
ET1 = 1; /////////
TMOD |= 0x26;//////pierwszy timer(T1) automatyczne przeładowanie, drugi(T0) counter z automatycznym przeładowaniem
TCON |= 0x50; właczenie Timera 0 i Timera 1
EA = 1; //włączenie przerwań
}



void Init()
{
dzielnik = 0;
Select = 2;
index = 0;
Led = 0xFF;
ISR_Init();
}

//procedura obslugi przerwania 0
void ISR_INT0(void) interrupt 0 {
Select = 0;
}
void ISR_T0(void) interrupt 1 {
Select = 2;
Led = 0xFF;
}

void ISR_INT1(void) interrupt 2 {
Select =1;
}

void ISR_T1(void) interrupt 3 {
dzielnik++;
if(dzielnik == Time) {
dzielnik = 0;
if (Select == 0)
{
Led = Lewo[index];
index++;
if(index==8) { index = 0; }
}

if (Select == 1) {
Led = Prawo[index];
index++;
if(index==8) { index = 0; }
}
}
}

void main(void)
{
Init();
for(;;)
{ ;}
}

Co sek zapala diody

#include <REGX51.H>

#define CZAS 57

/*co 1s mrugaja diody */

static void timer1 (void) interrupt TF1_VECTOR using 1 {

unsigned char i;

if (i>7) P1=1+(P1<<1);

else P1=P1>>1;

if (i==15){

i=0; }

else i++;

}

void timer0 (void) interrupt TF0_VECTOR using 2 {

TL0=0xFF;

TH0=0xDB;

TR0=0x00;

TR1=0x01;

TR1=0x00;

TR0=0x01;

}

void main(void){

TL0=0xFF;

TH0=0xDB; // 65535-7200

TL1=0xF3;//0x9B;

TH1=0xF3;//0x9B; // 255-100

TMOD = 0x21; // T1 - licznik z aut przeladowaniem, T0 czasomierz

EA=0x01; // wlaczenie przerwan

ET0=0x01; // wlaczenie przerwan licznika T0

ET1=0x01; // wlaczenie przerwan licznika T1

TR0=0x01; // wlaczenie licznika T0

for(;;)

{ ; }

}