SET 39 Call For Papers

¿Eres un hacker? Si deseas pasar a formar parte de la historia del hacking hispano, colabora con la próxima edición de SET 39 enviándonos un artículo. No esperes más, esta es tu oportunidad de demostrar lo que sabes. Ayúdanos a construir una revista de hackers para hackers. SET Staff

Electronica Digital - Parte I

      2250

Autor: Jnzero
-[ 0x0C ]--------------------------------------------------------------------
-[ Electronica Digital - Parte I ]-------------------------------------------
-[ by jnzero  ]-------------------------------------------------------SET-22-



      -= ELECTRONICA DIGITAL O COMO CREARSE UN PENTIUM CON UN SOLDADOR =-
         _____________________________________________________________
                               

           Parte I                                     por jnzero



  Hola, este es mi primer articulo "serio" para un ezine underground. Se
supone que deberia ser un cursillo introductorio a la electronica digital,
es decir, en plan novato, con esquemas faciles y tal.

 Al ser electronica digital, casi mejor que voy a pasar de circuitos con
resistencias, condensadores, etc. y me dedicare unica y exclusivamente a
circuitos puramente digitales, ya sabeis, no intenteis buscar
impedancias, transistores porque no los voy a poner.

  Otra cosilla, el dise~o de circuitos digitales requiere, al menos el  
conocimiento de las leyes booleanas, que es un OR, un AND y tal, si habeis  
estudiado algun lenguaje de programacion, aunque sea BASIC, ya llevareis
un gran adelanto. Tambien es importante que conozcais como reducir la  
realidad a 1's y 0's, y esto inevitablemente tiene que pasar por los  
formalismos matematicos/logicos. No es tan jodio como parece pero es  
fundamental manejarse con las expresiones logicas.

  Y sin mas preambulos doy paso a la primera parte de estos articulos,
quiza sea solo uno o quiza sean veinte, todo depende del Y2K >:-]...



------------------1. Codificacion de la informacion.
           	     ==============================


  Aunque no lo creais el mundo de los ordenadores se basa en dos estados,  
ON (1) y OFF(0), que en la realidad se corresponden con una tension  (V =
5 volt ) y/o no tension (V = 0 volt).
  
  Ahora bien, imaginemos que tenemos una calculadora. Si pulsamos el 9,  
en la pantalla saldra un 9 (bieeeen), pero interiormente la calculadora  
no guarda la informacion tal que asi -> 9, sino en codigo binario: 1001.

  Esto lo doy porque es necesario pasar de codigo binario a codigo decimal  
(los numeros 0-9) y viceversa. Ej:

      DEC    BIN |
       0  -   0	 |  Como podemos ver, se mantiene el orden respecto a los
       1  -   1  | numeros en base decimal es decir 0 < 1 < 10 < 11.
       2  -  10  |
       3  -  11	 |	
  


------------------------------------1.1 Pasar de binario a decimal.



  Una pregunta: Como pasar de base binaria a base decimal? Facil.
Primero hemos de tener la estructura del numero... ej: 1010
 
 Al igual que en los numeros decimales, los digitos a la izquierda tienen  
mas "peso" sobre el numero que los de la derecha, en los decimales pasa  
lo mismo:
 
 MSB (Most Significative Bit)--> 1 0 1 0 <--LSB (Less Significative Bit)

 Para realizar el calculo tambien hemos de tener en cuenta como se
descompone  un numero, como por ejemplo el 1395,

   1395 = 1000 + 300 + 90 +5, esto es si nombramos a cada uno de los  
numeros con una letra y el numero de 0's que quedan sustituyendo todas las
cifras a la izquierda con 0, nos queda que

    a3 = 1 -> 1000 \
    a2 = 3 -> 300   \
    a1 = 9 -> 90    /+= 1395
    a0 = 5 -> 5    /

 
 Luego para codificacion binaria, pasa lo mismo:

    a3 = 1 -> 1000 \
    a2 = 0 -> 000=0 \
    a1 = 1 -> 10    /+= 1010
    a0 = 0 -> 0    /
  
 Si nos fijamos, podemos descomponer los numeros aun mas, utilizando  
