Buscador

sábado, 9 de diciembre de 2017

Reparación Korg mini kaoss pad 2 bricked / brick ( mini-KP2 unbrick )

Este tutorial se escribirá en castellano e un intento de inglés. Si quieres leerlo en castellano, pulsa control+f y busca "Tutorial castellano".
This tutorial will be written in Spanish and in a kind of English. If you want to read it in English, press control + f and search "English tutorial".




Tutorial castellano


 En este tutorial se explicará cómo reparar el aparato mini kaoss pad 2 de la marca korg si le cargaste un binario que no era y se te quedó brickeado ( no arranca ).

1) Lo primero que haremos será abrir el aparato y dejar la placa base accesible para trabajar con ella.



2) Seguidamente, le desoldamos la memoria flash que queda justo detrás del jack de alimentación, su código en la placa es IC3, la memoria es una MX25L1606E.



3) Le cargamos el binario modificado ( se puede descargar al final de este post ). Para este paso necesitarás un programador para la memoria flash. Una opción es usar un programador universal como el que uso yo ( minipro TL866 ) aunque también puedes usar un arduino, pic o cualquier micro que tengas a mano y programarle un código para subirlo.

minipro tl866



El binario no es el mismo que el que da el fabricante, se modificó para que pudiese funcionar correctamente. Se borró de la posixión 0x00 hasta la 0xFF. Ese bloque lo usa el procesador para comprobar que esté todo bien. El código que buscamos (para pegar en la posición 0x00 ) empieza con 0x01 0x50.... También hay que rellenar con 0xFF el final del binario hasta llegar a la posición  0x1F00FF. Empieza desde la última posición hasta llegar a la posición 0x1F00FF. Afortunadamente ya lo modifiqué, así no tendrás que hacerlo, sólo tendrás que cargarlo.





4) Una vez cargado el binario en la flash ( sin que dé ningún tipo de error en la comprobación del binario cargado ) volvemos a soldar la memoria flash y a montar de nuevo el aparato.

5) Ahora tendrás que mantener pulsado el botón de power un rato, si no logra encender, mantén pulsado el botón de power y el botón de vol - hasta que arranque, ten paciencia, arrancará. A mi me tardó unos 5 segundos en arrancar.



English tutorial


In this tutorial I'm gonna explain how to fix the device mini kaoss pad 2 of korg's brand if you loaded a wrong binary file and it's bricked ( it won't turn on ).


1) The first step we're gonna do will be to open the device and take the pcb out of the enclosure to let us work with it properly.



2) Now we're gonna unweld the memory flash that it's placed behind of the power DC jack, it's code on the PCB is IC3, the memory is the MX25L1606E.



3) On this step we're gonna load the modified binary file ( you can download it at the end of this post ). For this step you will need a flash programmer. An option could be to use a universal programmer like the one I'm using ( minipro TL866 ).
Although you can use an arduino, pic or whatever you have at hand, just write some code to load the binary on the memory.

minipro tl866





The binary file is not exactly the same that the manufacturer gives to you, this was modified to work properly.
It was removed from position 0x00 to 0xFF. This chunk of memory it's used by the processor to check if the binary file is working properly. The part of code we're looking for (to put in 0x00's place) begins with 0x01, 0x50, etc.
It's also needed to fill with 0xFF the end of the binary file untill 0x1F00FF's position. Start from the the last position untill you reach 0x1F00FF's position.
Fortunatelly I did those modifications so you won't need to do it, just download it and load it.





4) Once you loaded the binary file inside the flash memory ( without errors on the checking process) weld the memory again on the pcb and assemble again the device.

5) Now you will have to press the power button for a while. If it doesn't turn back, press the power button and the vol - at the same time untill it turns on. Be patient, it will turn on. I needed like 5 seconds to turn on the device.

Descarga binario / Binary download




+info

jueves, 30 de noviembre de 2017

LCD SmartWatch U8 ( pinout + datasheet )

