Copy Link
Add to Bookmark
Report
SET 022 0x0c
-[ 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*
