Autor Tema: Problemas con TFT  (Leído 2570 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7854
Problemas con TFT
« en: 22 de Octubre de 2014, 15:15:18 »
Hola, hace poco compre mi primer placa con procesador ARM de TI, con un TM4C1294xxx

Hasta ahora fue posible hacer todo lo que quise, pero hace poco compre un TFT desde dealextreme (http://www.dx.com/es/p/arduino-compatible-3-2-tft-lcd-touch-sensor-screen-module-145725#.VEfzjPmG8Rw), supuestamente con controlador SSD1298 y estoy intentando hacerlo andar. pero me encuentro con algunos problemas

Antes de conectarlo estuve portando el driver desde la libreria UTFT para arduino y su shield, para que pueda usarlo con mi placa.

El driver no termina siendo nada distinto de lo que hay dando vueltas, las rutinas de inicializacion son todas muy parecidas ( identicas o hay algunas mas simples, tiene la misma inicializacion que posee la libreria de suky que hizo para su Pic32 ) En fin por las dudas pongo la rutina aqui.

Código: [Seleccionar]
void initTFT(void) {

// Inicializacion de puertos

SysCtlPeripheralEnable(TFTPORT_LB_ENA);
GPIOPinTypeGPIOOutput(TFTPORT_LB, 0xFF);
GPIOPinWrite(TFTPORT_LB, 0xFF , 0);

SysCtlPeripheralEnable(TFTPORT_MB_ENA);
GPIOPinTypeGPIOOutput(TFTPORT_MB, 0xFF);
GPIOPinWrite(TFTPORT_MB, 0xFF , 0);

SysCtlPeripheralEnable(TFTPORT_CONT_ENA);
GPIOPinTypeGPIOOutput(TFTPORT_CONT, 0xFF);
GPIOPinWrite(TFTPORT_CONT, 0xFF , 0xFF);

// Fin de configuracion

// Comienzo de configuracion del TFT

GPIOPinWrite(TFTPORT_CONT, RST , 0xFF);
SysCtlDelay((5e-3)*CLKSPEED/3);
GPIOPinWrite(TFTPORT_CONT, RST , 0x00);
SysCtlDelay((15e-3)*CLKSPEED/3);
GPIOPinWrite(TFTPORT_CONT, RST , 0xFF);
SysCtlDelay((15e-3)*CLKSPEED/3);

// ******** Control de alimentacion **********
TFT_W_CyD(0x00,0x0001); // Registro Oscilador - Comienza a funcionar
TFT_W_CyD(0x03,0xA8A4); // Registro Power Control 1 - Step-up cycle (8 color) a Fosc/4 - Step-up factor +5 -4 - Step-up cycle (262k color) a Fosc/4 - Cantidad de corriente medium to large
TFT_W_CyD(0x0C,0x0000); // Registro Power Control 2 - Ajuste de VCIX2 voltaje a 5.1V
TFT_W_CyD(0x0D,0x080C); // Registro Power Control 3 - Ajuste de Vlcd63 = Vref x 2.570  (0x00C)
TFT_W_CyD(0x0E,0x2B00); // Registro Power Control 4 - VcomG = 1 - Amplify Vcom = VLCD63 * 0.93
TFT_W_CyD(0x1E,0x00B0); // Registro Power Control 5 - nOTP = 1 para poder setear VcomH, VcomH = VLCD63 * 0.9
TFT_W_CyD(0x01,0x2B3F); // Registro Driver Output Control - REV = 1 (reverse) - Retention capacitor on common (Cs) - Orden <B><G><R> - Gate scan order G0 a G219 - Direction G0 to G219
TFT_W_CyD(0x02,0x0600); // Registro LCD-Driving-Waveform Control - B/C = 1 and EOR = 1, the odd/even frame-select signals and the N-line inversion signals are EORed for alternating dr
TFT_W_CyD(0x10,0x0000); // Registro Sleep mode - Fuera del sleep
SysCtlDelay((30e-3)*CLKSPEED/3);
TFT_W_CyD(0x11,0x6070); // Registro Entry Mode - Color Mode = 65k color(RRRRRGGGGGGBBBBB) - Write RAM from generic interface - Display from RAM and Generic data
TFT_W_CyD(0x05,0x0000); // Registro Compare register - q no se compare nada xD
TFT_W_CyD(0x06,0x0000); // Registro Compare register -
TFT_W_CyD(0x16,0xEF1C); // Registro Horizontal Porch - Pixel por linea = 239 - No. of clock cycle of DOTCLK = 30 (POR)
TFT_W_CyD(0x17,0x0003); // Registro Vertical Porch - No. of clock cycle of HSYNC = 4 (POR) - Delay en 1 cycle desde el ultimo VSYNC
TFT_W_CyD(0x07,0x0233); // Registro Display Control - vertical scroll is performed in the 1st screen by taking data VL17-0 in R41h
// ******** Configuracion del TFT  ***********
TFT_W_CyD(0x0B,0x0000); // Frame cycle control
TFT_W_CyD(0x0F,0x0000); // Gate scan start position
TFT_W_CyD(0x41,0x0000); // Vertical Scroll control(1)
TFT_W_CyD(0x42,0x0000); // Vertical scroll control(2)
TFT_W_CyD(0x48,0x0000); // First Window start - Una sola ventana de 0 a 319
TFT_W_CyD(0x49,0x013F); // First Window end
TFT_W_CyD(0x4A,0x0000); // Second Window start
TFT_W_CyD(0x4B,0x0000); // Second Window end
TFT_W_CyD(0x44,0xEF00); // Horizontal RAM address position
TFT_W_CyD(0x45,0x0000); // Vertical RAM address position start - De 0 a 319
TFT_W_CyD(0x46,0x013F); // Vertical RAM address position end
// ******** Registros de correccion de gamma ********
TFT_W_CyD(0x30,0x0707);
TFT_W_CyD(0x31,0x0204);
TFT_W_CyD(0x32,0x0204);
TFT_W_CyD(0x33,0x0502);
TFT_W_CyD(0x34,0x0507);
TFT_W_CyD(0x35,0x0204);
TFT_W_CyD(0x36,0x0204);
TFT_W_CyD(0x37,0x0502);
TFT_W_CyD(0x3A,0x0302);
TFT_W_CyD(0x3B,0x0302);

TFT_W_CyD(0x23,0x0000); // Seteo de mascaras de RAM
TFT_W_CyD(0x24,0x0000); // Seteo de mascaras de RAM
TFT_W_CyD(0x25,0x8000); // Seteo de frecuencia de cuadros
TFT_W_CyD(0x4f,0x0000); // Set GDDRAM Y address counter
TFT_W_CyD(0x4e,0x0000); // Set GDDRAM Y address counter
TFT_W_Command(0x22); // Direccion de RAM

}

La funcion TFT_W_CyD manda un comando y luego un dato igual que todos los demas drivers, el mayor problema con el que me encuentro es que cuando utilizo esta funcion:

TFT_W_CyD(0x07,0x0233);

Puedo activar cualquier bit de ese registro, pero cuando activo el bit DTE, la pantalla pasa de un color uniforme a una lluvia de puntos de colores.
De no activarlo me queda de un color uniforme pero no me permite mostrar nada en pantalla.

Citar
DTE: When GON = “1” and DTE = “0”, all gate outputs become VGL. When GON = “1” and DTE = “1”, selected gate
wire becomes VGH, and non-selected gate wires become VGL.

Foto de mala calidad mostrando como queda.


Intente usar el proceso de inicializacion que ofrece el datasheet - pag 72.
http://aitendo3.sakura.ne.jp/aitendo_data/product_img/lcd/tft2/M032C1289TP/3.2-SSD1289.pdf

Y aun asi cuando activo ese bit especifico me encuentro con el mismo resultado.
Ya no se si me confundi de controlador, o si tengo mal configurado mi rutina de inicializacion

Edit:

Acabo de leer el registro 00h y me da exactametne el valor que dice el datasheet 8989h
Encontre la libreria que usa coocox http://www.coocox.org/repo/b84dc262-606c-478c-b06d-c56c398f622b/src/stm_lib/src/GLCD.c.htm
Y note que usa distintas configuraciones segun el ID que provee este registro, probe la inicializacion con ese tipo de ID y aun asi sigo con el mismo problema.

Note que a pesar que queda asi la pantalla al seguir adelante con la inicializacion los demas registros siguen funcionando ya que se modifica el gamma y es visible en la pantalla.

Aunque me falto mencionar, ya revise todas las señales de control y se activan como se deben.
« Última modificación: 28 de Octubre de 2014, 00:34:53 por KILLERJC »

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7854
Re: Problemas con TFT
« Respuesta #1 en: 22 de Octubre de 2014, 20:49:58 »
Bueno perdon a todos pero estaba correcta la inicializacion
Tenia un problema en la configuracion de la direccion de RAM  para rellenar la pantalla

Ahora Lo unico es que tarda locuras para completar un barrido :/ y rellenar enteramente la pantalla, nada parecido a lo que vi en videos, ahora me queda resolver esa parte.

Desconectado Suky

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 6759
Re: Problemas con TFT
« Respuesta #2 en: 23 de Octubre de 2014, 20:09:00 »
Buenísimo que se haya podido resolver... el tema de velocidad puede estar en la función que escribe la data. Si se utiliza un puerto dedicado, no pines individuales, o un periférico especifico para comunicación paralela puede mejorar mucho.


Saludos
No contesto mensajes privados, las consultas en el foro

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7854
Re: Problemas con TFT
« Respuesta #3 en: 24 de Octubre de 2014, 12:07:00 »
Gracias Suky por responder, la verdad que busque ayuda por que era la primera vez que tocaba un TFT y no tenia idea como usarlo, actualmente ya puedo mostrar imagenes, hacer formas simples ( que por cierto en tu driver los circulos cuando tienen un radio grande (80+) se deforman), todavia no me puse a ver bien por que ya que estuve tratando de mostrar una imagen.

Mal acostumbrado a los LCD 2x16 y a pesar de fijarme en la hoja de datos y que los tiempos estaban bien al ver que no funcionaba empeze a meter demoras por todos lados (al menos si funcionaba sabia que era por esto) y ahi fue que iba lento, ahora muestra  bien rapido la imagen.

Vi que TM4C1294xxx tiene un External Peripheral Interface (EPI) que podria usar aunque todavia no estoy muy acostumbrado a los ARM, a pesar que las librerias lo hacen mas facil de tratar.

/**  EDIT

Ahora que me hiciste buscar eso, habia visto el desorden de los pines de salida hacia las placas de prueba, armar un puerto completo es complejo ya que tenes los pines por todos lados
Mirando el EPI ahora me doy cuenta por que estan asi, y si lo hubiera usado estaban todos bien seguido. Bueno para saber para luego u otra cosa.

**/

Proximo paso, letras y touch, escribiendolas yo con referencias para aprender en el camino.
« Última modificación: 24 de Octubre de 2014, 12:14:39 por KILLERJC »

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7854
Re: Problemas con TFT
« Respuesta #4 en: 28 de Octubre de 2014, 00:59:08 »
Bueno nuevamente vuelvo a molestar ya logre hacer todo lo que pude con respecto al TFT, letras , formas geometricas etc.
El problema que tengo ahora es sobre el touch screen, Al menos funciona bien y esta andando.

Primero intente hacerlo con SPI y no funciono..
Probe el codigo de Suky que hace un SPI por SW y ahi logre hacerlo funcionar. El problema radica en que no se como ubicarme con las coordenadas.

Utilizando el siguiente codigo, identico en su mayoria al de suky:
Código: [Seleccionar]
void InitTouch(void) {

// Configuracion del SSI para comunicarse con el touch

SysCtlPeripheralEnable(SSI_PORT_SYSCTL);
GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_0);
GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CS, 0xFF);
GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CLK | T_PIN_TX , 0x00);

}