En esta entrada voy a colgar el pinout + datasheet y  explicar un poco un proceso de ingeniería inversa que le hice a un display de un smartwatch chino ( U8 ).

El tamaño del display es de 1.4" y tiene un código posterior como el siguiente:
F0-14TG013-01 0G.

Puede que en vez de ceros, sean la letra o, la verdad cuesta un poco leer. Estuve buscando por internet si había alguna información con ese código, desgraciadamente no encontré nada.





El display tiene 18 pines, los cuales son:

1   - GND
2   - K (cátodo backlight)
3   - A (ánodo backlight)
4   - GND
5   - #RESET ( se resetea con 0 )
6   - DATA_COMMAND
7   - MOSI
8   - SCK
9   - VCC
10 - VCC
11 - #CS ( se activa con 0 )
12 - GND
13 - NC ( no connected )
14 - NC
15 - NC
16 - NC
17 - GND
18 - GND

Imagen de test


La tensión del display son 3.3V y la tensión del backlight son 3V. El backlight consume una corriente de entre 20 a 40mA, así que es necesario ponerle una resistencia en serie para limitar la corriente que le atraviese.

El protocolo que usa el display es el SPI y el driver que usa es el ST7735. No usé un spi por hardware, lo programé por software, así os será más fácil de adaptar a vuestro micro. El formato de color es R5G6B5 y el formato es little endian.

(Descarga el datasheet al final del post)

Aquí os dejo un código de ejemplo, no es para arduino ( lo hice para un ARM modelo STM32F446RTE6 ) pero igualmente puede usarse, sólo es cuestión de cambiar las macros del código por los pines correspondientes. Muy importante, limitar la tensión del arduino a 3.3V con algunos divisores de tensión.






//----------------------------------------------------------------------------------------------code

void Pantalla_init()
{
    LCD_init_pins(); // aqui inicio los pines
   
    LCD_ON; // aqui doy tension a mi display ( se controla con un mosfet )
    BACKLIGHT_ON; // enciendo el backlight
    LCD_DISABLE; // CS = 1
   
    HAL_Delay(50); // delay 50ms
    RESET_LCD; // reset -> reset = 0 , delay 1, reset = 1
    HAL_Delay(10); // delay 10ms
   
    LCD_ENABLE; // CS = 0
    lcd_protocol_init(); // aqui esta el protocolo para configurar el display ( mirar abajo)
}

inline void lcd_protocol_init()
{
    LCD_WriteCommand(SLEEP_OUT_BOOSTER_ON); // envio 0x11

    LCD_WriteCommand(PIXEL_FORMAT); // envio 0x3A
    LCD_WriteData(FORMAT_16_BIT); // envio 0x05
 
    LCD_WriteCommand(DISPLAY_ON); // envio 0x29
}

void LCD_WriteCommand(char dada)
{
    LCD_COMMAND; // pin DATA_COMMAND = 0
    LCD_Write(dada);
}

void LCD_WriteData(uint8_t dada)
{
    LCD_DATA; // pin DATA_COMMAND = 1
    LCD_Write(dada);
}

inline void LCD_Write(uint8_t dada)
{
    char i;
   
    for( i=0; i<8; i++)
    {
        LCD_CLK_LOW; // pin clock 0
   
        ( ((dada & 0x80) == 0x80) ? LCD_DATA_HIGH : LCD_DATA_LOW); // if bit == 0x80, pin MOSI = 1, else MOSI = 0
       
        dada <<= 1; // shift dato 1 a la izquierda
        LCD_CLK_HIGH; // pin clock 1
    }
}

inline void LCD_WriteData_16(uint16_t dada)
{
    LCD_WriteData(dada>>8);
    LCD_WriteData(dada);
}


