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(;;)
{ ; }
}