uint32_t TouchWriteAndRead(uint16_t Data) {
uint32_t k,Temp;

GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CS, 0x00);
SysCtlDelay((1E-6)*CLKSPEED / 3);
    // En cada flanco ascendente se toma el dato:
    for (k=0;k<8;k++) {
     if(Data&0x80) {
     GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_TX , 0xFF );
     SysCtlDelay((1E-6)*CLKSPEED / 3);
     }
     else {
     GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_TX , 0x00 );
     SysCtlDelay((1E-6)*CLKSPEED / 3);
     }

     GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CLK , 0xFF );
     SysCtlDelay((1E-6)*CLKSPEED / 3);
        Data<<=1;
        GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CLK , 0x00 );
   }

    SysCtlDelay((1E-6)*CLKSPEED / 3); // Esperamos busy:
    GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CLK , 0xFF );
    SysCtlDelay((1E-6)*CLKSPEED / 3);
    GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CLK , 0x00 );
    SysCtlDelay((1E-6)*CLKSPEED / 3);
    SysCtlDelay((1E-6)*CLKSPEED / 3); // Esperamos busy:

    // En flanco descendente leemos data desde el ADS7843:
    GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CLK , 0xFF );
    SysCtlDelay((1E-6)*CLKSPEED / 3);
    Temp=0;

    for (k=0;k<12;k++) {
     Temp<<=1;
        GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CLK , 0x00 );
        SysCtlDelay((1E-6)*CLKSPEED / 3);
        Temp+=GPIOPinRead(GPIO_PORTD_BASE, T_PIN_RX);
        SysCtlDelay((1E-6)*CLKSPEED / 3);
        GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CLK , 0xFF );
        SysCtlDelay((1E-6)*CLKSPEED / 3);
        }

    SysCtlDelay((1E-6)*CLKSPEED / 3);
    GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CLK , 0x00 );
    SysCtlDelay((1E-6)*CLKSPEED / 3);
    GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CS, 0xFF);

    return(Temp);

}