void LCD_donarTamany(uint8_t x,uint8_t y,uint8_t ample,uint8_t altura) // le damos una posicion y tamaño para pintar la imagen
{
    LCD_WriteCommand(COLUMN_ADDRESS_SET); // envio 0x2A
    LCD_WriteData_16(x);
    LCD_WriteData_16( (x + ample-1) );

    LCD_WriteCommand(ROW_ADDRESS_SET); // envio 0x2B
    LCD_WriteData_16(y);
    LCD_WriteData_16( (y + altura-1) );

    LCD_WriteCommand(MEMORY_WRITE); // ja podem pintar
}


void LCD_Fill(int x,int y,int ample,int altura,uint16_t color) // para pintar toda una zona del mismo color
{
    int i,j;
    LCD_donarTamany(x, y, ample, altura);
   
    for(j = 0; j < (ample*altura); j++)
    {
        LCD_pintar_pixel(color);
    }
}


void LCD_PintarImatge( uint8_t x, uint8_t y, uint8_t ample, uint8_t altura, uint16_t *color ) // nos permite pintar una imagen, se le pasa un array con la imagen de colores
{
    uint32_t i = 0;
    LCD_donarTamany(x, y, ample, altura);
   
    for(i = 0; i < (ample*altura); i++)
    {
        LCD_pintar_pixel(color[i]);
    }
   
}


inline void LCD_pintar_pixel(uint16_t pixel)
{
    LCD_DATA;
    char i;
   
    for( i=0; i<16; i++)
    {
        LCD_CLK_LOW;
   
        ( ((pixel & 0x01) == 0x01) ? LCD_DATA_HIGH : LCD_DATA_LOW);
       
        pixel >>= 1;
        LCD_CLK_HIGH;
    }
}


//----------------------------------------------------------------------------------------------code

Datasheet ST7735

Descarga código aquí













+info

martes, 31 de octubre de 2017

Control acceso ordenador (login pc) mediante RFID


El link de descarga está al final del post.

En esta entrada aprenderemos cómo usar un arduino pro micro para permitirnos acceder a nuestra cuenta de usuario de nuestro ordenador.

Los materiales que usaremos:

· Arduino pro micro ( con un Arduino leonardo también te serviría )
· Módulo RFID-RC522
· Protoboard + cables
· Regulador de 3'3V  ( para el módulo RFID que funciona a menor tensión ).



Nota 1: La IDE de arduino me lo detecta como Leonardo, lo programé como tal y me funcionó correctamente.

Nota 2: Mi arduino pro micro no tiene regulador de 3'3V, si el tuyo lo lleva, no te hará falta el regulador de 3'3V que sale en la lista.








Diagrama de conexión

Necesitarás importar la libreria de RFID desde la IDE de Arduino. Abrimos nuestra IDE de Arduino y vamos a: Sketch -> Include library -> Manage libraries...