potencias de la base, si la base es 10, 10^x--> 10 elevado a x, y si  es
2, 2^x 
   
   a3 = 1000 -> 1* 2^3 -> Aqui esta la movida. Si nos fijamos, si queremos   
   a2 = 000  -> 0* 2^2 -> obtener en decimal el numero de combinaciones
                          posibles
   a1 = 10   -> 1* 2^1 ->  en binario de tres cifras (esto es 000,001...)
   a0 = 0    -> 0* 2^0 -> tenemos en cuenta que por a2 habran dos
                          posibilidades 0 y 1; en a1, otras dos
                          posibilidades (0 y 1)...
                          asi hasta a0 que seran de nuevo 0 y 1... si lo
                          pensamos esto es 2*2*2 para una palabra de 3
                          bits.
(palabra=conjunto de bits=numero) y claro es lo mismo que 2^3. De ahi el
truquillo de la nomenclatura de cada uno de los bits, nos da la cantidad de
0's  o el exponente de nuestra potencia. Luego:

  VALOR (1010)base10= 1*2^3 + 0*2^2 + 1*2^1 + 0*2^1 =8 + 0 + 2 + 0=    10

 
  Es decir en terminos cutre-cientificos:
  (base=numero de elementos de la base en decimal-> binarios: (1,0)=2!!
						     
  VALORDEC (an...a0)=an*base^n + a(n-1)*base^(n-1) + ... + a0*base^0; 

  Como investigadores que somos nos damos cuenta que este metodo sirve
para pasar de cualquier base (binaria, octal, hexa...) a la decimal.
  Puf! espero que mas o menos se haya entendido... porque ahora va la  
parte chunga que es la operacion contraria. De todas formas, no os  
preocupeis, si pillais esto, teneis un 50 % hecho de los circuitos.



------------------------------------1.2 Lo contrario de 1.1


 
 Como se que estais deseosos de empezar a hacer codificadores de
informacion o vuestro propio Athlon, no me enrollare mucho...
Para pasar de decimal a binario se utiliza la aritmetica modular, esto
consiste en ir guardando los restos de las divisiones entre dos de los
cocientes sucesivos de nuestro numero decimal (num mod 2) y luego
presentarlos en orden inverso... cogiendo como MSB el cociente de la
ultima division... ahora lo veis...

P. ej.          147  |_2__
                  7   73                       
                  1/ --> LSB - este sera a0;

   Ahora hacemos :-->   73  |_2_
                        13   36
			 1/ --> a1...
                
                 ---> 36 |_2_
		       0/ 18 |_2_
			   0/  9  |_2_
			        1/  4 |_2_
				    0/  2 |_2_
					0/  1/ ---> MSB

 Luego dandole la vuelta al ultimo cociente y a todos los restos nos queda
un numero tal que:  10010011 que solo tenemos que pasar con la ful de las
potencias a base 10 para comprobar que vale...



------------------2. Hacer ya algo que interesa (puertas logicas).
		     ============================================



------------------------------------2.1 Puerta AND


  Es un dispositivo que nos compara dos se~ales, y si son ambas iguales y
estan a 1, nos devuelve 1 en otro caso nos dara 0.
        
          x | y | AND(X,Y) 
         ---|---|---------       x  _____|---\
          0 | 0 |   0                    |     \
          0 | 1 |   0                    |      |--- AND (X,Y)
          1 | 0 |   0            y  _____|      |
          1 | 1 |   1                    |     /
                                         |---/


------------------------------------2.2 Puerta NOT

  
  NOT not tiene misterio, una se~al que entra a 1 sale a 0, una que entra
a 0 sale a 1.
                                 	   |\
                                     x ----|  \o____ NOT(x)
 (me niego a poner las tablas)             |  /
					   |/


------------------------------------2.3 Puerta OR


          x | y | OR(X,Y)
         ---|---|---------       x  _____ ---\
          0 | 0 |   0                      \   \
          0 | 1 |   1                      |    |>--- OR (X,Y)
          1 | 0 |   1            y  _____  |    |
          1 | 1 |   1                     /    /
                                          ---/


  Si en las entradas hay al menos una a 1, la salida es 1. Si ambas son 0,
salida=0
 

  En el proximo capitulo mas puertecillas...



------------------------------------2.4 Un circuito


 Ahora que lo pienso si os habeis leido todo el muermazo de arriba y os lo
habeis aprendido de memoria, sois unos autenticos campeones, porque para
algo estan las calculadoras XDDD. Nah pero en la proxima fiesta podreis
presumir...

 Imaginaos que necesitais un circuito que compruebe la seguiridad de una
presa...

-Si el nivel del agua sube a un nivel considerable.
-Si la presa esta a punto de reventar. 

  Pues como vemos tenemos varios estados para nuestro sensor:

 S0-No pasa nada.
 S1-Advertencia.
 S2-Peligro.
  
  Ya que nos hemos aprendido lo de arriba vamos a pasar nuestra
informacion de numero de estados a binario luego:

S0 - 00     S2 -10 
S1 - 01
  
  Como tambien comprobamos tenemos dos entradas, entonces...

|        y| --> Sensor de peligrosidad 
|         |   
|        x| --> Sensor de advertencia
|         |
-----------

  Luego si el agua pasa por x, x genera una corriente que en terminos
digitales equivale a 1; y si pasa por y genera una corriente propia tb a
valor 1 digital.

   Luego nuestra tablita es :           x   |   y  || Estado | Valor OUT
					0	0	S0	00
Este estado es erroneo (pelig sin adv)->0	1	S?	?
					1	0	S2	01
					1	1	S3	10

 Como el valor de salida queramos que sea complejo, es decir que nos de la
mayor informacion posible, entonces tenemos cuatro salidas.
 
Ahora una notacion especial:
  

  x*y = xy = x AND y           Valor(x)  =1
  x+y =      x OR  y           Valor(y)  =0
  !x  =	     NOT x             Valor (!x+!y) = 1 (0 OR 1)


  osease:

1) SI x=0 e y=0, no se activado ningun sensor luego daremos una salida S)
 
 !x!y --> s0 
                etc...

 total que al final tenemos cuatro salidas que podemos conectar a cuatro
