Publicado por: MasterD en 10 de Mayo de 2004, 10:39:00
En PicBasic o en Basic existen los Alias. Es decir que puedo acceder
A cualquier punto de la variable en cualquier momento por ejemplo
Tengo la siguiente sub-rutina en Basic que puede leer un DipSwitch
Y almacena el contenido en variable < dipswt >, cuando los puertos están
Organizados en grupo de 4, 8, 2 no hay problema. Pero cuando están dispersos
En el puerto o en diferente puertos el caso es diferentes.
Read_sw:
dipswt=0 ‘ Limpia el contenido de la variable
dipswt.0=PORTA.2 ‘Almacena el contenido del PORTA.2 en dipswt.0
dipswt.1=PORTA.1 ‘Almacena el contenido del PORTA.1 en dipswt.1
dipswt.2=PORTA.4 ‘Almacena el contenido del PORTA.4 en dipswt.2
debug dipswt ‘ Imprime el valor total almacenado en < dipswt >
return
En C se me ocurre lo siguiente:
int Read_sw ( ) {
Int dipswt;
dipswt = 0;
bit_clear(dipswt,0);
if (input(PIN_A2))
bit_set(dipswt,0);
bit_clear(dipswt,1);
if (input(PIN_A1))
bit_set(dipswt,1);
bit_clear(dipswt,2);
if (input(PIN_A4))
bit_set(dipswt,1);
return (dipswt);
}
Sin embargo me resisto a creer en esto debe de existir un mejor método de asignación.
Estoy estudiando las estructuras y las uniones pero aun me cuesta comprender, menos aun los punteros.
Publicado por: pocher en 10 de Mayo de 2004, 13:48:00
Se puede hacer que sea el compilador quien asigne los bits individuales a las posiciones de memoria que le dé la gana (normalmente las asigna correlativas). Esto es lo más rápido de programar, o bien se puede obligar al compilador a que meta los bits en posiciones fijas de direccciones fijas asignadas por tí.
Yo personalmente te recomiendo la primera opción (que el jefe sea el compilador y te quite faena)
¿Con cual te quedas?
Un saludo
Publicado por: MasterD en 11 de Mayo de 2004, 05:02:00
hacer que sea el compilador quien asigne los bits individuales a las posiciones de memoria que le dé la gana (normalmente las asigna correlativas).
Publicado por: pocher en 11 de Mayo de 2004, 06:02:00
Codigo:
// P1_4_2.C
#include <16f84a.h>
#use fast_io(A)
#use fast_io(B)
#byte port_b = 6
main()
{
short B,A,R;
port_b = 0;
set_tris_a(0x1F);
set_tris_b(0x00);
while (1)
{
B = input(PIN_A0);
A = input(PIN_A1);
R = (R||!B)&&!A;
output_bit(PIN_B0,R);
}
}
Publicado por: El_Coach en 24 de Mayo de 2005, 04:01:00
Necesito asignar el valor de un pin del micro a los diferentes bits de una variable cada cierto tiempo. La única forma que se me ocurre es la que a continuación explico, pero espero que haya alguna más efectiva, no puede ser que sea la única manera. Un saludo
#include<18F2550.h>
#fuses HS,NOPROTECT,NOBROWNOUT,NOWDT,NOPUT
#use delay(clock=20000000) //Oscilador a 20MHz
main()
{
int var=0;
set_tris_a(0xFF);
while(1)
{
delay_ms(1000);
if (input(PIN_A0)) // <--- Me gustaria abreviar estas dos líneas en una sola,
bit_set(var,7); // <--- algo así: var.7=input(PIN_A0);
delay_ms(1);
if (input(PIN_A0))
bit_set(var,6);
delay_ms(1);
if (input(PIN_A0))
bit_set(var,5);
delay_ms(1);
if (input(PIN_A0))
bit_set(var,4);
delay_ms(1);
if (input(PIN_A0))
bit_set(var,3);
delay_ms(1);
if (input(PIN_A0))
bit_set(var,2);
delay_ms(1);
if (input(PIN_A0))
bit_set(var,1);
delay_ms(1);
if (input(PIN_A0))
bit_set(var,0);
}
}
Publicado por: Nocturno en 24 de Mayo de 2005, 05:05:00
var=0;
for (i=0;i<7;i++)
{
var=var+input (PIN_A0); // mete el valor de PIN_A0 en el bit menos significativo
var=var*2; // desplaza un bit a la izquierda la variable var
delay_ms(1)
}
Publicado por: El_Coach en 24 de Mayo de 2005, 06:44:00
Como se nota la experiencia...
A veces es bueno pensar en ensamblador, lo hice con tanto código porque con el for y utilizando i como indicador del bit en el que quería escribir, utilizando bit_set(var,i); , no siempre tardaba el mismo tiempo en ejecutar la instrucción. Haciéndolo como indicas debería siempre tardar lo mismo.
Gracias Nocturno