void TouchGetInfo() {

uint32_t TempX=0,TempY=0;
uint8_t i=0;

for(;i<=PREC;i++){
        TempX+=TouchWriteAndRead(TOUCH_READ_X);
        TempY+=TouchWriteAndRead(TOUCH_READ_Y);
}

TempX = TempX >> 3;
TempY = TempY >> 3;
UARTprintf("Valor X: %d , Valor Y: %d",TempX,TempY);
}

Gracias a la UART podia ver los valores en el hyperterminal y me encontre con lo siguiente:

[/url]

Con lo cual para los valores que tengo cada putno son 4 valores de la pantalla y ahi ya no se como seguir... A no ser que tenga un valor negativo/positivo pero esos son los 12 bits
Alguno con la respuesta o imagina que puede ser ?
« Última modificación: 28 de Octubre de 2014, 01:29:23 por KILLERJC »

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7854
Re: Problemas con TFT
« Respuesta #5 en: 28 de Octubre de 2014, 21:31:42 »
Al final lo termine solucionando
Era claramente un error al tomar las medidas, hoy me desperté y se me ocurrió que podría ser eso, al no tener un analizador lógico tenia que pelear con un osciloscopio para ver la señal y corroborar.

Cuando observe los valores me di cuenta que todos terminaban en par, eso queria decir que me estaba salteando un bit al principio de la trama. Es decir el MSB no lo tomaba y tomaba al siguiente como el bit11 asi hasta el bit0 ( que siempre era 0 ).
Otra de las cosas que note que con el driver de suky lee en el flanco de bajada e introduce un ciclo de clk mas, yo con el codigo este lo lei en el flanco de subida a todos ( por que en el de bajada cambia el estado de T_DO) Y no ingrese ningun ciclo de reloj extra.
Quise también tratar de lograr hacerlo funcionar con el SPI ( SSI ) lo cual me enfrente a otro problema que fue que entre cada trama el pin CS se ponía en alto, por suerte o lo hacia por software o este integrado (tm4c1294ncpdt) tiene una opción de "avanzado" y que permite que durante toda la trama hasta que uno se lo pida se mantenga en bajo el pin CS.

