multiplexer 4 entradas (A,B,C,D), 2 modificadores(S1,S2),

[johnbr]

Hola amigos, tengo un problema y esque necesito de realizar un multiplexer en pic c, tengo que desarrollarlo y no tengo la menor ide de como hacerlo , estoy usando el 18f4550 voy a tener 6 entradas y una salida, me pueden ayudar?

[Chaly29]

Hola johnbr. Estudia el funcionamiento de los integrados TTL 74153 o CMOS 4052 y ya tendrás una buen idea de como realizar o empezar tu programa.

Un saludo.

Atte. CARLOS.

[johnbr]

Esto es lo que tengo, pero el led(la salida) solo se queda parpadeando continuamente y no hace los cambios que quiero

#include "C:\Users\abrah\Documents\Universidad\demi.h"

#use delay(clock=20000000)
#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)

   
   #FUSES INTRC_IO //Oscilador Interno y tanto RA6 como RA7 son I/O
#FUSES NOWDT //Watch Dog Timer apagado
#FUSES PUT //Power Up Timer activado
#FUSES NOBROWNOUT //Reset ante variaciones de VCC desactivado
#FUSES NOIESO //Switch del oscilador en el encendido apagado
#FUSES NOFCMEN //detector de falla del oscilador principal apagado
#FUSES NOSTVREN //reset por desborde del stack desactivado
#FUSES NOLVP //Programación en baja tensión desactivada
#FUSES NOPROTECT //Protección contra lectura de la FLASH desactivada
#FUSES NOCPD //Protección de la EEPROM desactivada

#define A PIN_A0//set the pins
#define B PIN_A1
#define C PIN_A2
#define D PIN_A3
#define S1 PIN_B0
#define S2 PIN_B1
#define LD1 PIN_C2

int Sw1=0;//it states that Sw1 is 0 in the begining
int Sw2=0;
 

void main()
{

Sw1=input (S1);//Sw1 is an input
Sw2=input (S2);


while(true)
{
{
if ((Sw1==0)&(Sw2==0))//if port b5, b6 and a0 is 0
output_bit (PIN_A0,1);//led turns on
}

{
 if(input(PIN_A0)==1)//if input a0 (switch) is 1
output_toggle(PIN_C2);//output d2 led turns off
}


 
{
{
if ((Sw1==1)&(Sw2==0))
output_bit (PIN_A1,1);
}
{
 if (input(PIN_A1)==1)
output_toggle(PIN_C2);
}
 
{

{
if ((Sw1==0)&(Sw2==1))
output_bit (PIN_A2,1);
}
{
 if (input(PIN_A2)==1)
output_toggle(PIN_C2);
}

{

{
if ((Sw1==1)&(Sw2==1))
output_bit (PIN_A3,1);
}
{
 if (input(PIN_A3)==1)
output_toggle(PIN_C2);
   
}
 
}

}
}
}
}

[KILLERJC]

Creo que te seria mas facil si los 2 selectores ( S0 y S1 ) fueran uno solo, recorda que podes fabricar un numero con eso.. es decir con S0 y S1 podes tener los valores 00, 01, 10 ,11 o en decimal 0,1,2,3 respectivamente, y no separados.

De alli en mas es simple el programa, Te dejo para que lo hagas vos a como crear ese numero con los 2 bits o si hay alguna otra forma de hacerlo directo. Respecto al programa te daras cuenta que termina siendo mas simple si tenes ese numero ya realizado.

No puedo/quiero darte ni siquiera un pseudocodigo porque sino seria arruinarte el aprendizaje. Ya que es bastante simple y hay muchas posibilidades para hacerlo de formas distintas. Solo te voy a decir que:

Dependiendo de los valores S, vas a poner en tu salida el valor de alguna de las entradas (A,B,C o D). Una ves resuelto por tu parte podemos dar codigos para que veas otras formas de realizarlo.

[johnbr]

