Contor de rotaț ii pentru bobinatoare

Invalid input. Please provide text for translation.

17 octombrie, 2010
Acest proiect pe care ni-l trimite prietenul Roberto González, are
cum să numărăm rotirile pe care le face un motor prin intermediul unui
sensor de efect Hall, folosindu-l pentru a bobina transformatoare.
Sistemul poate func ț iona în două moduri: unul este să numere
vuletile motorului ș i altul este să indice numărul de rotaț ii
ce trebuie să ofere. În acest fel putem desfă ș ura un
transformator ș i a ș ti numărul de spire pe care le are bobina ș i/sau
bobinând un număr de ture determinat, odată ce acest număr este atins
de vueltas se taie alimentarea motorului.
La începutul sistemului, intrăm într-un meniu în care putem
selectaț i opț iunea dorită.
Circuitul poate fi utilizat pentru alte tipuri de aplicaț ii, având în vedere că este conceput
pentru a număra.

Circuit
Nucleul principal al circuitului este bazat pe un PIC 16F628. Nu s-a folosit PIC-ul
16F84 din cauza că programul pe care l-am dezvoltat ocupă mai mult de 1k de memorie. Dacă
programa se dezvolta in limbaj de asamblare este posibil sa se poata economisi memorie si sa incapa
în 16F84. De ș i, dacă ne uităm la pre ț urile componentelor, 16F628, pe care îl ai
oferă performanț e mai mari, este mai economic decât 16F84.
Microcontrolerul numără impulsurile furnizate de un senzor de efect Hall. Pentru
Trebuie să adăugăm la motorul pe care îl alegem, un mic magnet pe ax, pentru ca cu fiecare
vuelta pe care o face motorul generează un impuls în senzorul Hall. În cazul meu, am folosit un
ș urubelniț ă electrică de care se aruncă pentru că bateriile nu mai funcț ionează. Ș urubelniț a vă
am conectat la o sursă de alimentare externă care îl impulsionează.
Pe de altă parte, ș i independent de alimentarea motorului, se foloseș te o altă alimentare pentru
electronică asociată cu PIC. Aceasta a fost făcută astfel pentru că într-o primă aproximare am văzut
că vârfurile generate de motor (consumă destul de mult curent) erau introduse în
electronică ș i generau comportamente nedorite. Ca urmare a acestei experienț e, s-a decis
adăugaț i un optocuplor pentru a izola electronica de releul care permite alimentarea cu
motor.
Ca interfaț ă cu utilizatorul a fost folosit un keyboard matriceal de 4×3 ș i un LCD. El
tastatura serveș te pentru a da comenzile sistemului iar cu LCD-ul putem vedea în ce punct ne aflăm
am găsit. Schema este cea prezentată în figura de pe pagina următoare.
Ca senzor HALL a fost folosit A1104 de marca Allegro, pe care l-am achiziț ionat de pe web
[Link] un senzor care ne oferă un impuls la ieș ire atunci când detectează un
câmp magnetic, este un senzor de tip comutator. Ieș irea senzorului este mosfet cu drenaj
deschis, de aceea se adaugă o rezistenț ă între +5v ș i ieș irea senzorului.

Software
Microcontrollerul a fost programat în limbajul C, în special codul este realizat în
CCS. Utilizăm două rutine furnizate de acest compilator pentru a gestiona tastatura
matricial ș i LCD. Am modificat rutinele pentru a folosi portul B, în cazul în care
tastatură matricială ș i pentru a folosi 8 biț i pentru controlul LCD-ului prin intermediul portului B, pentru
LCD.
În esenț ă, programul utilizează TIMER0 ca un contor de evenimente de la nivel scăzut la nivel înalt
care sunt introduse de RA4 provenind de la senzorul HALL.
 Iniț ial, programul iniț iază tastatura, LCD-ul, setează RA4 ca intrare ș i restul
ca ieș iri. Este necesar să activezi rezistenț ele de pull-up asociate portului RB.
După iniț ializarea TIMER_0 pentru a număra evenimente prin pinul RA4 pe fronturile de la jos la
Bun, intrăm într-un bucle în care se aș teaptă comenzi de la tastatură.
În primul rând, pe LCD apare un mesaj al proiectului, pe care îl vom sări după
apăsaț i orice tastă.

Aceasta dă naș tere meniului de opț iuni al sistemului:

 Vom alege una dintre opț iuni apăsând pe tastatura numerică 1 sau 2. Opț iunea 1 permite
controla motorul cu start/stop ș i numără impulsurile care îi ajung prin senzor.

Opț iunea 2 ne activează tastatura pentru a introduce valoarea contului în care trebuie să ne oprim.
motorul. După introducerea acestei valori, cu tasta start/stop se porne ș te motorul
oprind când s-a ajuns la sfârș itul numărului.