Código: [Seleccionar]
void InitTouch(void) {

// Configuracion del SSI para comunicarse con el touch

SysCtlPeripheralEnable(SSI_ENA);
SysCtlPeripheralEnable(SSI_PORT_SYSCTL);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOQ);
GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_1 | GPIO_PIN_3| GPIO_PIN_2); // No se si realmente es necesario pero por las dudas...
GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_0);
GPIOPinWrite(GPIO_PORTD_BASE, T_PIN_CS, 0xFF);

// Configuramos los multiplex para el SSI
GPIOPinConfigure(PIN_RX_MUX); //RX
GPIOPinConfigure(PIN_TX_MUX); //TX
GPIOPinConfigure(PIN_FSS_MUX); // Frame: CS
GPIOPinConfigure(PIN_CLK_MUX); // Clock
// Asignamos esos pines al SSI
GPIOPinTypeSSI(PORT_BASE, PORT_PINS);


SSIConfigSetExpClk(SSI_BASE, CLKSPEED, SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, 1000000, 8);
SSIAdvModeSet(SSI2_BASE, SSI_ADV_MODE_READ_WRITE); //Avanzado
SSIAdvFrameHoldEnable(SSI2_BASE); //
SSIEnable(SSI_BASE);

}

uint32_t TouchWriteAndRead(uint16_t Data) {
uint32_t valor[3];


SSIDataPut(SSI_BASE,Data);
SSIDataPut(SSI_BASE,0x00);
SSIAdvDataPutFrameEnd(SSI2_BASE, 0x00);
SSIDataGet(SSI_BASE,&valor[0]); //dummy read para el primer write
SSIDataGet(SSI_BASE,&valor[1]);
SSIDataGet(SSI_BASE,&valor[2]);
valor[1] = (valor[1] & 0xFF) << 4 ;
valor[2] = (valor[2] & 0xF0) >> 4 ;


return (valor[1] | valor[2]);


}