timbres distintos de tal manera que cada pitidito sea un aviso distinto


        !x!y  --> (not x and not y) -> Pitido 1: Todo va bien
         x!y  --> ( x and not y) -->   Pitido 2: Nivel peligroso del agua.
          xy  --> ( x and y   ) -->    Pitido 3: Defcon 4!!!
         !xy  --> ( not x and y) -->   Pitido 4: Malfuncion...     

 De todas formas, os adjunto unos gifs sencillitos para que os vayais
familiarizando con las formas de las puertas  mas o menos comprendais como
va el circuito...( joder no querreis que lo haga todo en ASCII !!). Sin
embargo no estaria mal que os pillaseis por ahi un programa que se llama
Orcad, supongo que a partir de la version III valdra. Sirve para la
simulacion de circuitos digitales y ademas seran los formatos de los
siguientes archivos mandados salvo que se me indique lo contrario.


------------------------------------2.5.1 Puerta NAND


 Las puertas que ahora os pongo tienen la caracteristica de que funcionan
como conjunto universales esto es, pueden imitar las funciones del resto
de las puertas basicas (AND, OR, NOT)


A ello vamos..         __              _(FUNCION/PUERTA)_
                     _|   \
  NOT --->       x__| |    \
                    |_|    | o---- !x           
                      |   /
		      |__/

		   ___
               x__|    \
  AND --->        |     \        
                  |      |o----!(xy)--(NOT/NAND)-xy
               y__|    /                          
            	  |___/

 (Observacion = Si!, se utiliza una NAND para la negacion)

  OR  --->  
                  x-(NOT/NAND)-!x--	\
                                  (NAND/NAND)=>!(x+y) (NOT/NAND)--->x+y
                  y-(NOT/NAND)-!y--    /