Se poate ieș i din orice meniu apăsând tasta ‘#’. Dacă în meniul principal apăsăm
tasta '#' microfonul intră în stare de somn ș i programul nu se va mai executa până când
resetează microfonul cu butonul.

Tasta '*' din oricare dintre meniurile 1 sau 2 este responsabilă pentru funcț ia de start/stop, este
a spune, apăsând-o pentru prima dată ac ț ionează releul care alimentează motorul ș i apăsând-o din nou
a doua oară pentru motor. Acest lucru este util pentru un control manual al bobinătorului, având în vedere că
poate apărea ca firul să se blocheze, să se rupă sau să existe alte neplăceri, care necesită oprirea motorului
ș i a-l reporni odată ce a fost rezolvat.
 În primul rând, tot proiectul a fost realizat pe placa MicroPic Trainer, de acolo că în...
comentarii ale programului se ata ș ează starea întrerupătoarelor pentru a func ț iona
corectamente tastatura ș i LCD-ul.
După cură ț area proiectului, am realizat un circuit imprimat, imaginile acestuia
vom ataș a mai târziu.

// Trebuie să ne amintim că liniile RA0-RA2 acț ionează acum ca ieș ire de

// semnale de control către LCD. Fiind conectate cu întrerupătoare separate
// în MicroPIC Trainer, acestea trebuie să fie la nivel logic '1' permanent.
// adică în poziț ia marcată ca 0 pe placa
// Datele LCD-ului conectat la portul B
Teclado conectat la portul B: Coloana 0,1,2 la B5,B6 ș i B7.
// Fila 0,1,2 ș i 3 la B1, B2, B3 ș i B4
// RA3 conectează la ieș ire pentru motor. La început funcț ionează ca ieș ire
// de activat. Se poate studia posibilitatea de a implementa un control PWM
// pentru viteză. RA4 intrare pentru Timer0
#include
#include

#FUSEZ NOWDT //Niciun temporizator de supraveghere

#FUSEZE XT
#FUSES NOPUT //Fără temporizator de pornire
#FUSELE NOPROTECT
#foloseș te întârzierea(clcă=4000000)

#foloseș te fast_io(A)
#foloseș te fast_io(B)

#bit puertoA3 = 5.3 //Folosit pentru control on/off motor

voidmenu1(void);
voidmenu2(void);
int16contar(void);
int16introducere_valoare(void);

charcadena1[]={"f1-Contar Vueltn2-Introd. Vuelt"};

intdesbordamiento=0;

