TODOPIC
Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: f-traxx en 16 de Julio de 2010, 06:25:09
-
Ola, soy nuevo en el foro y necesitaria ayuda para emular el codigo que utiliza el motorola MC145026, supongo que todos los protocolos trinarios van igual, si alguien me puede echar una manita, se lo agradeceria en cantidad.
Grácias a todos de antemano, y felicidades por el foro.
-
alguien me puede ayudar porfavor, necesitaria que me guiarais para hacer una subrutina que emule el MC145026 a una freqüencia de 181 KHZ, lo que no entiendo es lo de la freqüencia, alguien me puede decir si esa freqüencia se corresponde a el envio de las dos palabra o al de una.
Necesito un empujoncito...
-
Estaba mirando la hoja de datos del 145026 http://www.freescale.com/files/rf_if/doc/data_sheet/MC145026.pdf
Creo que la frecuencia que indicas es para el oscilador. Mira la página 12.
Igualmente... va ser un poco dificil emular las entradas triestado de este chip, ya que los pic tienen entradas smitch trigger y si las dejas al aire (ni 0 ni 1) entonces toman valores al azar (0 o 1) dependiendo del ruido que les entre. Seguramente tendrás que utilizar uno o mas integrados con entradas triestate antes del micro.
Al menos es lo que yo creo, si alguien tiene una idea mejor que la comparta. Siempre hay "truquillos" con los micros que uno desconoce :)
Si lo que quieres es reemplazar el 145026 con un solo micro yo te diría que uses un micro con 15 entradas digitales . En lugar de tener 9 dip switchs triestado le pones 15 dips biestado 0/1. Con eso logras 32k combinaciones. Luego ya es cuestión de codificar el tipo y envío de datos.
-
Muchisimas gracias por la respuesta pibe, si lo que quiero intentar hacer es sustuir el MC145026 y el MC145027, por dos microcontroladores, el problema es que no se como empezar con la codificacion de los datos.
Lo que yo creia, es que la freqüencia esa de 181 Khz, era el data period que sale en la página 13, y he calculado el tiempo que tarda en microsegundos en enviar una palabra, como lo harias tu lo de la codificacion?
Lo siento por ser tan pregunton... pero soy algo nuevo en el tema... nunca havia tocado RF.
-
Pero ya tienes unos 145026 y 027 puestos en algun circuito? O es un proyecto escolar ? O es un desafío particular?
Me suena como que es un proyecto escolar porque aportas el dato de 181khz.
Por otra parte... microsegundos para enviar una palabra no es posible a menos que tengas un micro corriendo a 1 ghz :). Seguramente son milisegundos.
El problema que yo de C ni papa. Pero es que ni siquiera puedo escribir el encabezado sin que me dé error, jajajaa. Y mira que lo he intentedo! :P
Pero bueno, el lenguaje es lo de menos.
Primero deberías encarar por el hardware. Necesitas que las entradas sean triestate? O solo necesitas que los datos de salida sean los mismos sin importar el tipo de entradas? Luego de esto, usarás modulos de RF para emitir recibir? O al ser un proyecto escolar sólo es sobre el papel y nada más?
Una vez tengas claro todos los componentes que deberías utilizar entonces haces el esquema. A ser posible en el ISIS de proteus.
Luego toca hacer un diagrama de flujo del programa. De principio a fin. Primero globalmente para que te aclares que debe hacer el programa.
Luego refinas, profundizas el diagrama de flujo mas detalladamente: Inicializacion de variables, temporizadores, interrupciones (si cabe) . lectura sobre las entradas, decisiones acorde a las entradas y grabación del dato en ram o eeprom, lectura del pin "envio" , envió de datos y su correspondiente codificación y vuelta al loop de lectura de entradas.
-
Si, como bien has dicho es un proyecto escolar, pero no me interesa mucho que me hagais el programa en si, sino contrastar mis ideas y que se me suigeran otras, no tengo ningun 145026 en ningun circuito, respecto a lo de los microsegundos..., me he explicado mal, si no me he equivocado en los calculos, lo que queria decir es que el micro tarda 0.58 ms en enviar un estado (un "1" o un "0"), aunque no sepas de C, creo que da igual, porque me gustaria que me dierais algunas pautas, ahora me pondre a hacer el diagrama de flujo y todo lo que me has aconsejado.
Te cuento lo que necesito y lo que no, las entradas no tienen que ser tristate solo necesito que los datos de salida sean los mismos, ya que yo tengo un micro que recibe una instruccion por un pin, luego esa instruccion se tendria que pasar a codigo trinario para que lo pudiera reconocer un MC145027 y por último, si que será via RF para emitir y recibir, el professor nos pasara los módulos, nosotros solo tenemos que hacer la programación.
Muchisimas grácias por tu paciencia/interés espero aprender mucho de este foro y ser de ayuda en medida de lo possible, veo que tu eres de gran ayuda porque me he fijado que escribes en muchos posts.
Grácias otra vez.
-
De ná ;-)
Ve primero por lo que te he puesto.
Te costará lo suyo, pero una vez tengas el diagrama de flujo es coser y cantar.
La clave es que reemplaces primero el 45026 por el micro . Aun no programes las entradas para que cambie el codigo, déjalo para después. Haz que envíe un código fijo, una palabra primero , luego dos. Da igual la frecuencia. Luego cambias la frecuencia (no sé si usarás UART o un pin digital del micro) , y así.... pasito a pasito....
Una vez tengas el dato de salida deseado ( te aconsejo ferviertemente un osciloscopio) entonces pruebes con un 45027 por cable a ver que tal va.
Si no sabes C, pues vas de a poco. Busca por el foro los ejemplos en C que existen, mira como inicializan el micro y cada instruccion. Copia y pega sin vergüenza! jajajaja.
-
Muchisimas grácias por tus aportes, rapidez y paciéncia, me pondre en quanto pueda ahora estoy haciendo el diagrama, te puedo preguntar cosillas por mensajes?
-
Hola, alguien me puede ayudar con el tema, por ahora he hecho un codigo que envie una trama fija de bits, alguien me puede decir si funciona, ya que no consigo utilizarlo en el Proteus.
#device adc=8
#FUSES NOWDT, XT, NOPUT, NOPROTECT, NODEBUG, NOBROWNOUT, NOLVP, NOCPD, NOWRT
#use delay(clock=8000000)
#use rs232(baud=1200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
#USE FAST_IO (A)
#USE FAST_IO (B)
#USE FAST_IO (C)
//ROGRAMA PER EMULAR PROTOCOL MC145026
/////////////////////////////
////////////////////////////
// Definició de Pins
//////////////////////////
/////////////////////////
// ***** IN-CIRCUIT SERIAL PROGRAMING ***** //
// PGM ==> PIN_B3 (24)
// PGC ==> PIN_B6 (26)
// PGD ==> PIN_B7 (28)
// VDD ==> (20)
// VSS ==> (8,19)
///////////////////////
//////////////////////
// Variables Globals
////////////////////
///////////////////
///DECLARACIO DE FUNCIONS
void envia_paraula(void); // envia una paraula
void bit_alt (void); // high bit(1)
void bit_baix(void); // low bit(0)
#DEFINE ENVIA_CODI PIN_C6 //port per enviar el codi
#DEFINE POLSADOR PIN_C3 //para hacer pruebas de envio de datos
void main()
{
set_tris_a (0b00000000);
set_tris_b (0b00000000);
set_tris_c (0b00000000);
setup_psp(PSP_DISABLED);
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
disable_interrupts(GLOBAL);
while (true)
{
if (input(polsador));
{
envia_paraula();
delay_ms(8);
delay_ms(8);
envia_paraula();
delay_ms(8);
delay_ms(8);
}
}
}
void envia_paraula()
{
bit_alt(); //Una paraula la formen 9 "digits"
bit_alt(); //els 5 primers son de la direccio
bit_baix(); //i els altres 4 de la dada.
bit_baix(); //Aquests són els cinc
bit_alt(); //digits de la direccio.
bit_alt(); //Aquests són els 4 "digits"
bit_alt(); //que formen la dada.
bit_alt();
bit_baix();
}
void bit_alt()
{
delay_ms(0.5);
output_high(envia_codi);
delay_ms(3.5);
output_low(envia_codi);
delay_ms(0.5);
output_high(envia_codi);
delay_ms(3.5);
output_low(envia_codi);
}
void bit_baix()
{
delay_ms(0.5);
output_high(envia_codi);
delay_ms(0.5);
output_low(envia_codi);
delay_ms(3.5);
output_high(envia_codi);
delay_ms(0.5);
output_low(envia_codi);
delay_ms(3.5);
}
-
veo que los 8 milisegundos salen como 8) ya sabeis amigos, la carita són 8 milisegundos
-
Jeje. Veo que vas por buen camino.
No entiendo nada de C, pero adc=8 y use 232 en las declaraciones creo que están de más porque no las vas a utilizar.
Que micro?
El cristal es de 8mhz?
Que compilador C usas?
Igualmente al usar el compilador te crea un .COF que puedes usar con el ISIS para simularlo.
-
Gracias por tu apoyo pibe, lo del adc=8, nose que es porque me lo pone solo el compilador, y lo del use232, si que lo necesito porque tambien tiene que poder ser por cable, uso el PIC16F870, el cristal a 8 mhz si, y el compilador el CCS PCW.
Crees que la rutina está bien echa??
-
Hombre, tiene buena pinta . Pero como no entiendo ni papa de C pues es como si un chinito me habla en chino , me doy cuenta que me habla en chino pero ni me entero :P
Ahora, el 232 NO lo necesitas. Por que? Porque el rs232 envía bytes enteros y de una duración preestablecida, misma duración entre 0 y 1. Tus datos son diferentes, duran diferentes los 1 y los 0. Hay pulsos intermedios que un rs232 no puede emular.
Igualmente tu código te servirá tanto para enviarlo por cable como por aire. Es solamente emular un 145026.
Yo podría "intentar" compilarte el programa. Pero seguro meto la pata, empiezo a tocar aquí y allá, y no lograré nada porque no entiendo lo que hago.
Mejor te esperas a que un sabio del C te eche un cable :D
Si te sirve el programa en asm (asembler) te lo hago. Pero seguro tu profe te mirará con cara rara :mrgreen:
-
hombre pues si me hicieras el favor, pero si te supone mucho tiempo, no te molestes, que yo ya lo ire haciendo, pero si conocieras a alguien del foro que sepa de C... pues mejor, porque por lo que parece a los nuevos es dificil que les ayuden...
-
Na, tranqui que ya saltará un buen samaritano del C. Si ven que tu te esmeras y haces tu parte pues entonces te echan un cable.
Y además, hay más foreros de C que de asm, eso fijo :mrgreen:
He compilado SIN FALLOS :-/ tu código.
He metido el .cof en el isis pero el osciloscopio virtual me marca que la salida se pone en High y ahí se queda todo.
Mañana a primera hora desempolvo uno de mis 16f877 , lo meto en la protoboard y le machaco algo de asm :D
El tema será luego que tu pases mi asm a C. Ahí ya no te puedo ayudar.
Por eso, a ver si un "Maestro Yoda" del C te echa un cable que será más productivo y rápido.
Claro que tendrás que explicarle de que vá el envío de datos y el protocolo. Lo que es un digito High, uno low y otro High impedance.
-
A mi me pasaba lo mismo con el Issis, veia la salida High, pero luego ya no pasaba nada mas, seguro que no te costara mucho rato? porque si es asi de verdad que da igual, muchas grácias por toda tu ayuda!!! con los passitos que me has ido dando la cosa se ha desatascado, GRACIAS!
-
Vaya... veo que la peña ha pasado del tema. :?
bueno, ya tengo montada la proto. En un rato te paso el asm.
-
Si, yo tambien veo que la gente pasa bastante...
Bueno he modificado un poco el codigo, con lo que te dije de los pulsos, que en uno largo caben 7 cortos, te lo podrias intentar mirar (lo he hecho mirandome el Data period).
aqui dejo el codigo modificado
#include <16f870.h>
#device adc=8
#FUSES NOWDT, XT, NOPUT, NOPROTECT, NODEBUG, NOBROWNOUT, NOLVP, NOCPD, NOWRT
#use delay(clock=4000000)
#use rs232(baud=1200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
#USE FAST_IO (A)
#USE FAST_IO (B)
#USE FAST_IO (C)
//ROGRAMA PER EMULAR PROTOCOL MC145026
/////////////////////////////
////////////////////////////
// Definició de Pins
//////////////////////////
/////////////////////////
// ***** IN-CIRCUIT SERIAL PROGRAMING ***** //
// PGM ==> PIN_B3 (24)
// PGC ==> PIN_B6 (26)
// PGD ==> PIN_B7 (28)
// VDD ==> (20)
// VSS ==> (8,19)
/////////////////////
//****CONSTANS****//
///////////////////
int pols = 0.5; //tiempo de un pulso(ms)
int DT = 8; //tiempo que dura un digito (ms) (Data Period)
///DECLARACIO DE FUNCIONS
void envia_paraula(void); // envia una paraula
void bit_alt (void); // high bit(1)
void bit_baix(void); // low bit(0)
void atent (void); // enviar un espacio para empezar a recibir la
// trama, para "despertar" al micro
#DEFINE ENVIA_CODI PIN_C6 //port per enviar el codi
#DEFINE POLSADOR PIN_C3 //para hacer pruebas de envio de datos
void main()
{
set_tris_a (0b00000000);
set_tris_b (0b00000000);
set_tris_c (0b00000000);
setup_psp(PSP_DISABLED);
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
disable_interrupts(GLOBAL);
while (true)
{
if (input(polsador));
{
atent();
envia_paraula();
delay_ms(DT*3);
envia_paraula();
delay_ms(DT*3);
}
}
}
void atent()
{
output_low(envia_codi);
delay_ms(DT);
}
void envia_paraula()
{
bit_alt(); //Una paraula la formen 9 "digits"
bit_alt(); //els 5 primers son de la direccio
bit_baix(); //i els altres 4 de la dada.
bit_baix(); //Aquests són els cinc
bit_alt(); //digits de la direccio.
bit_alt(); //Aquests són els 4 "digits"
bit_alt(); //que formen la dada.
bit_alt();
bit_baix();
}
void bit_alt()
{
output_low(envia_codi);
delay_ms(pols);
output_high(envia_codi);
delay_ms(pols*7);
output_low(envia_codi);
delay_ms(pols);
output_high(envia_codi);
delay_ms(pols*7);
output_low(envia_codi);
}
void bit_baix()
{
output_low(envia_codi);
delay_ms(pols);
output_high(envia_codi);
delay_ms(pols);
output_low(envia_codi);
delay_ms(pols*7);
output_high(envia_codi);
delay_ms(pols);
output_low(envia_codi);
delay_ms(pols*6);
}
-
Vaya... veo que la peña ha pasado del tema. :?
bueno, ya tengo montada la proto. En un rato te paso el asm.
me puedes passar el fichero issis, o el esquema de la proto para probar??
-
Marchando. :mrgreen:
Tendrás que cambiar la declaración del micro ya que no tenía 16f870 para probar.
Luego me cuentas
Aqui se ve una "palabra"
(http://img.photobucket.com/albums/v165/carlyvalente/SCR0007.png)
He creado el asm en base al primer ejemplo que has subido. Pero ya creo que con esto puedes seguir experimentando.
Recuerda que has declarado variables en mayusculas y luego las llamas en minusculas, corrije eso.
-
Muchisimas gracias pibe. Ahora lo probare.
Pero he probado el mio, y no me funciona, en Issis, el oscilloscopia digital, no me hace nada, he utilizado el mismo esquema que tu, cambiando el micro por supuesto.
alguien me puede ayudar... creo que pibe al final ya se va a cansar... y el no sabe C, alguien que sepa algo de C me puede decir si el codigo es logico... porfavor.
Yo lo dejo aqui por si alguien se lo quiere mirar y opinar. Gracias.
#include <16f870.h>
#device adc=8
#FUSES NOWDT, XT, NOPUT, NOPROTECT, NODEBUG, NOBROWNOUT, NOLVP, NOCPD, NOWRT
#use delay(clock=4000000)
#use rs232(baud=1200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
#USE FAST_IO (A)
#USE FAST_IO (B)
#USE FAST_IO (C)
//ROGRAMA PER EMULAR PROTOCOL MC145026
/////////////////////////////
////////////////////////////
// Definició de Pins
//////////////////////////
/////////////////////////
// ***** IN-CIRCUIT SERIAL PROGRAMING ***** //
// PGM ==> PIN_B3 (24)
// PGC ==> PIN_B6 (26)
// PGD ==> PIN_B7 (28)
// VDD ==> (20)
// VSS ==> (8,19)
////////////////////
//***VARIABLES***//
//////////////////
int pols = 0.5; //tiempo de un pulso(ms)
int DT = 8; //tiempo que dura un digito (ms) (Data Period)
int1 polsat; //bit de seguridad
///DECLARACIO DE FUNCIONS
void envia_paraula(void); // envia una paraula
void bit_alt (void); // high bit(1)
void bit_baix(void); // low bit(0)
void atent (void); // enviar un espacio para empezar a recibir la
// trama, para "despertar" al micro
#DEFINE envia_codi PIN_C6 //port per enviar el codi
#DEFINE polsador PIN_C3 //para hacer pruebas de envio de datos
void main()
{
set_tris_a (0b00000000);
set_tris_b (0b00000000);
set_tris_c (0b00000000);
setup_psp(PSP_DISABLED);
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
disable_interrupts(GLOBAL);
while (true)
{
if (input(polsador&&(polsat==0)));//polsat=0 porque si se pulsa el
{ //boton mientras está dentro del
polsat=1; //bucle, no pase nada.
atent();
envia_paraula();
delay_ms(DT*3);
envia_paraula();
delay_ms(DT*3);
polsat=0;
}
}
}
void atent()
{
output_low(envia_codi);
delay_ms(DT);
}
void envia_paraula()
{
bit_alt(); //Una paraula la formen 9 "digits"
bit_alt(); //els 5 primers son de la direccio
bit_baix(); //i els altres 4 de la dada.
bit_baix(); //Aquests són els cinc
bit_alt(); //digits de la direccio.
bit_alt(); //Aquests són els 4 "digits"
bit_alt(); //que formen la dada.
bit_alt();
bit_baix();
}
void bit_alt()
{
output_low(envia_codi);
delay_ms(pols);
output_high(envia_codi);
delay_ms(pols*7);
output_low(envia_codi);
delay_ms(pols);
output_high(envia_codi);
delay_ms(pols*7);
output_low(envia_codi);
}
void bit_baix()
{
output_low(envia_codi);
delay_ms(pols);
output_high(envia_codi);
delay_ms(pols);
output_low(envia_codi);
delay_ms(pols*7);
output_high(envia_codi);
delay_ms(pols);
output_low(envia_codi);
delay_ms(pols*6);
}
-
No me voy a cansar! (además hay una docena de empanadas argentinas de por medio! :mrgreen: :mrgreen:)
Has probado el asm/hex que te he pasado en el ISIS que te he pasado?
Ahora lo que debes hacer es mirar mi asm con el MPLAB. Vete si eso en modo debugger /select tool / MPLAB SIM y le vas dando paso a paso. Miras lo que vá haciendo y ve estudiando tu código , comparando que hace el mío que funciona y donde está la diferencia con el tuyo.
-
El polsat de seguridad no es necesario. Te cuento por que:
Cuando pulsas saltas a la linea donde ya envia la palabra.
Pausa
Envias otra palabra
Pausa
etc
etc
Vuelves al inicio, a mirar el pulsador.
O sea, va linea a linea y por mas que pulses cuando estés dentro del bucle pues el micro no estará mirando el pulsador hasta no haber acabado el bucle y vuelto a empezar.
Distinto sería si utilizaces interrupciones para detectar el pulsador, entonces si deberías usar un flag de seguridad para que no vuelva a entrar en la interrupcion hasta no haber acabado la rutina principal.
-
ERROR :
set_tris_c (0b00000000);
Debe ser
set_tris_c (0b00001000);
Ya que el pin C3 es la entrada del pulsador
ERROR :
#use rs232(baud=1200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
Quita esto, porque el pin C6 está compartido con TX de la UART y entonces no te actuará el pin C6 como salida del dato!
-
Ostias.... normal que no me funcionara... a veces los despistes mas tontos son los que hacen perder mas tiempo....
ERROR :
set_tris_c (0b00000000);
Debe ser
set_tris_c (0b00001000);
Madre mia... ahora lo probare
-
Me hace caso omiso del pulsador... envia las palabras quando le da la gana...
-
Le pusiste la resistencia de pullup?
Para pruebas solamente: Lleva el pin C3 directamente a tierra y mira que ocurre en C6, luego a positivo y mira que ocurre. En una de las dos maneras deberá enviar los datos sin parar, y en la otra nada de nada.
Puede que to while esté al revés y esté enviando todo el rato porque detecta que C3=1, en ese caso modifica tu while para que envie cuando detecte C3=0
-
he probado las dos cosas en C, he negado el If que utilizo, y luego me lo envia rapidisimo, luego lo he dejado como estaba, y me lo envia quando le da la gana... aqui te subo los archivos que tengo... perdona pero no se que es el archivo .cof... aroa lo probare un rato mas a ver si encuentro algo raro y me ire a comer, hasta eso de las 4 no estare otra vez... no tengas prisa en mirartelo, si no puedes ya voy buscando yo cosas, pruebo eso que me has dicho de las resistencias y por la tarde te digo algo, lo prueba en la realidad no??
GRACIAS POR TODO...
-
aqui te subo los archivos que tengo...
:shock: :shock:
donde están?
Debes darle a opciones adicionales para subir el archivo. yo ahora piro a hacer siestita, vuelvo tipo 4pm.
-
Lo siento ha sido un lapsus... hoy ya van unos quantos... :?
-
jajajjaa! Que loco lo tuyo!
Estás midiendo tierra con el osciloscopio? :D :D :D
Aún así no sale nada. Déjame le eche un vistazo
-
Este es el que utilizava de verdad... es el que me pasaste tu :?
-
He modificado el codigo con unos calculos que he hecho, puedes medir que freqüencia tiene??
Muchisimas gracias
-
:-/ Creo que ya esta terminado por completo el programa!!!
aqui dejo los archivos subidos, esta todo lo necesario para simularlo en Issis, programa y todo.
-
Ahora que parece que ya termine con el MC145026 (no probado) y que parece que tiene buena pinta.
Vamos a empecar con el MC145027 que es el decoder, aqui dejo el codigo que he hecho, haver si alguien se lo puede mirar y opinan sobre ello, ya que no se si el array lo tengo bien hecho o no ustedes que creen???
Muchas gracias.
#include <16f870.h>
#device adc=8
#FUSES NOWDT, XT, NOPUT, NOPROTECT, NODEBUG, NOBROWNOUT, NOLVP, NOCPD, NOWRT
#use delay(clock=4000000)
#USE FAST_IO (A)
#USE FAST_IO (B)
#USE FAST_IO (C)
//ROGRAMA PER EMULAR PROTOCOL MC145027
/////////////////////////////
////////////////////////////
// Definició de Pins
//////////////////////////
/////////////////////////
// ***** IN-CIRCUIT SERIAL PROGRAMING ***** //
// PGM ==> PIN_B3 (24)
// PGC ==> PIN_B6 (26)
// PGD ==> PIN_B7 (28)
// VDD ==> (20)
// VSS ==> (8,19)
////////////////////
//***VARIABLES***//
//////////////////
int bit = 0; //esto es para guardar los tiempos de los bits en el array.
int num = 0; //para guardar la palabra (primera o segunda).
int digit=0; //para guardar los bits en el digito correspondiente.
/////////////////
//***ARRAYS***//
///////////////
long paraula[2][2][9]; //array para guardar los 2 tiempos de cada DT o digito
//iremos incrementando las variables para que cada vez se
//vaya guardando en las siguientes posiciones:
//(0,0,0)-(0,1,0)-(0,0,1)-(0,1,1)-(0,0,2)-(0,1,2)-(0,0,3)etc...
//DECLARACIO DE FUNCIONS
void guardar(void); //almacenar las dos palabras en un array
void comparar(void); //compara las dos palabras guardadas anteriormente
//////DEFINICIO DE PINS////
#DEFINE envia_codi PIN_C6 //port per enviar el codi
#define rebre PIN_C3 //Pulsador para enviar los datos
//DEFINICO D'INTERRUPCIONS//
void main()
{
set_tris_a (0b00000000); //todas los puertos como salidas
set_tris_b (0b00000000); //todas los puertos como salidas
set_tris_c (0b00001000); //todas los puertos como salidas menos
//el pin C3 como entrada
setup_psp(PSP_DISABLED);
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
//habilitacio d'interrupcions//
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_INTERNAL | T1_DIV_BY_1); //configuramos el timer1 con el prescaler a 1
//asi cuenta de 1us en 1us
setup_timer_2(T2_DISABLED,0,1);
enable_interrupts (int_timer1); //habilitamos el timer1
enable_interrupts (global);
while(1)
{
guardar();
comparar();
}
}
void guardar()
{ for ( ; !input(rebre); ); //Esperamos el inicio del pulso (flanco subida)
set_timer1(0); //Cuando llegue se pone a cero el Timer1
for ( ; input(rebre); ); //Esperamos al final del pulso (flanco de bajada)
paraula[num][bit][digit]= get_timer1();//Capturamos el intervalo de tiempo que tarda
//en hacer el cambio y lo guardamos en 0,0,0, quando
++bit; //passamos por aqui aumentamos en 1 "bit" y la segunda vez que pase por arriba
//lo guardará en 0,1,0. Quando vuelva a pasar por ++bit lo incrementara y bit será=2.
if (bit<=2);//esto se cumplira y como bit será =2
{
bit=0; //pondremos bit a 0
++digit; //y aumentaremos digit en 1, porque al volver a empezar la seqüencia lo guarde en 0,0,1.
if(digit<=9);
{
digit=0;
++num;
if(num<=2)num=0;
}
}
}
void comparar()
{
}
-
Uy uy, esto ya es C avanzado para mí :D
Tanto corchetes.. me pierdo...
NI idea traxx, te he dado una muleta durante un tiempo. Ahora es hora que te lances a caminar solito porque mi muleta ya te queda pequeña :mrgreen:
Además que aunque quisiese no podría ya que como te he dicho; debo entregar una serie de cuadros eléctricos urgentemente.
-
Tranquilo pibe, tu ayuda me ha servido de mucho!!!
Gracias por todo!! :mrgreen: :mrgreen: :) :)
-
Aqui esta el programa casi terminado, lo he probado con un MC14026 como codificador, y me va perfecto, ahora falta hacer el trocito de programa que haga salir los datos, pero la decodificación va perfecta.
En el Issis no se porque no funciona, lo he probado con un osciloscopio digital fisico y si que va.
Dejo el codigo y unas imagenes para ver que funciona.