------------------------------------2.5.2 Puerta NOR


Casi idem que la NOR
                       __              _(FUNCION/PUERTA)_
                     _|   \
  NOT --->       x__|  \   \
                    |_  |   >o---- !x           
                       /   /
		      |__/

		   ___
               x__|    \
  OR --->          \    \        
                    |    >o----!(x+y)--(NOT/NOR)-(x+y)
                   /    /
               y__|___ /                  
            	  

 ...se utiliza una NOR para la negacion...

  AND  --->  
                  x-(NOT/NOR) -!x--	\
                                    (NOR/NOR) =>!(xy) (NOT/NOR)--->xy
                  y-(NOT/NOR) -!y--    /



------------------------------------2.5.2 Extra - Puerta XOR


	Jeje, esta es la puerta que mas me gusta, puesto que es la mas 
utilizada en los circuitos de encriptacion, es mas yo diria que es la unica 
funcion valida en criptografia...
Bueno ahi va la tabla de valores:

	| x | y |XOR(x,y)
	-----------------         ____
        | 0 | 0 |   0           \ \   \
        | 0 | 1 |   1        --- \ \   \
        | 1 | 0 |   1            |  |   >-- XOR (x,y)
        | 1 | 1 |   0        --- / /   /
                                //____/


	Direis "menudo cachondo, y donde esta la criptografia?", pues ni mas 
ni menos que en la tabla de valores... me explico imaginemos que tenemos un 
numero, el 2 y queremos codificarlo con una clave ultra-segura que es el numero
1 de tal manera que la funcion cod(2,1)=numero codificado... siendo 2 la 
informacion sensible y 1 la clave ultra-secreta... veamos que se puede hacer 
con la puerta XOR...

   Recordamos 2= 10 en binario (1=MSB; 0=LSB) -> msg
	      1= 1 = 01 en binario 	      -> key

      Primer bit de nuestro msg --> 0 \
       					(XOR) => 1 -> LSB (crypt)
      Primer bit de nuestra key --> 1 /


      Segundo bit de nuestro msg --> 1 \
       					(XOR) => 1 -> MSB (crypt)
      Segundo bit de nuestra key --> 0 /

  Luego nuestro mensaje codificado es 11 en binario, 3 en decimal.

  Llegara un momento en el que queramos descodificar lo que hemos escondido... 
por que no vamos a utilizar la misma funcion? solo tenemos que poner nuestro 
mensaje encriptado como msg, y la misma key!... veamos:

      Primer bit de nuestro msg-Crip --> 1 \
       					  (XOR) => 0 -> LSB (original)
      Primer bit de nuestra key      --> 1 /


      Segundo bit de nuestro msg-Crip --> 1 \
       					   (XOR) => 1 -> MSB (original)
      Segundo bit de nuestra key      --> 0 /

    Tocoto, tocoto... el resultado ahora es 10b = 2d... que bueno, ahora solo 
tenemos que aplicarle un circuito generador de secuencias aleatorias, unos 
cuantos bits mas para que no adivinen facilmente nuestra clave (unos 510 mas) 
y ya esta ;). Bueno un dia de estos montaremos algo mas complicado que tenga 
que ver con el tema.




------------------3. Algo mas de matematicas.
		     ========================


	Bueno ahora que teneis los pantalones como una tienda de campa~a (con 
el expreso perdon del genero femenino) despues de haber leido lo de la puerta 
XOR; una de cal y de otra de arena os tengo que dar algo que os baje el 
hinchazon... ;).

	Os acordais del circuito de la presa? bueno si no os acordais os pongo 
aqui la salida que tenia el susodicho...

                                        x   |   y  || Estado | Valor OUT
					0	0	S0	00