void TouchGetInfo() {

uint32_t TempX=0,TempY=0;
uint8_t i=0;

for(;i<PREC;i++){
        TempX+=TouchWriteAndRead(TOUCH_READ_X);
        TempY+=TouchWriteAndRead(TOUCH_READ_Y);
}


TempX = TempX >> 3;
TempY = TempY >> 3;
UARTprintf("Valor X: %x , Valor Y: %x \n",TempX,TempY);
}

El código quedo mas compacto y por supuesto liberándome y pudiendo hacer uso del micro mientras. Tiene una FIFO de 16 bits que podría usarla para hacer las cosas mas rápidamente en especial cuando promedias. Pero no me la quise complicar tanto xD. Ahora me queda poner a trabajar todo junto y hacer una función de calibración.

+ Tratar de usar una SD que no tengo la menor idea como usarla
« Última modificación: 29 de Octubre de 2014, 04:15:59 por KILLERJC »

Desconectado elgarbe

  • Moderador Local
  • PIC24H
  • *****
  • Mensajes: 2178
Re: Problemas con TFT
« Respuesta #6 en: 07 de Marzo de 2015, 21:52:36 »
Hola, podrías poner el código o un proyecto básico con la inicializacion del display y un texto simple?
Para tomarlo como ejemplo y ver si puedo hacer andar el mío. Programaste con CCS al T4M?

Saludos!
-
Leonardo Garberoglio

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7854
Re: Problemas con TFT
« Respuesta #7 en: 08 de Marzo de 2015, 00:22:22 »
Esas son las librerias que realize un poco con las copias de las libreas de Suky y de UTFT ( a esta ultima sacandole todos los demas drivers ). Obvio que las copie habiendo tantas por internet.. pero las copie a mi forma. me puse a ver que era cada registro que tocaba, etc etc etc y como hacia para escribir en el TFT.