voidmain()
{
caracter
port_b_pullups(TRUE);
lcd_init();
kbd_init();
set_tris_a(0x10);//A4 ca intrare
puertoA3=0;//inicializo motor con 0
//lcd_enviar(LCD_COMANDO,LCD_CURSOR_BLINK); Nu activaț i cursorul ș i blinkerul

setează_timer_0(RTCC_EXT_L_TO_H|RTCC_DIV_1);
printf(lcd_putc,"Contor de Pulsuri By Rober ",);

fă
kbd_getc();
');
în timp ce (caracter=='
printf(lcd_putc, "%s", cadena1);
while(1)
{
caracter=kbd_getc();
 comută(caracter)
{
caz'1'
0
set_timer0(0);
menu1();
printf(lcd_putc,"%s",cadena1);
ruptura;
caz'2'
0
set_timer0(0);
meniu2();
printf(lcd_putc,"%s",cadena1);
pune capăt;
caz'*':
printf(lcd_putc,"f DE DE");
adormi();
}
};

int16contar()
{
intcuenta=0;
int16n;

contor=get_timer0();

dacă(cuenta==255)
{
setează_timer0(0);
deversare++
}
n=256*desbordamiento+contor;

lcd_gotoxy(10,2);
printf(LCD_PUTC,"%Lu",n);

return(n);
}

voidmenu1()
{
personaj;
intcontador_parcial=0;
1
inttecla_enter=0;//control de la tecla asterisco pulsada primera vez=1,
pulsada din nou =0
f* Motor Pornit/Opritn# iesire

fă
{
caracter=kbd_getc();

comutare(caracter)
{
caz '*':
dacă(tecla_enter==0)
{
fMotor ONn cuenta:
setează_timer0(contador_parcial);
1
0
set_tris_a(0x10);
puertoA3=1;//activo motor
}
altfel
{
lcd_gotoxy(1,1);
get_timer0();
printf(lcd_putc,"Motor OPRIT");
1
0
set_tris_a(0x10);
puertoA3=0;// motor apagado
}
opreș te;
#
tecla_enter=0;
1
set_tris_a(0x10);
0
ruptura;
}

dacă(tecla_enter)
contar();
}while(caracter!='#');
}

int16introduce_valoare()
{
caracter
charnumeros[6];
intcontador_caracter=0;
int16rotiri

printf(lcd_putc,"fN. Rotiri (4 cifre)n ");

lcd_enviar(LCD_COMANDO,LCD_CURSOR_ON);// activare cursor ș i clopot

fă
{

caracter=kbd_getc();

dacă(caracter!=' ')
{
printf(lcd_putc,"%c"caracter);
numeros[contador_caracter]=caracter;
contador_caracter++;
}
}
în timp ce (caracter!='#'&&contador_caracter<=4);
' ';
atol(numeros);
lcd_enviar(LCD_COMANDO,LCD_CLEARE);
lcd_enviar(LCD_COMANDO,LCD_ACASA);

printf(lcd_putc,"f* Motor Pornit/ Opritn# ieș i");

return(vuletas);
}

voidmenu2()
{
caracter
int16vâlturi;
1
inttecla_enter=0;//*es la tecla enter y asi controlo si la he pulsado 1 o
niciodată

int16n;

rotiri = introduce_valoare();

a face
{
caracter=kbd_getc();

comutare(caracter)
{
*
dacă(tecla_enter==0)
{
1
0
printf(lcd_putc,"fON Fin: %Luncuenta:",vueltas);
set_tris_a(0x10);
1; //Activ motor
}
altfel
{
lcd_gotoxy(1,1);
printf(lcd_putc,"Oprit Fin: %Lun cuenta:",vueltas);
1
tecla_enter=0;
set_tris_a(0x10);
0;//motor oprit
}
ruptură;
#
0
1
set_tris_a(0x10);
0;//motor oprit
rupt
}

dacă(tasta_enter)
{
n=conta();

if(vueltas==n)/*trebuie să opresc motorul*/

{
2;/*Folosit pentru a ieș i din funcț ie*/
set_tris_a(0x10);
0;//opresc motorul
}
}
}while(caracter!='#'&&motor_off!=2);
dacă(motor_oprit==2)
{
printf(lcd_putc,"fSe han Bobinado: n %Lu Vueltas",n);
fă
caracter=kbd_getc();
în timp ce (caracter == ' ');
}
}
PCB
Ataș ăm PCB-ul construit pentru a monta toată circuiteria:
Montajul final al proiectului este prezentat în imaginile următoare:

Sper că acest articol ț i-a fost util. Dacă da, aș aprecia să-l comentezi în
forumul nostru.
tastatură 4x4 în portul D în....ccs c 27 iunie 2009, 10:37:54
Salut tuturor, sunt nou pe forum, dar mi se pare grozav tot asta, observ un nivel ridicat la
nivel de utilizator, sper să pot contribui cu ceva ce ș tiu ș i au nelămuriri, de asemenea
pot solicita ajutorul dumneavoastră de mai multe ori.
Bine, sunt aici pentru că am făcut un mic cod în CCS C pentru PIC 16F877A unde
manipulez un tastatură matricială 4x4, dar problema este că a devenit foarte robust ș i nu ș tiu cum
fă să pară mai prezentabil ș i să nu fie nevoie să consum atât de mult timp citind linii, dacă da
m-ar putea ajuta să-l îmbunătăț esc, ar fi de mare ajutor. Pe de altă parte, nu pot folosi portul
A, pentru că l-am configurat pentru alte lucruri, B-ul îl am pentru gestionarea unui LCD.
20x4 y parte del puerto C, îmi ocup 2 CCP, prin urmare îmi rămâne doar portul
D liber ș i C în parte, bine, vă las pentru a vedea dacă mă pute ț i ajuta pu ț in. De
în avans, mulț umesc.

Cod:
#include <16F877a.h>
#dispozitiv adc=10
#FUSEZA NOWDT, HS, NOPUT, NOPROTECT, BROWNOUT, NOLVP, NOCPD, NOWRT
#foloseș te întârziere (ceas=20000000) //Fosc=20Mhz
#define use_portb_lcd ADEVĂRAT //definirea ieș irii portului B pentru lcd
#include<lcd.c> //biblioteca pentru gestionarea LCD
#foloseș te standard_io(D)

int i,j,x;
char Teclas[4][4]={{'1','2','3','A'}
{'4','5','6','B'}
7
{'D','0','E','F'}}
void main(){
lcd_init(); //iniț ializează lcd
în timp ce (ADEVĂRAT) {
i++;
schimbă( i )
{
caz 1:
output_high(PIN_D4);
output_high(PIN_D5);
output_high(PIN_D6);
iesire_scăzută(PIN_D7);
opriț i;
cazul 2:
produse_inalte(PIN_D4);
iesire_inalta(PIN_D5);
iesire_scazuta(PIN_D6);
iesire_inalta(PIN_D7);
ruptură;
caz 3:
output_high(PIN_D4);
ieș ire_scăzută(PIN_D5);
output_high(PIN_D6);
output_high(PIN_D7);
ruptură;
cazul 4:
iesire_pandant(PIN_D4);
output_high(PIN_D5);
scoate_inaltime(PIN_D6);
output_high(PIN_D7);
 ruptura;
caz 5:
rupturi;
default
}
dacă(i==5){i=0;}
dacă(!input(PIN_D0)){j=0;x=i;}
dacă(!input(PIN_D1)){j=1;x=i;}
dacă(!input(PIN_D2)){j=2;x=i;}
dacă(!input(PIN_D3)){j=3;x=i;}
printf(lcd_putc,"tecla:%c",Teclas[j][x]); //...prezentare
lcd_gotoxy(1,1);
}}

Bun, vă las simularea în Proteus + codul în C + hex...

teclado 4x4 [Link](18.21 KB - descărcat de 443 ori.)

darck_khronosRăspuns #1: 28 iunie 2009, 12:06:56

De ce nu foloseș ti biblioteca kdb ș i combini display-ul ș i tastatura în acelaș i port

SukyRăspuns #2: 28 iunie 2009, 12:17:05

Nu cred că este necesar să folosim acelaș i port pentru amândouă. Eu aș schimba LCD-ul pe portul D, ș i
aș profita de întreruperea prin schimbarea stării în RB4-RB7 pentru a detecta apăsarea uneia dintre ele
tecla.

Cod: (c)
#foloseș te fast_io(b)

char Teclas[17]={'1','2','3','A',
'4','5','6','B',
7
'D','0','E','F',' '};

char Tecla;

void main(){
set_tris_b(0xF0);
output_b(0x00);
activează_interupătoare(INT_RB);
activează_interrupț iile(GLOBAL);

#int_RB
void RB_isr(void)
{
Tecla=TestTeclado(); //Testează la Tecla Pulsată.-
printf("Tecla=%c", Tecla);
output_b(0x00); // Se poate folosi întreruperea de la RB4-RB7, iar cu asta rămâne
// în aș teptarea unei viitoare întreruperi.-
}

int TestTeclado(void){
int i,j,Filas;
Filas=0x0E; //xxxx1110.
output_b(Filas);
i=0;
pentru(j=0;j<4;j++){
dacă (input(PIN_B4) == 0) {break;}
 i++;
dacă (input(PIN_B5) == 0) {break;}
i++;
dacă(input(PIN_B6)==0){break;}
i++;
dacă(input(PIN_B7)==0){break;}
i++;
//rotaț i_stânga(&Filas,1);
shift_left(&Filas,1,1);
output_b(Filas); // Ț inem 0-ul la următorul Pin.
}
return(Teclas[i]);
}

darck_khronosRăspuns #3: 28 iunie 2009, 12:28:20

Susț in ceea ce spune Suky ș i, de asemenea, activezi pull-up-urile.

japifer_22Răspuns #4: 28 iunie 2009, 12:55:12

Un mare maestru suky aki = mă întâlnesc cu el ș i mereu mă ajută în tot, mulț umesc.
ceea ce se întâmplă este că am încercat să activez LCD 16x2 ș i funcț ionează bine, dar când o schimb la 20x4 nu îmi funcț ionează.
A funcț ionat ș i nu ș tiu de ce, de aceea a trebuit să mă descurc să fac asta ^^ salutări

darck_khronosRăspuns #5: 28 iunie 2009, 01:01:00

Citat de: japifer_22 pe 28 iunie 2009, 12:55:12
un mare maestru suky aici mă întâlnesc mereu ș i mă ajută în tot, mulț umesc.
Ceea ce se întâmplă este că am încercat să activez LCD-ul 16x2 ș i funcț ionează bine, dar când îl schimb în 20x4, nu funcț ionează.
funcț ionează ș i nu ș tiu de ce, de aceea a trebuit să mă descurc să fac asta ^^ salutări

Dacă tot încerci cu cea de 16x2, iată un diagramă pentru a conecta LCD-ul ș i tastatura.

japifer_22Răspuns #6: 28 iunie 2009, 01:11:43

suky, te spun că am o rutină pe care am făcut-o cu bibliotecile de keypad ș i funcț ionează, activează
tastatura cu portul B ș i LCD 16x2 pe portul D, dar când vine vorba să trecem la LCD 20x4 nu
îmi funcț ionează ș i rămâne pe portul B funcț ia acesteia, împreună cu funcț ia
tastatură, dar punctul aici face scurtcircuit. salutări
Cod:
#include <16F877a.h>
#dispozitiv adc=10
#FUSES NOWDT, HS, NOPUT, NOPROTECT, BROWNOUT, NOLVP, NOCPD, NOWRT
#foloseș te întârzierea (ceas=20000000) //Fosc=20Mhz
#define use_portd_lcd ADEVĂRAT //definirea ieș irii portului D pentru lcd
#include<lcd.c> //biblioteca gestionare lcd
#include <keypad.c> Librăria de tastatură 4x4

caracter fără semn cheie; //Variabilă globală tecla

// Interrupț ie RB4 - RB7 /////////////////////////////////////////////////////

#INT_RB
void întrerupe_tastatura()
{
cheie=citeste_tastatura(); //Asigna la tecla pulsată
sterge_intrerupere(INT_RB); // Lini ș teș te steagul RBIF
lcd_putc('\f'); //
lcd_gotoxy(1,1); //Vizualizaț i pe lcd
lcd_putc(key); //
}
// Programul Principal /////////////////////////////////////////////////////////

void main()
{
init_keypad();
lcd_init();

lcd_putc("\fAș teptând...");

în timp ce (adevărat)
{
}
}

japifer_22Răspuns #7: 28 iunie 2009, 01:13:20

Bună darck_khronos, mulț umesc pentru ajutor, dar portul A este ocupat. Salutari.

SukyRăspuns #8: 28 iunie 2009, 01:19:17

japifer_22, adaugă la librăria de 20x4 pentru a vedea cum să schimbi portul.
darck_khronos, în schemă pe care ai plasat-o văd un led pe RA5, iar acest pin nu are driver.
de ieș ire, poate fi folosit ca intrare sau ca Mclr.

japifer_22Răspuns #9: 28 iunie 2009, 02:42:25

Salut suky, aici îț i las biblioteca, plus simularea mea în proteus + C-ul + hex-ul programului meu.
Mulț umesc salu2s
para [Link](33.52 KB - descărcat de 246 ori.)

japifer_22Răspuns #10: 28 iunie 2009, 02:49:06

Bună, m-am înș elat, ț i-am trimis biblioteca pentru keypad, aici este lcd420.
para [Link](35,1 KB - descărcat de 155 de ori.)

SukyRăspuns #11: 28 iunie 2009, 11:14:45

Citat de: japifer_22 pe 28 iunie 2009, 02:42:25
Salut suky, aici îț i las biblioteca împreună cu simularea mea în proteus + C + hex-ul de
programa mea.. Mulț umesc salutări
Ataș ez biblioteca modificată ș i, de asemenea, alta care este mult mai flexibilă pentru o altă ocazie.
Biblioteca Modificată.rar(14.46 KB - descărcat de 264 de ori.)
japifer_22Răspuns #12: 28 iunie 2009, 03:20:06
Îț i mulț umesc mult, suky, îmi funcț ionează minunat, ai depăș it aș teptările încă o dată oferindu-mi soluț ia pentru
problemele mele, mulț umesc.
japifer_22Răspuns #13: 28 iunie 2009, 04:28:45
Mă gândeam,..... Cum pot forma o valoare de două sau mai multe cifre cu tastatura, sau prin
exemplu cu zecimal, mă refer la cum fac, de exemplu, numărul 10.5 cu tastatura ș i ce
aparezca în LCD acel număr, dacă doar eu apas pe 1, 0, ... ș i 5 ca un tot pentru a forma
un număr doar ?.

ArieRăspuns #14: 28 iunie 2009, 04:41:49

Bună!
foloseș ti o variabilă ș i faci ceva de genul
Variabilă = 0
Variabila = variabila + 1erdigito x 10
Variabila = variabila + 2erdigito
Variabila = variabila + 3erdigito/10

Asta da, respectând tipurile ș i sintaxa C.

Salut!
japifer_22Răspuns #15: 28 iunie 2009, 04:53:54
Bună Ariel, am văzut munca ta cu calculatorul, excelent, te felicit... ei bine, să vedem ce iese.
anda ce mi-ai spus salu2s

SukyRăspuns #16: 28 iunie 2009, 05:17:57

O altă formă ar fi să păstrăm într-un string:
char Sir[5];
char Tecla;
int i;
float Valor;
aș începe de la 0, aș a că de exemplu la apăsarea 12.35. De fiecare dată când se primeș te un număr se
păstrător
Tasta=test_tastatură();
Tecla
i++;

se va reseta când se apasă +, -, *, /, =, etc. La terminalul de primire va rămâne:

{1,2,.,3,5}
Ș i pentru a-l converti într-un float:
Valor=atof(ș ir);

Pentru acest lucru trebuie inclusă biblioteca #include <stdlib.h>

japifer_22Răspuns #17: 28 iunie 2009, 05:43:37
Bună suky, linia unde spuneTecla=test_teclado();îmi aruncă că nu este definit de ce.
SukyRăspuns #18: 28 iunie 2009, 06:01:38
Cita de: japifer_22 pe 28 iunie 2009, 05:43:37
Bună suky, linia unde scrie Tecla=test_teclado(); îmi aruncă că nu este definită de ce
Asta este un exemplu! Cred că tu foloseș ti read_keypad();

japifer_22Răspuns #19: 29 iunie 2009, 12:35:

Ups XD jijijij. Bun, acum am înț eles ce menț ionezi, dar acum am o mare îndoială ș i am încercat să fac
care doar la apăsarea unei taste de pe tastatură să crească cu unul i++, dar nu reuș esc să fac asta.
Aș adar, se presupune că fiecare tastă pe care o apas se va salva în String ș i de aceea este i++ pentru
să meargă într-un spaț iu ș i să păstreze în acest caz numărul pe care i-l asignez ș i să mi-l
arată ca un tot (asta depinde de câte numere am apăsat), dar nu reuș esc să îmi dau seama doar când
când apăs o tastă de pe keypad să crească i++, cum fac asta
SukieRăspuns #20: 29 iunie 2009, 01:47:04
Nu ș tiu unde vei plasa i++, cu siguranț ă ai o i=0; care îț i elimină pasul
anterior
japifer_22#21: 29 iunie 2009, 02:19:10

Nu înț eleg! A vezi nu face ceea ce vreau, îl am configurat greș it.

am încercat să facă ceva tot acest timp, dar nimic. Te rog ajută-mă... tastatura
este în acest fel:
char tastatură[4][4] = 1
4
7
Textul furnizat nu poate fi tradus.

atunci apasă pe A ș i acced la tastatură adică pot folosi toate numerele, apoi prin
exemplu vreau să scriu numărul 10.5, odată ce am scris asta, revin ș i apas A sau B, dă-l
mismo, ș i mi se blochează din nou tastatura doar cu numere, adică de la 0 la 9 ș i ., ș i numărul 10.5
salvează-l într-o variabilă pentru a putea face operaț ii aritmetice cu el, dar ș i în interiorul pic-ului
a putea vizualiza pe LCD cifra creată, care în acest caz este 10.5 ș i asta e tot. Dar numerele
ce trebuie să creez poate fi atât întreg, cât ș i zecimal, care variază de la 0 la 25, unde în număr
poate avea nu mai mult de 2 zecimale adică 2.22, 5.53, 20, etc.
Singurul lucru pe care am reuș it să-l fac ș i care funcț ionează este să vizualizez tastele apăsate...

Cod:
#include <16F877a.h>
adc=10
#FUSEZĂRI NOWDT, HS, NOPUT, NOPROTECT, BROWNOUT, NOLVP, NOCPD, NOWRT
#foloseș te întârzierea (ceas=20000000) //Fosc=20Mhz
#define use_portd_lcd TRUE //definirea ieș irii portului D pentru LCD
#include<lcd420.c> //librărie gestionare lcd
#include <keypad.c> Biblioteca de tastatură 4x4
#include <stdlib.h>

unsigned char cheie; //Variabilă globală tecla

char variabila=0;

char String[5];
char Tecla;
int i;
float Valoare;
// Interrupț ie RB4 - RB7 /////////////////////////////////////////////////////

#INT_RB
void intrerupe_tastatura()
{
cheie=lectura_tastaturii();//Atribuie tasta apăsată
sterge_interrupt(INT_RB); //Limpia bandera RBIF

}
// Programul Principal /////////////////////////////////////////////////////////
void main()
{
lcd_init();
i=0;
în timp ce (adevărat)
{

init_keypad();
variabilă=cheie;
printf(lcd_putc,"tecla: %c",variabila);
lcd_gotoxy(1,1);

}}
Sper că mă poț i ajuta, maestre
PD:{blestemat hobby îmi ocupă prea mult timp jijijiji, dar oricum mulț umesc suky pentru
tot ceea ce mi-a ajutat, o mare îmbrăț iș are

SukyRăspuns #22: 29 iunie 2009, 11:35:48

Aceasta este o modalitate de a face acest lucru, nu l-am simulat pentru a vedea daca functioneaza cu adevarat, dar ar trebui.

Cod: (c)
#include <16F877a.h>
dispozitiv adc
#FUSES NOWDT, HS, NOPUT, NOPROTECT, BROWNOUT, NOLVP, NOCPD, NOWRT
#foloseș te întârzierea (ceas=20000000) //Fosc=20Mhz
#define use_portd_lcd TRUE //definire ieș ire a portului D pentru LCD
#include<lcd420.c> //librărie manipulare lcd
#include <keypad.c> //Librăria de tastatură 4x4
#include <stdlib.h>

unsigned char cheie; //Variabila globală tecla

char variabilă=0;
int1 kbhit_tecla=0; // Pentru a verifica dacă a fost apăsată vreo tastă.
int1 NouIngres=1; // Indică că este prima intrare, aș a că ș terge ecranul
înainte de a imprima.
char String[5];
int i;
float Valoare;

// Interrupț ie RB4 - RB7 /////////////////////////////////////////////////////

#INT_RB
void întrerupere_tastatură()
{
citeste_tastatura(); //Asigna tasta apăsată
dacă (cheia != 'D') { // Trebuie să stabilim o tastă sau ceva care să îț i ofere
// s-a încheiat introducerea datelor
String[ i ]=cheie;
i++;
1 // Există un nou caracter de imprimat.
}else{
Valor=atof(String); Se apasă tasta D, ca un "enter",
// aș a că salvăm datele ș i indicăm
// că la sosire...
NouIngresare // ...altă dată se ș terge ecranul, ca o
// calculatoare. Ș i resetăm i.
i=0;
}
clear_interrupt(INT_RB); // Ș tergeț i steagul RBIF

}
// Programul Principal /////////////////////////////////////////////////////////
void main()
{
lcd_init();
initiaza_tastatura();
i=0;
în timp ce (adevărat)
{
dacă (kbhit_tecla=1) { // O taste a fost apăsată?
if(NouaTasta==1){
lcd_putc("\f"); // Cumpără ecranul.-
0
}
kbhit_tecla=0;
printf(lcd_putc,"tecla: %c",key); // Imprimăm tasta apăsată
}}
Cita de: japifer_22 în 29 Iunie 2009, 02:19:10
PD:{blestemat hobby îmi ia prea mult timp jijijiji, dar oricum mulț umesc
suky pentru tot ce ai ajutat, o îmbrăț iș are mare

Ș i dacă asta durează mult timp

japifer_22Răspuns #23: 29 iunie 2009, 03:50:43
Acum nu te mai deranjez, se pare că am aproape ceea ce încerc să fac, fac câteva teste.
mai mult ș i public, mulț umesc frumos pentru tot, suky.
marchezi#24: 3 Iulie 2009, 04:09:56
Bună!, nu ș tiu dacă ajung prea târziu ș i deja ai pregătit proiectul tău jejeje. Uite, eu pentru a folosi tastatura
pentru 4x4 am folosit o bibliotecă pe care am găsit-o pe internet cu numele kbdd.c ș i îmi funcț ionează la
o mie de minuni.
Apoi, pentru a afiș a un număr pe ecran cu zecimale, fiecare presupun că va avea trucurile sale.
Am creat două funcț ii, una pentru a introduce numere pe ecran ș i cu trei taste de control.
el * îl folosea pentru a ș terge ultimul număr introdus, A pentru a introduce virgula ș i # pentru
validarea numărului ș i ieș irea din funcț ie. Ș i apoi, când numărul era deja validat, să creez o altă funcț ie
ceea ce făcea era să capteze numărul de pe LCD, verificând dacă era virgulă sau nu. Dacă era virgulă în
în loc să-l înmulț ească cu 10 ș i să-i adune valoarea acumulată, îl împărț ea la 10.
Sper că m-am explicat suficient de bine
japifer_22Răspuns #25: 5 iulie 2009, 01:18:01
Bună, mulț umesc pentru comentariu........ suky, am încercat programul tău, dar nu face nimic..... este că ceea ce
fac ceva asemănător cu o calculatoare, adică pe măsură ce apas un număr, aceasta se
vizualizează pe LCD, ș i dacă apas mai mult de un număr = să se vizualizeze cifra adică apăs 1 ș i
după 2 ș i după 3 ... etc, etc, etc. Se va vedea pe ecran ca un număr adică 123 ș i
în plus, acest număr să rămână într-o singură variabilă. Nu te mint că sunt pe cale să
Rendimentează-mă cu acest proiect, nu am crezut că va fi atât de complicat să fac asta, l-am făcut multiplicând.
decena, centena ș i bla bla bla, dar programul mi se pare prea lung ș i asta nu este ideea, ideea
de asta este să economiseș ti cât mai multe linii. De la ultimul tău pos, am încercat să fac asta, dar nimic.
Vă rog să mă ghidaț i cum să fac asta, vă rog!

marcheziRăspuns #26: 5 iulie 2009, 05:50:29

Bună, cred că îț i pot oferi ceea ce ai nevoie, deoarece problema ta a fost exact la fel ca a mea
tubul
Îț i pun o funcț ie care afiș ează pe ecran numărul pe care îl introduci prin tastatură, ș i
are trei taste de control, * pentru a ș terge ultimul număr introdus, A pentru a introduce
mănâncă ș i # pentru a valida numărul care a fost introdus. Odată ce apeș i pe ș ir, ieș i din
funcț ie, dar vei avea numărul pe ecran, doar trebuie să îl capturezi unul câte unul ș i să creezi
număr. Dacă mai ai probleme, anunț ă-mă!!

Cod:
///////////////////////////////////////////////////////////////////////////////
/
Tecla_pulsada
/
///////////////////////////////////////////////////////////////////////////////
/
//Funcț ie: Afiș ează pe ecran valoarea numărului pe care doriț i să îl introduceț i. //
//Parametru de intrare:
//
///////////////////////////////////////////////////////////////////////////////
/

void Tecla_pulsada ()
{
int Teclan, coma=0,salir;
char Teclac; //INTRODUCEREA VALORII
while(salir==0){
do{
Teclac=kbd_getc();
clac=='\0');
Teclac-48
dacă(Teclan==-6)
printf(lcd_putc,"\b \b"); // A fost apăsat *
}
altfel dacă (Teclan==17)// S-a apăsat,
{
dacă(coma==1)
{
ruptura;
}
altfel
{
1
printf(lcd_putc,", ");
}
}
altfel dacă (Teclan==-13) // S-a apăsat #
{
1
}
altfel
{
printf(lcd_putc,"%d",Teclan);
}
}
}

SukyRăspuns #27: 5 iulie 2009, 11:37:40

Cita de: japifer_22 pe 5 iulie 2009, 01:18:01
Bună, mulț umesc pentru comentariu........ suky am încercat programul tău, dar nu face nimic..... este că ce încerc să
facând este ceva similar cu o calculatoare, adică pe măsură ce apas un număr, acesta se vizualizează în
la lcd, ș i dacă apas mai mult de un număr = să se vizualizeze cifra adică apas 1 ș i apoi 2 ș i apoi 3
... [Link]. se vede pe ecran ca un număr adică 123 ș i în plus că acest număr mă
rămână într-o singură variabilă. Nu te mint că sunt pe cale să renunț la acest proiect, nu am crezut că
a fost atât de complicat să fac asta, am făcut-o multiplicând zeci, sute ș i bla bla bla, dar programul
îmi iese prea lung ș i aceasta nu este ideea, ideea este să economisesti cât mai multe linii posibil. Din partea ta
ultima dată am încercat să fac asta, dar nimic. Vă rog să mă ghidaț i cum să fac asta, vă rog.
Am clarificat că codul s-ar putea să nu funcț ioneze, nu l-am simulat. Dar studiindu-l puț in, te
Îț i dai seama de ce nu funcț iona, de exemplu, nu am activat întreruperea pentru RB4-RB7, mă
echivoc în numele unei variabile, îmi lipsea un else, etc... Modificând asta func ț ionează
corect
Salut!
japifer_22Răspuns #28: 5 iulie 2009, 07:12:16
Bună din nou, bine, îț i spun SuKi că mi-am dat seama de variabila pe care o aveai greș ită ș i
am reparat ș i, de asemenea, am activat întreruperea, dar nu găsesc locul unde spui că trebuie să meargă
altfelîmi poț i indica, te rog? Ș i cealaltă chestiune, am o problemă de compilare, pentru că
pare a fi, deci este ideea mea că nu îmi detectează kbhit...

Cod
#INT_RB
void întrerupe_tastatura()
{
cheie=citeș te_tastatura(); //Atribuie tasta apăsată
dacă (cheia != 'D') { Trebuie să stabilim o tastă sau ceva.
care să te termine de introducerea datelor
String[ i ]=cheie;
i++;
kbhit_tecla=1; Este un nou caracter de imprimat.
}else{
Valor=atof(Sir) ; // A fost apăsată tasta D, ca un "enter", aș a că
// salvăm datele ș i indicăm că la sosire...
1 // ...un alt lucru este că ecranul se ș terge, ca o
// calculator. Ș i resetăm i.
i=0;
}
clear_interrupt(INT_RB); //Cură ț ă steagul RBIF

}
// Programul Principal /////////////////////////////////////////////////////////
void main()
{
lcd_init();
activează_interruptele(INT_RB); //interrupț ie INT_RB activată
dezactivează_interrupturile(GLOBAL); //toate întreruperile dezactivate
initiază_tastaieră();
i=0;
în timp ce (adevărat)
{
dacă(kbhit_tecla=1){ A fost apăsată vreo tastă?
if(NouaClavă==1){
lcd_putc("\f"); // Ș terge ecranul.-
0
}
kbhit_tecla=0;
printf(lcd_putc,"tecla: %c",key); // Imprimăm tasta apăsată
}}
Ha ș i marchizilor, mulț umesc pentru program, o să-l încerc..........
japifer_22Răspuns #29: 5 iulie 2009, 08:35:37
Bună, Suky, acum mi-a funcț ionat bine programul, mulț umesc.