Este estado es erroneo (pelig sin adv)->0	1	S1	11
					1	0	S2	01
					1	1	S3	10

	Ahora que tenemos mas claridad de conceptos podemos definir el valor 
correspondiente a S? como S1 y el valor OUT correspondiente como 11... para 
que asi el circuito pueda dar una salida correcta. Bueno lo que voy a intentar
explicar ahora es como reducir al minimo la cantidad de componentes de un 
circuito. Hombre, para un circuito chiquitin como este reducirlo es absurdo, 
pero en adelante os sera muy util para ahorraros un paston en descodificadores,
multiplexores... etc.

Definamos Z(x,y) como la funcion que determina el valor OUT cuando es 1,
si tenemos en cuenta todos los valores que puede tomar nos queda algo como:

Z1->define el MSB de la funcion valor OUT

  Z1=!xy + xy  -> Son las entradas que hacen que Z1 sea 1 (true)
  Z0=!xy + x!y -> Joer, me suena a cierta puerta por ahi... (XOR)

  Veamos, si utilizamos las propiedades matematicas con Z1 nos queda:

Z1=y(x+!x)= y(1) = y  --> puesto que OR (x,x!) = 1 = TRUE


Luego Z1=y
      Z0=XOR(x,y)

  y nos queda un circuito reducido tal que asi:


        x-----\
              XOR(x,y)----->Z0
        y_____/
	      \_______/----->Z1

 Ejem! un poco mas peque~o que el que os he pasado en el GIF...

AH! que lo quereis mas peque~o aun! OK!

Coged y ordenad de menor a mayor las salidas de Z es decir, 00, 01,...

De esta manera las salidas corresponden tal que:


                                        x   |   y  || Estado | Valor OUT
					0	0	S0	00
Este estado es erroneo (pelig sin adv)->0	1	S1	01
					1	0	S2	10
					1	1	S3	11


Z1=x
Z0=y

 Mas facil imposible.  Mas facil imposible?. Naaa, cuando veamos 
descodificadores vereis una manera de empalmarlo todo.



------------------------------------3.1 Mapas de Karnaugh



  Todo lo que acabo de decir es muy bonito, pero que pasa si teneis una tabla
de verdad para entradas  x3, x2, x1, x0? tendriais 2^4=16 posibles 
combinaciones (estados), lo cual pondria jodidas las cosas si quereis empezar
 a reducir "por la cuenta de la vieja". Para eso se inventaron los mapas de 
Karnaugh.

  Estos mapas consisten en mapas con 2^x casillas (tantas como posibles 
combinaciones haya) y en unas coordenadas que solo se modifican en un bit por 
cuadrado. Ahora lo vereis mas claramente.

Tenemos la siguiente funcion:
              ---
              \
Z(x2,x1,x0)=  /__ (0,3,7) 

   [Nota: que significa esto?, bueno en realidad como estamos tratando
          matematicamente todas las operaciones con valores binarios, 
          empleamos 
          el simbolo sumatorio (la epsilon hecha en ascii) para 
          representar que se estan sumando (haciendo la OR) con los 
          valores que forman en binario el 0(!x2!x1!x0), el 3 (!x2x1x0)
          y el 7 (x2x1x0), recordad que el valor que se le da a una 
          variable negada !x es igual a 0(false) y que la dada a una 
          variable no negada es igual a 1 (true)
                                                                     ]

Luego Z(x2,x1,x0)=!x2!x1!x0 + !x2x1x0 + x2x1x0

  En este caso podriamos reducirlo a mano, pero realmente no me da la 
gana osea que creamos un mapa de Karnaugh (uf, maldito ascii, cuando editaran 
SET en pdf exclusivamente :))

 [Daemon: Ya es suficiente trabajo sacarla en Ascii, creeme. ]


                      Valores de x1x0   			
                      ---------------

                        00   01    11    10
                     |-----------------------|
		   0 |    0|    1|    3|    2|
                     | o   |     |  o  |     |
  Valor de    x2     |-----------------------|
                   1 |    4|    5|    7|   6 |
                     |     |     |  o  |     | 
                      ------------------------


      Como vemos cada casilla representa el numero en decimal que indica la 