lo hice asi y solo me enciende con el pin A0 con cualquier combinacion que haga
#FUSES INTRC_IO //Oscilador Interno y tanto RA6 como RA7 son I/O
#FUSES NOWDT //Watch Dog Timer apagado
#FUSES PUT //Power Up Timer activado
#FUSES NOBROWNOUT //Reset ante variaciones de VCC desactivado
#FUSES NOIESO //Switch del oscilador en el encendido apagado
#FUSES NOFCMEN //detector de falla del oscilador principal apagado
#FUSES NOSTVREN //reset por desborde del stack desactivado
#FUSES NOLVP //Programación en baja tensión desactivada
#FUSES NOPROTECT //Protección contra lectura de la FLASH desactivada
#FUSES NOCPD //Protección de la EEPROM desactivada

#define A PIN_A0//set the pins
#define B PIN_A1
#define C PIN_A2
#define D PIN_A3
#define S1 PIN_B0
#define S2 PIN_B1
#define LD1 PIN_C2



void main(void)
{




{

int S; //Since the inputs are always read before this is used,
//it does not need to be initialised.

 
 
    while (true)
    { //assuming the switches really do need to update every loop

       S=input (S1) & input(S2);
       //S now has a number 0 to 3, reflecting the four possible combinations
       //of S1 & S2
       switch (S) {
       case 00:
          //Both S1 and S2 low
          output_bit(LD1, input(A)); //copy the A input to the output
          break;
      case 01:
          //S1 high S2 low
          output_bit(LD1,input(B)); //copy the B input to the output
          break;
      case 10:
          //S2 high and S1 low
          output_bit(LD1, input(C)); //copy the C input to the output
          break;
      case 11:
          //Both S1 & S2 high
          output_bit(LD1,input(D)); //copy the D input to the output
          break;
      }
   }
}
}

[KILLERJC]

hay un par de cosas mal pero el camino es el correcto... Las voy a nombrar, las vas a corregir y de alli tratar que funcione.

      case 10:

10 es un decimal, si quisiera poner un binario seria 0b10 y 0b11, sino 10 decimal es equivalente a 0b1010.
O los pones todos como binario ( 0b00 0b01 0b10 0b11 ) o todos en decimal ( 0 1 2 3 )

       S=input (S1) & input(S2);

Eso no te va a dar un valor de 2 bits, sino que estas haciendo una AND, pensa como si el input(S1) y el S2 tambien te devolviera un valor de 8bits en cero 0b00000000 o en uno 0b00000001

Si observas ambos te devuelven un 1 en la posicion del bit 0 cuando estan activos.
Al resultado(bit) del input(S1) le vamos a llamar "a" y al del input(S2) lo llamamos "b"
Luego de los inputs tenes esto:

0b0000 000a
0b0000 000b

ahora vos tenes que hacer:
0b0000 00a0
0b0000 000b

Y luego una operacion logica que los transforme en:

0b0000 00ab

Existe otra forma, aprovechando que estas usando b0 y b1, ya que de esa forma te lo da ordenado, y de alli deberias filtrar los datos. Dependiendo de a que resultado llegues luego ponemos las opciones.

[johnbr]

seria algo asi? el int 8 refiriendo a que son 8 bit y S lo voy a multiplicar por dos para que se mueva dos posiciones en cada caso?
void main(void)
{




{

int8 S;

 
 
    while (true)
    {

       S=input (S1) & input(S2)*2 ;
      switch (S) {
       case 0b00:
          //Both S1 and S2 low
          output_bit(LD1, input(A));
          break;
      case 0b01:
          //S1 high S2 low
          output_bit(LD1,input(B));
          break;
      case 0b10:
          //S2 high and S1 low
          output_bit(LD1, input(C));
          break;
      case 0b11:
          //Both S1 & S2 high
          output_bit(LD1,input(D));
          break;
      }
   }
}
}

[KILLERJC]

O podes multiplicarlo por 2 o hacer un shift a la izquierda de 1 lugar ( << 1 ), es lo mismo. Lo que no se si CCS tomara el resultado como un entero de 8 bits o no, espero que si.

Ya ahora tenes esto:

0b0000 00a0
0b0000 000b


Si haces una AND ( & ) vas a tener que hacer una AND bit a bit de esos valores, y una AND con un 0, es siempre 0

Aca tabla de verdad de la AND:
https://cdn.mikroe.com/ebooks/img/37/2016/02/al-mundo-de-los-microcontroladores-chapter-01-fig0-10.gif

El resultado de esa AND entonces SIEMPRE, lo cual no es lo correcto:
0b0000 0000