Se te abrirá una ventana como la anterior, en el buscador ( donde pone " Filter your search... " busca:   rc522  e instala la librería.


En mi caso ya la instalé por eso me sale inhabilitado el botón de instalación.

Una vez instalada la librería, ya podrás usar el código fuente ( te recomiendo reiniciar la IDE de Arduino ).

Notas: El arduino pro micro que usé, tenía que reconectarlo cada vez que subía el sketch para que me detectara el USB. Si al cargarlo ves que no te escribe el password, prueba a reconectarlo.









Descarga el código aquí





+info

domingo, 29 de octubre de 2017

Tutorial fabriación CPU desde 0: Módulo 01 - Clock, reset y FA

(En construcción)

Introducción


Empezamos una nueva serie donde crearemos paso a paso nuestra propia CPU, para ello nos valdremos de puertas lógicas y de algún que otro FPGA  y/o CPLD.

El motivo de usar FPGA y/o CPLD en vez de puertas lógicas será para mayor comodidad a la hora de crear algunas partes de la CPU ( por ejemplo,  si se quisieran añadir nuevas instrucciones o hacerlas más rápidas, con puertas lógicas sería un infierno ).

Nota: los FPGA y CPLD son, a grandes rasgos, circuitos que permiten programarles el comportamiento de elementos lógicos como una puerta AND, un multiplexor, etc. No funcionan igual que un procesador aunque pueden existir en el mercado algunas FPGA que integran procesadores. A diferencia de la programación convencional, para programar un FPGA o un CPLD, es necesario describir el hardware ( se le explica qué entradas y salidas tiene y cómo se comportarán ).

Es por ello que en estos tutoriales los partiremos en unos bloques, uno por cada módulo de la CPU. Dicha CPU estará compuesta de PCBs apiladas una encima la otra, formando una especie de "sandwich", conectándose entre sí. 

Dicho proyecto añadirá algunas partes que no son propias de una CPU, como por ejemplo, un bloque de fuente de alimentación y módulos de entrada/salida (I/O) como un teclado y una salida vga para tener "algo que funcione" y poderse mostrar cosas por pantalla.

En este proyecto no se busca crear un gran procesador ni tampoco el más eficiente, es por ello que los diseños mostrados son totalmente mejorables y toda sugerencia será bienvenida.


Información para nerds

F: 8MHz ( seguramente ampliable )
Bus de datos: 8 bits
Tipo de arquitectura: Von Neumann
Nº de IRQs externas: 8

Aclaraciones

Antes de entrar en materia, necesitamos explicar algunos conceptos de los procesadores. En la medida de lo posible, se intentará hacer de la forma más amena posible y si durante el transcurso de la nota aparecen nuevos términos, se intentarán explicar todos y cada uno de ellos. 
Por favor, si hay algo que no entiendas, déjamelo en los comentarios e intentaré añadirlo para futuros/as lectores/as.

Un procesador es un componente electrónico que, mediante instrucciones, se encarga de controlar los distintos módulos de un dispositivo, además de realizar algunas operaciones. Lo podríamos dividir en dos grupos:

· Realizar operaciones lógicas / matemáticas ( operaciones AND, OR, sumas, restas , etc ).
· Mover datos de una posición de memoria a otra.

Todo lo que ves en una pantalla como botones, sliders y demás, es información binaria, que mediante un código, interpreta esa información de una forma u otra. ¿Qué quiero decir con esto? por ejemplo, si guardamos en memoria el número 127, ese número puede ser una coordenada XY de un botón, una coordenada de tu mouse, el número de tecla que pulsaste, el resultado de una operación matemática que hiciste o que un programa hizo, el color de un pixel en pantalla, la munición restante de un personaje del videojuego que estás jugando, etc.

El procesador no es quien decide el uso de esos datos, éste simplemete obedece a un código dado, el programador/a ( o sea, nosotros :P ) es quien le explicará al procesador el uso de cada dato en memoria y cómo lo ha de gestionar ( comunicándose mediante las instrucciones en ensamblador ).

Todo ( y cuando digo todo, es todo todo ) es visto por un procesador como una posición de memoria. Desde las coordenadas XY de tu mouse hasta tu impresora, todo ha de ser direccionable desde memoria ( que has de poder acceder mediante una dirección de memoria ). Más adelante veremos que hay disponibles una serie de "trucos" o "herramientas" que nos facilitarán la vida para no tener que movernos siempre números.

Nota: la imagen no corresponde con la realidad, es un simple ejemplo
 
Esto que a priori puede parecer confuso, veremos que nos aporta una gran flexibilidad ( si añadimos un nuevo módulo, no hay que cambiar toda la CPU, simplemente indicarle qué uso tendrán las nuevas posiciones de memoria y seguir usando las mismas instrucciones de ensamblador, sin necesidad de crear unas nuevas ).

Pero entonces... ¿todo está en la ram?. No exactamente, aunque sea "direccionable" ( que podemos acceder mediante una dirección ) no implica necesariamente que se encuentre la memoria ram. Esto quiere decir que físicamente hay partes que no están conectadas a la memoria ram, pero por comodidad, a nivel lógico ( a la hora de programar ) se interpretan como tal. 

Cuando empecemos a crear algunos módulos de la cpu se verá mucho más claro este punto, pero es importante remarcar que, cuando se ve un mapa de memoria como el mostrado arriba, donde aparecen desde los gráficos de la gpu hasta la impresora, no necesariamente están todos en el mismo sitio físico, aunque a la hora de programar nos pueda parecer que es así.





Conceptos básicos necesarios para este módulo

Transistor:

A grandes rasgos ( y para no complicarlo más de lo necesario ), un transistor funciona como un interruptor, sólo que en vez de controlarse con el dedo, lo hace con una señal eléctrica. Está formado por tres pines y uno de ellos sería la señal de control, los otros dos se conectan o desconectan entre ellos, permitiendo pasar la señal eléctrica o bloqueándola.
 

Nota: el transistor usado en el ejemplo es conocido como transistor NPN

En la imagen anterior, podemos ver un 0 y un 1 a la izquierda del transistor, representan si hay señal o no. A partir de ahora, cuando veas un 0 de esa forma, es un 0 lógico, eso quiere decir que representa " no señal " ( apagado ) y el 1  representa " señal " ( encendido ).

Se usarán muy pocos transistores en la cpu, lo que sí usaremos, serán las puertas lógicas ( que están formadas a partir de transistores ) para reducir la complejidad, tamaño y precio ), pero es necesario entenderlos para poder comprender mejor el funcionamiento de las puertas lógicas.

 
Puertas lógicas and, or, not:

Las puertas lógicas son un conjunto de transistores que forman un circuito lógico, existen varios tipos, de momento sólo explicaremos las que usaremos en este ḿodulo. Nos permiten realizar operaciones booleanas de suma, negación, etc.

Como imagino que no te habrá quedado muy clara mi explicación anterior, pasaremos a ver algunos ejemplos:

Puerta AND:


 La puerta AND sólo da como resultado 1 cuando todas sus entradas son 1.
Nota: si nuestra CPU funciona a 5 voltios como nivel lógico, el 1 valdría 5v, pero si trabajase a 3'3V, el nivel lógico sería de 3'3V.

Puede que ahora no le veas mucha utilidad, pero en un futuro verás como sí. Mediante puertas lógicas podremos crear circuitos que necesitemos para que, al cumplirse ciertas condiciones, dé como resultado una serie de salidas que necesitamos.

Nota 1: para crear circuitos lógicos medianamente complejos, es muy útil aprender a crear mapas de karnaugh. Nos permitirán de forma simple, generar las puertas lógicas que necesitamos mediante las entradas que queremos y las salidas que buscamos.

Nota 2: La puerta AND no está limitada a dos entradas, hay puertas and de 4 y más entradas.
 

Puerta OR:


La puerta OR nos dará como resultado un 1 siempre y cuando alguna de sus estradas esté activa (  no importa la combinación, si una de sus entradas se activa, la salida también se activará ).

Nota 1: "1 OR 1" no da 2 porque no funciona igual que la suma a la que estamos acostumbrados. Si lo prefieres, cambia los 1 y 0 por " true " y " false ".

Nota 2: Como ocurre con la puerta AND, la puerta OR tampoco está limitada a 2 entradas.


Puerta NOT:


Esta última puerta es bastante simple, su función es invertir la señal lógica. Las puertas NOT sólo tienen una entrada, si se quiere una NOT de varias entradas, podría usarse una NAND ( de momento no la explicaremos ).



Nota: Se anima al lector/a a investigar sobre cómo se crea una puerta lógica a partir de transistores para ver la relación que hay entre ambos.




Cristal de cuarzo:

El cristal de cuarzo es un componente electrónico que nos dará una frecuencia de trabajo para nuestra CPU. Podríamos entrar en detalles mucho más técnicos sobre éstos pero no nos será muy necesario para nuestro proyecto, con entender que al aplicarle una tensión, nos oscilará a una frecuencia ( la llevan escrita en el encapsulado ) nos es suficiente por ahora.

Más adelante veremos que, mediante unos circuitos llamados contadores ( se crean con puertas lógicas ), podremos ir contando los " ticks " del reloj y así, poder realizar las operaciones correspondientes.

Distintos encapsulados de cristal de cuarzo




Registros:

Los registros son pequeñas memorias donde dejamos datos temporalmente. Por ejemplo, un registro que use nuestra CPU para dejar el resultado de una operación matemática. Hay varios tipos de registros y algunos, como comentamos anteriormente, no están de forma física unidos entre sí. Algunos tipos de registros podrían ser:

· Propósito general: Te permiten guardar el dato que quieras, desde un número de una operación a una dirección de memoria.

· Específicos: Los puede usar la CPU para indicar estados de partes específicas ( posición de el resultado de una operación ( si fue negativa, cero, etc.), siguiente instrucción a ejecutar,  etc).

Nota: cuando creemos nuestra CPU, también crearemos los registros, que nos permitirán interactuar con nuestra CPU. Normalmente, el tamaño de un registro ( medido en bits ) es igual que la arquitectura de la CPU. La nuestra será de 8 bits, eso quiere decir que nuestros registros tendrán un tamaño de 8 bits.


Sistema binario:

No quiero meter mucha teoría con el sistema binario, os enseñaré una forma muy rápida que uso para calcular los números sin necesidad de usar divisiones u otro sistema que implique "demasiado cálculo". El sistema binario es otra forma de representar los números, pero a diferencia del sistema decimal ( diez ), en el binario se usan dos dígitos.




En la imagen anterior, puede verse una forma de calcular el número binario, simplemente se suman los valores en azul donde hay el digito 1. En el primer ejemplo, 2 + 16 se sumó así porque si vemos los números en azul ( potencias de dos ) y después los unos de color verde, coinciden con el  2 y el 16 en azul. El resto de posiciones ( 1, 4, 8, 32 y 64 )  al tener ceros, no se suman.


 En el sistema binario por ejemplo, el número 3 sería 11  y para pasar al número 4, añadimos un nuevo dígito ( 100 ), si probáis estos dos números con la tabla superior, veréis como coinciden. Los ceros de la izquierda no son importantes pero los de la derecha son totalmente necesarios.

Nota: Es muy importante que se domine el sistema binario de forma fluida, nos será muy útil más adelante para la creación de algunos módulos de la CPU ( tampoco es necesario saber hacer divisiones o raices cuadradas en binario, pero sí saber pasar de binario a decimal y viceversa ).
 

Multiplexor:

Un multiplexor está compuesto de puertas lógicas ( como mostraremos a continuación ) y es un componente con muchas entradas, una salida y unos pines de control ( para seleccionar la entrada ). Podríamos imaginarlo como un selector:



El número en binario que le demos a los pines de control, nos conectará la entrada con la salida ( ignorad hacia dónde apuntan las flechas, la dirección sería opuesta ).

Nota: Sólo puede conectar una entrada con una salida.



Entrando en materia

El procesador que haremos, constará de varios módulos, en este punto sólo se numerarán pero no se explicarán ( se harán en cada entrada correspondiende a dicho módulo ).

· FA
· Clock
· Reset
· Unidad de control ( UC )
· IRQs ( interrupciones )
· Entradas / Salidas ( I/O )
· ALU
· Stack
· Registros

No os preocupéis por no entender qué significado tienen los puntos anteriores, sólo con saber que existen nos vale por ahora. En esta entrada hablaremos del clock, reset y la FA.






Clock:


El sistema de clock, contará con opción de usar un clock interno o externo:




En el dibujo anterior, podemos ver que consta de tres entradas: 
· Señal clock interno ( U4, pin 3 ).
· Registro "Extern_Intern" ( nos permitirá seleccionar mediante instrucciones de ensamblador si queremos usar el reloj interno o externo ).
· Señal clock externo ( U3B, pin 4/5 ).

Lo que vemos en el dibujo anterior es un multiplexor que tiene 2 entradas , 1 pin de control y una salida:

- control = 0 --> clock interno
- control = 1 --> clock externo

El reloj interno será de 8MHz. Aunque parezca poco comparado con nuestros procesadores ( de varios GHz ) nos servirá para este proyecto. Hemos de recordar que no buscamos competir contra intel :P

Nota: El componente U4 es un cristal de cuarzo,  que nos da una frecuencia fija de 8MHz.


Reset:




Este circuito nos permitirá resetear toda la CPU justo en el instante que se alimenta. ¿Por qué se hace esto?, para asegurarnos que conocemos en qué estado empiezan los distintos módulos, de lo contrario podría ocurrir que un registro quede con una carga residual y no haya el dato que nos pensamos que contiene ( por ejemplo, el contador de programa y empezar en una instrucción equivocada ).

El pin " Reg_RST " es un pin que irá conectado a un registro especial, que nos permitirá resetear la CPU por software.

El componente J2 ( donde pone Reset ) es un conector para el pulsador de reset. El componente R5 junto al componente C8 permiten el reset inicial de forma automática. El condensador ( C8 ) tardará un tiempo en cargarse, mediante la resistencia (R5) que tiene en serie y su propia capacidad se ajusta el tiempo de carga. Durante dicho tiempo, el pin 2 del componente U3A ( este componente tendría que empezar a sonarte ya ;) ) lo tendrá a 0, generando en la salida un 0 lógico. 

Nota 1: La señal de reset es negada, eso quiere decir que " se activa " mediante un 0 lógico. Por lo tanto, para resetear nuestra CPU, aplicaremos un 0 lógico.

Nota 2: Vcc y GND son los dos terminales de alimentación, en este caso, Vcc valdrá 3.3V. Nuestra CPU funcionará internamente a 3.3V y externamente a 5V.

FA:

La fuente de alimentación contiene varios circuitos, empecemos con el de control:



En la imagen anterior podemos ver un circuito que nos permite apagar la CPU mediante software ( Registro_FA_On_Off ) al aplicarle un 0 lógico. El componente J1 es donde va el pulsador para encender la CPU, éste activa el transistor Q2 ( éste se conoce como MOSFET, es un poco distinto al NPN, se controla mediante tensión y no corriente ). A mano derecha podemos ver una etiqueta llamada IRQ_On_Off, cuando el botón sea pulsado, dará un 1 lógico en ese pin, pudiendo detectar así la CPU si alguien pulsó el botón ( usado cuando se pida por hardware apagar la CPU ).

Nota 1: Este módulo (FA) no se integra en las CPUs comerciales, se gestiona de otras formas.

Nota 2: La CPU se alimentará con un transformador de 12 voltios, conectado en la etiqueta " 12V_input ".





En la imagen anterior, podemos ver dos reguladores, uno que transforma los 12 voltios a 5 y el otro a 3'3 voltios. Los usaremos para alimentar los dos bloques de la CPU. La interna funcionará con 3.3v y la externa con 5v.

Nota 1: Los reguladores anteriores son conmutados, eso quiere decir que no tienen tantas pérdidas a la hora de transformar la energía, podríamos imaginarlo como un interruptor que se cierra y abre tan rápido que sólo deja pasar la tensión que quiere. Hay otras formas de regular la tensión,  como la forma lineal, que normalmente se usa un transistor de potencia para limitar la tensión , disipando dicho componente el resto de energía que no se use.

Nota 2: Para más información, buscar sobre fuentes lineales y fuentes conmutadas.




Puntos pendientes:
· Diseñar y fabricar PCB
· Soldar componentes y debuggear PCB

+info
-