concatenacion de la parte izquierda con la de arriba. Por ejemplo, la esquina
 inferior derecha tiene el valor 6, puesto que ahi x2=1, y x1x0 tiene el 
valor = 10 es decir x1!x0. Luego la expresion que representa es x2x1!x0 
que es lo mismo que 110 = 6 en decimal.

        Bien y como reducimos segun los mapas de Karnaugh? Pues hay una serie
de reglas basicas.

   1) Siempre pillar grupos consecutivos cuyo tama~o sea potencia de 2:
       2,4,8,16,32...
   2) No se pueden coger en diagonal (puesto que no tienen ningun elemento en
      comun)
   3) Si se puede dar la vuelta al mapa, es decir, imaginarselo como un donut,
      de esta manera podriamos pillar el siguiente grupo (6,4) o (2,0) o
      incluso (6,4,2,0)
   4) Los recuadros que dibujemos deben tener en cada casilla la o, es decir
      no vale coger recuadros con celdas vacias.
   5) Una celda marcada con o se puede coger varias veces.
   6) Cuanto mas grandes sean los recuadros mejor.
   7) El numero de celdas sera 2^x siendo x el numero de variables de entrada.

      Ahora bien, cual es la reduccion real? Pues miremos nuestro ejemplo
y como hemos marcado con o. Solo tenemos dos grupos a coger que contengan o's
consecutivos el (3,7) y el (0) que no es reductible. Luego nos centramos en 
el (3,7).

Si nos fijamos en los ejes los numeros en los que coinciden ambos son x1 y x0,
luego la funcion reducida sera:

Z(x2,x1,x0)=!x2!x1!x0 + x1x0 ;




  Vamos a poner otro ejemplo, ahora imaginemos que queremos reducir la funcion
              ---
              \
Z(x2,x1,x0)=  /__ (0,2,3,6,7). 


Z(x2,x1,x0)=!x2!x1!x0 + !x2x1!x0 + !x2x1x0 + x2x1!x0 + x2x1x0 



  El mapa de Karnaugh queda tal que asi: 


 

                      Valores de x1x0   			
                      ---------------

                        00   01    11    10
                     |------------------------
		   0 |    0|    1|    3|    2|
                     | o   |     |  o  |  o  |
  Valor de    x2     |------------------------
                   1 |    4|    5|    7|   6 |
                     |     |     |  o  |  o  | 
                      ------------------------

  Cogemos el grupo (3,2,7,6) y el grupo (2,0) [donut rlz].

 (3,2,7,6) = x1 --> Es el unico valor que se repite en las 4 casillas
 (2,0)     = !x2!x0

  La funcion queda reducida a Z(x2,x1,x0)=x1 + !x2!x0. Amen.

------------------------------------------------------------------------------

  Bueno basta por este numero. En el proximo os garantizo muchas menos 
formulitas y mas ca~a asi como mas circuitos (esta vez en Orcad que los gifs 
y el ascii me matan). Para que vayais abriendo boca os recomiendo un libro:

  Fundamentos de Sistemas Digitales (6a Edicion)
  T.L. Floyd
  Prentice Hall

En el proximo numero, descodificadores, codificadores, multiplexores, ROMs,
PLA, etc. e incluso algun que otro circuito mas grande. Recordad que este 
capitulo era introductorio. Si habeis sobrevivido a el, es que valeis para 
este mundo porque una vez que hayais pillado esto no habra circuito que se os
resista.

                                    We are all living in a yellow submarine


 							jnzero

  jnzero@phreaker.net   --> Solo mujeres.

  flt_hack@phreaker.net --> si alguien quiere colaborar con mi grupillo...
                             
  pon_aqui_tu_nick@127.0.0.1--> criticas, etc.



*EOF*