Con respecto a los dibujos y letras, encontre mas simple el de Suky ya que el archivo de fuentes era mas pequeño. Y su fuente escala desde una sola matriz de alfabeto, mientras que la de UTFT , hay una matriz por cada tamaño lo cual lo vuelve con una mejor definicion de la letra. Y en la libreria de UTFT permite con una variable global mantener un color de fondo, entonces cuando detectaba un 0x00 lo reemplazaba por el color de fondo, lo que le llama el modo "transparente" ( si el fondo tiene muchos colores no sirve xD

Lamentablemente no tengo ningun main.c para usarlo.

Pero basicamente es agregar todos los .h, configurarlos a los .h

usar el initTFT();

y de ahi alli era el usar cualquiera de las demas funciones para graficar:

Observa que todos tienen los parametros X e Y ( algunos de comienzo y fin )

void TFTLine(uint32_t x1,uint32_t y1,uint32_t x2,uint32_t y2,uint32_t Color);
void TFTRectangle(uint32_t x1,uint32_t y1,uint32_t x2,uint32_t y2,bool Filled,uint32_t Color);
void TFTCircle(uint32_t x,uint32_t y,uint32_t Radius,bool Filled,uint32_t Color);
void TFTRoundRectangle(uint32_t x1,uint32_t y1,uint32_t x2,uint32_t y2,bool Filled,uint32_t Color);
void TFTDrawHexa(uint32_t x,uint32_t y, uint32_t sx, uint32_t sy, uint32_t largo, const uint16_t *Imagen);
void TFTText(unsigned short x,unsigned short y,char *PtrText,const char (*Fuente)[5],unsigned char Alto,unsigned short Color);

Citar
Programaste con CCS al TM4?

Si todo con el CCS y las libreria usada para los perifericos es el TivaWare
que por si no conoces algunas funciones para que te guies si queres llevarlo a otro compilador o libreria son:

GPIOPinWrite(Mascara, Numero): Con la mascara me hace una AND al Numero y solo modifica ese bit en el registro, sin tener que leer y volver a escribir. o hacer un bitbanding
SysCtlDelay(): Numero de ciclos del Systick a esperar. Un delay basico
SysCtlPeripheralEnable(): habilitacion del clk a los perifericos
GPIOPinTypeGPIOOutput(): Asignacion de fuerza del driver ( corriente ), direccion y tipo.

Por su parte en el touch notaras:

Código: [Seleccionar]
SSIDataPut(SSI_BASE,Data);
SSIDataPut(SSI_BASE,0x00);
SSIAdvDataPutFrameEnd(SSI2_BASE, 0x00);

En el cual uno pone el dato, el otro pongo 2 0x00 ( un dummy write ) asi envia los demas datos que le quedan del ADC (el clk sigue marchando mienrtas la salida de datos esta en bajo). Dice Advance por que de esa forma podia mantener el pin de CS ( Chip Select ) en bajo en toda la trasmision usando el modulo SPI y con ese le indico que termino ahi. Si no ocurria que cada byte enviado levantaba el CS y lo bajaba nuevamente. y perdia los bits de conversion.

Yo lo hice con SPI ( le llama SSI en el integrado de TI ), pero en la mayoria de los drivers que vi generan el clock a mano... es decir escribiendo el puerto en alto y en bajo. Asi como hice con los datos a enviar y el clock con el TFT.
Tambien no hice uso de toda la FIFO que son 16 bytes sino que solo use 3 y sin interrupciones.

Esta es una version que hice y como anduvo quedo,, pero realmetne hay que mejorarla y poder usarla con mas cosas como el puerto paralelo que ofrece el micro ( que me puede permitir el DMA, aunque los perifericos tambien me lo permiten, pero tiene FIFO xD y Clk ).
« Última modificación: 08 de Marzo de 2015, 00:42:20 por KILLERJC »