Tenes otras funciones logicas que te pueden servir.
La idea es que (refiriendome a la misma posicion de bits de ambos int8) si ambos son 0, el resultado sea 0.
Si uno de ellos es 1, el resultado sea 1.

[johnbr]

Entonces te estas refiriendo a que deberia usar una compuerta OR?y si si como lo representaria?

[KILLERJC]

Los operadores logicos bit a bit son:

AND = &
OR = |
XOR = ^

[johnbr]

Muchisimas gracias amigo al cambiarla a una OR ya me funciono el programa y la simulacion,mi problema ese, GRACIAS!!!

[KILLERJC]

Bien, ahora te voy a dar otros ejemplos de como lo podrias haber realizado de otras formas.

Código: C

1. void main(void)
2. {
3.  
4.    int S; //Since the inputs are always read before this is used,
5.    
6.  
7.     while (true)
8.     { //assuming the switches really do need to update every loop
9.  
10.        S = input_b() & 0x3; // Dejo solo B0 y B1, todo lo demas queda en 0, aprovecho de que ya están ordenados
11.        output_bit(LD1, (input_a() & (1 << S)));
12.    }
13. }

Otro

Código: C

1. int mArray[] = {0b0001,0b0010,0b0100,0b1000};
2.  
3. void main(void)
4. {
5.  
6.    int S; //Since the inputs are always read before this is used,
7.    
8.  
9.     while (true)
10.     { //assuming the switches really do need to update every loop
11.  
12.        S = input_b() & 0x3; // Dejo solo B0 y B1, todo lo demas queda en 0, aprovecho de que ya están ordenados
13.        output_bit(LD1, input_a() & mArray[S]);
14.    }
15. }

[johnbr]

input_a() en e parenthesis no va nada?
O aqui int mArray[]?
y que significa 0x3?

[KILLERJC]

input_a() en e parenthesis no va nada?

Las funciones input_x() son unicamente de CCS. No tienen ningun parametro, por eso esta vacio.

input_a() Te devuelve el valor de todo el puerto A. Es decir lee todo el puertoA y te devuelve un valor de 8 bits
input_b() es lo mismo pero para el puerto B.

O aqui int mArray[]?

Cuando declaro un array, puedo declarar la cantidad ejemplo:

int hola[3] = {1,2,3};

O puedo dejar sin declararlo como hice con mArray, luego el compilador va a verificar cuantos elementos tiene y le va a dar el valor correcto. Esto es mucho mas util cuando tenes textos, asi no tenes que estar contando uno por uno los caracteres + el caracter nulo.

char mText[] = "Hola como va";

y que significa 0x3?

En C hay distintas formas de representar los numeros. Decimal, Binario, Hexadecimal y Octal.

El Decimal (base 10)es el que conocemos, poner un numero y listo, ejemplo: 10
El Binario los numeros tienen base 2 ( solo podes usar del 0 al 1), debemos especificarle al compilador que lo que escribimos ES binario, por eso pusimos 0b1010
En Octal los numeros tienen base 8, ( se puede usar del 0 al 7), para que el compilador sepa que es un numero en octal, debemos anteponer un 0, ejemplo: 012
En Hexadecimal, los numeros tienen una base 16, simple de pasar de binario a Hexadecimal, para que el compilador sepa que es Hexadecimal se debe anteponer 0xA
Los elementos del Hexadecimal son del 0 al 9 y luego A,B,C,D,E y F.

Todos los numeros que te acabo de dar son lo mismo, es decir:

10 = 0b1010 = 012 = 0xA

Entonces 0x3 es igual a 3 decimal, o que es lo mismo que 0b11

La idea detras de eso es que de todo el puerto B, cuando se haga la AND del Puerto con 0x3 ( 0b0000 0011 ) unicamente queden los valores de RB0 y RB1 (obsevaras que son los unicos que se hacen la AND con un 1 )
Si hubiera querido hacer una AND y solo tener los valores de RB7 y RB6, entonces deberia haberlo hecho con 0b1100 0000

Espero que entiendas que esta pasando ahora.

PD: Separo los nibbles en binario porque es mas facil de ver, pero en realidad van juntos.

[johnbr]

Okay,muchas gracias ahora me queda claro