Microcontroladores PIC



  • Podías haber pedido el max7300 en encapsulado pdip que sí que los tienen, son los que yo pedí y por lo menos para las pruebas…

    En cuanto a la ayuda, no hay de que, simplemente aporta tus avances así como nosotros te ayudamos... y nada más...



  • Hola

    Te acabo de mandar los pdf´s de la placa de maxim que estoy usando y los manuales de microcontrolador tambien que son muy utiles para la gente que no sabe manejar un microcontrolador. Un manual que te he mandado es una asignatura de mi carrera, no se como colgarlos en el foro o si se puede asi que te los doy mejor a ti que haras un buen uso de ellos.

    te comentaba en el email (ya sabes mi nombre y de donde soy, jejeje) que vaya chasco que me mandasen con encapsulado SSOP, no es mucho problema porque despues voy a desarrollar una tarjeta impresa y los soldare en ella los SSOP pero bueno para hacer las pruebas en la placa board pues necesitaba unos PDIP.

    He preguntado en Electronica Alcala y en Conectrol pero no tienen asi que vaya chasco, ¿sabes donde los puedo conseguir en la comunidad de Madrid o en Internet pero que me tarden poco?

    otro tema es la programacion de la comunicacion I2c, he estado leyendo y ya se como funciona la comunicacion I2c, pero aun asi me gustaria profundizar un poco más.

    En los pdfs de la placa que estoy usando, tini400 no explica como usar la comunicacion I2c, les he mandado un email diciendo si me pueden facilitar algun documento de como poder hacerlo, porque me supongo que no sera con las funciones estandar de I2c:

    *Inicio comunicacion.
    *Delay
    *…
    *Stop

    Bueno con lo que me respindan yo te comento y bueno espero que me puedas decir algun sitio para comprar los componentes max7300 y max7318



  • Ahhhh el teclado ya funciona, al final he usado el componente que comente pero el registro lo he quitado porque no me funcionaba bien, no se porque pero no cambia bien cuando pulsaba la tecla.

    Lo que he hecho ha sido montar el controlador con los dos condensdores y la sorpresa fue que el propio componente actua como un registro, es decir hasta que no pulso una tecla no cambian de nivel los pines y con la salida da "data available" que me genera un pulso a nivel alto me indica que se ha producido un cambio, con lo que solo tengo que leer directamente de las salidas y espero que ya este.

    Por lo menos me cambiaba bien, algunas veces tenia que pulsar 2 veces para que cambiase pero aumentare la capacidad del segundo condensador para haber si aumenta la frecuencia de muestreo.

    gracias y haber si me puedes orientar de donde comprar eso. garcias.



  • Pues la verdad es que he tenido problemas para recibir tu correo…

    En cuando a donde encontrar los integrados, no te lo puedo decir, soy de Málaga y la verdad que madrid...me pilla lejos... Te vas a tener que dar prisa en hacer la placa o esperar a que te lleguen en otro encapsulado.

    Puedes hacer una placa sencilla para no tener calentarte la cabeza ahora, y simplemente poner más accesibles los pines. Te adjunto un ejemplo para soic.
    attachment_p_431656_0_8pinsm-small.gif



  • OK. te mando luego desde casa otro email a la direccion de hotmail. Muchas gracias por la ayuda. Me estoy creando una plaquita con Capture y Layout sencillita y luego la imprimire en la uni (sale muy barato hacerlo en la uni), la placa consta de 2 MAX7300AAX, 2 MAX7318AAG y conectores de pines para soldar de la libreria BCONT100 y listo. La verdad es que la complicacion sera cuando todo me funcione bien en la placa de entrenamiento hacer la placa final. Gracias por tu ayuda

    He decidido poner 2 componentes de cada porque si luego probando necesito más pues solo tendria que soldar otro componente y no hacer otra placa que seria mas gasto para mi.

    En cuanto a lo de pedir los PDIP me han contestado que no los fabrican ya con ese encapsulado, me ha dicho el que me ha contestado que se gastaba mucho plomo y por eso se han retirado ¿? No se porque pero bueno ya pues nada.

    Yo creo que voy a usar tambien el 7318 porque es mas facil que el 7300 y bueno para conectar el teclado por ejemplo, he pensado hasta en controlar el display tambien con otro 7318 y dejar el 7300 para los sensores y las salidas digitales, analogicas y para sacar etapas de potencia pero bueno luego puedo de idea y hacerlo al reves.

    Cuando termine la placa, que espero mañana por la mañana si quieres te mando el archivo *.DSN y *.MAX por si acaso algun dia pues lo usas.

    Anda que envidia estar en Malaga, solete, playita y dentro de poco Sierra Nevada cerca.

    Muchas gracias, esto ya va funcionando. jejeje



  • La verdad que no se está mal por akí… jeje

    Veo que avanzas a pasos grandes, ya mismo tienes el proyecto listo; En realidad el manejo de LCD, analógico y demás tiene algún objetivo o simplemente lo implementas para investigar sobre ese campo??

    Suerte en tus avances...



  • Hola, que tal?? yevo unas semnas muy liado por eso no he podido contarte los avances. Bueno pus la palca me ha dicho la empresa que para el martes estara imprimida y los componentes soldados.

    Ahora estoy haciendo las funciones del protocolo I2C, en la página de maxim encontre las cabeceras de las funciones, aunque básicamente no sirve de mucho me dio una idea de por donde seguir.

    Con esas cabeceras y las hojas de caracteristicas del max7300 y del max7318 he desarrollado 5 funciones, leer y escribir 1 bit, leer y escribir 1byte y luego la la condicion de start y de stop del protocolo I2C. Las funciones las he simulado con Keil3.0 (Muchas gracias por el link) y han funcionado bien.

    Ahora me queda resolver el problema de la función delay, para el protocolo I2C se tienen que cumplir unos tiempos minimos para que el dato quede validado, yo lo he puesto con un bucle for de 10 ciclos pero no se si cumplira los 4uS que son necesarios para los componentes max7xxx, sera cuestion de probar y de averiguar la fercuencia de Osc que tiene la placa DS80C400.

    Ahora ya simulado las funciones el siguiente paso es realizar un programita para leer del teclado y escribir en el display LCD. Y es este paso para mi el que puede ser más complicado.

    Para empezar me he leido de cabo a rabo todas las hojas de caracteristicas, lo que no se aun muy bien es como detectar mediante el puerto que he pulsado una tecla, es decir. Ya tengo en un registro los 4bits del codigo binario de la tecla que se ha pulsado, al mismo tiempo tengo un pin que me da un pulso de nivel alto cada vez que se pulsa una tecla (esto es por si acaso se pulsa la misma tecla ver que se ha pulsado dos veces), pero no puedo estar consumiendo todos los recursos del I2c en ver si se ha pulsado una tecla.

    No se si me explico bien, he leido en las hojas de caracteristicas que los componentes si estan configurados sus puertos a entrada (input) entonces estos pueden detectar cambios en las entradas, la cosa es que no se si funciona como interrupción o no se. El caso es que lo mejor sería tener en la placa una entrada de INT para asi mediante irq poder saber quien ha interrumpido y leer entonces del componente que gobierna al teclado.

    Asi que ahora me dedicare a eso, mientras me darán la placa y terminare de montar todo, para entonces hacer las pruebas ya fisicamente y espero que no me den muchos errores, pero mi experiencia es que seguro que me darán.

    Una vez hecho eso ya solo es programas los diagramas de estados que tengo hechos y espero que ya.

    Dejo el codigo fuente *.c de las funciones de I2C, para que si alguien tiene que usarlas que no se rompa la cabeza como he hecho yo:

    #include<reg51.h>
    #include "uah_types.h"
    //#include "uah_bit_access.h" esta dentro del uah_types.h

    #define I2C_SDA P3_4
    #define I2C_SCL P3_5
    #define I2C_ENABLE_SCL_WAIT_FOR_SLOW_SLAVES 0
    #define I2C_MAXIMUM_SCL_WAITCOUNT 10000
    #define I2C_DELAY_LOOP_COUNT 0

    //sbit SDA = p3^2;
    //sbit SCL = p3^3;

    unsigned char SLAVE1 = 0x40; // Variable con la direccion del periferico MAX7318.
    unsigned char SLAVE2 = 0x82; // Variable con la direccion del periferico MAX7300.
    unsigned char byte_leido; // Byte leido de algun esclavo.
    unsigned char bit_leido; // Bit leido de algun esclavo.

    void i2c_delay(void) // retardo minimo de 4.7uS.
    { // Fosc = 11.0592MHz.
    byte wait;

    for (wait=0;wait<10;wait++)
    {
    ;
    }
    }

    void i2c_start(void)
    {
    I2C_SDA = 1; // SDA en teoria debe estar ya a "1" para que tenga condicion de STOP
    I2C_SCL = 1;
    //P3_4 = 1;
    //P3_5 = 1;
    i2c_delay();
    I2C_SDA = 0;
    i2c_delay();
    I2C_SCL = 0;
    i2c_delay(); // START de la transmision

    }

    void i2c_stop(void)
    {
    I2C_SCL = 1;
    i2c_delay(); // Cumplo Tsu, STO
    I2C_SDA = 1;
    i2c_delay(); // STOP de la transmision
    }

    void validar_escritura(void)
    {
    I2C_SCL=1; // Realizo la señal de reloj SCL
    i2c_delay(); //
    I2C_SCL=0; //
    }

    unsigned char i2c_select(unsigned char address)
    {
    // SELECCION DEL PERIFERICO QUE VAMOS A USAR
    // SE PUEDE HACER EN EL MISMO CODIGO DEL MAIN()
    }

    void i2c_bit(unsigned char singlebit)
    {
    unsigned char bit_a_enviar;
    unsigned char ACK;

    bit_a_enviar=singlebit; // Asocio el bit que me pasan como parametro

    i2c_start(); // Inicio la transmisión
    if (bit_a_enviar == '1') // Transmito el bit
    { //
    I2C_SDA = 1; //
    }
    else{
    I2C_SDA = 0;
    }

    validar_escritura();
    //I2C_SCL=1; // Lo realiza la función validar función,
    //i2c_delay(); // asi me quito los errores de que no me ejecutaba
    //I2C_SCL=0; // las lineas estas
    i2c_delay(); //
    i2c_stop(); // Fin transmision
    //ACK=SDA; // Compruebo si he recibido el bit ACK
    //
    //if(ACK == 0) //
    //{
    // exit -1; // Problema grave: el esclavo no ha recibido el dato
    // // (no ha mandado ACK)
    //}

    }

    unsigned char i2c_readbit(void)
    {
    unsigned char i; // Variable auxiliar.
    i2c_start(); // Inicio la transmisión.
    I2C_SCL=1;
    i2c_delay();
    if(I2C_SDA == 1) // Asigno a la variable auxiliar el valor de SDA
    { //
    i=1; //
    }else i=0;
    I2C_SCL=0; //
    i2c_stop(); // Fin recepción

    return (i); // Devuelvo el valor leido

    }

    unsigned char i2c_readbyte(unsigned char doACK)

    //doACK = NACK = 1 para el ultimo byte.
    //doACK = ACK = 0 para cualquier valor que no sea el ultimo.

    {
    unsigned char i; // Variable del contador del bucle
    unsigned char aux; // Variable donde se va almacenar el dato leido temporalmente

    i2c_start(); // Inicio la transmisión.

    for (i=0;i<8;i++) // Lo realizo 8 veces – 1 byte.
    {
    I2C_SCL=1; // Comienzo la adquisicion.
    i2c_delay();
    aux = aux<<1; // Desplazo un bit (concateno el dato).
    if (I2C_SDA == 1) aux++; // Obtengo el valor del bit de SDA.
    I2C_SCL=0; // Bajo la señal para preparar la captura del siguiente.
    i2c_delay();
    }
    I2C_SDA = doACK; // Esto es para el bit de ACK
    I2C_SCL=1;
    i2c_delay();
    I2C_SCL=0;
    i2c_delay();
    return (aux); // Devuelvo eñ dato leido.
    }
    unsigned char i2c_writebyte(unsigned char singlebyte)
    {
    unsigned char byte_enviar;
    unsigned char ACK;
    unsigned char i;
    byte_enviar = singlebyte;

    i2c_start(); // Inicio la transmisión

    for (i=0;i<8;i++)
    {
    if (byte_enviar & 0x80) // Realizo la transmision
    { //
    I2C_SDA = 1; //
    }else I2C_SDA = 0; //

    validar_escritura();
    //I2C_SCL=1; // Lo realiza la función validar función,
    //i2c_delay(); // asi me quito los errores de que no me ejecutaba
    //I2C_SCL=0; // las lineas estas
    i2c_delay(); //
    byte_enviar=byte_enviar<<1; // Desplazo byte a enviar hacia la izqda
    }

    i2c_stop(); // Fin transmision
    ACK=I2C_SDA; // Compruebo si he recibido el bit ACK
    //
    // if(ACK == 0) //
    // {
    // exit -1; // Problema grave: el esclavo no ha recibido el dato
    // (no ha mandado ACK)
    // }

    }

    unsigned char i2c_writeblock(unsigned char address,unsigned char *barr,int length);

    unsigned char i2c_readblock(unsigned char address,unsigned char *barr,int length);
    unsigned char i2c_writereadblock(unsigned char address,unsigned char *barr1,int length1,
    unsigned char *barr2,int length2);

    void main (void)
    {
    // Mandar un bit

    //i2c_bit('1'); // PERFECTO

    //Leer un bit // PERFECTO
    //bit_leido=i2c_readbit();
    //P3_6=bit_leido;

    //Mandar un byte
    //i2c_writebyte(0x5F); // Perfecto

    //P2=i2c_readbyte(1); // Perfecto, he leido (forzando la entrada del puerto)
    // SDA a los valores 0x53 y me ha devuelto en el puerto
    // P2 los valores que he leido del puerto SDA
    }


    Bueno si sabes alguna manera de como hacer que la placa se entere de que ha cambiado el teclado pues como siempre estaré muy agradecido.
    te mando un mail ahora con algunos archivos.

    En una semana espero poner más avances</reg51.h>



  • Hola de nuevo!

    Generalmente los microcontroladores tienen una entrada de interrupción (como por ejemplo la RB0/INT en los pic) que te indican un suceso externo, aunque posteriormente, mediante software debes comprobar que es realmente lo que ha ocurrido. No se si me he explicado.

    En tu placa, en el datasheets del microcontrolador (pag 89) viene el tema de interrupciones donde te indica que posee varias interrupciones externas, y el vector de interrución al que salta. Sólo debes comprobar que esa interrupción esté dispnible para su uso en algún conector que uses, de esa forma podrás utilizarlo; a no ser que sea utilizado por el controlador ethernet, can, etc…

    No sé si te dejo claras las cosas... aunque ya llevas el proyecto avanzado... y a la vez sin problemas(mejor así ¿no?) jeje



  • Joder mira que tengo PDF´s pero no he visto nada de las interrupciones, he econtardo que esta en el J4, y que el puerto I2C tiene el SDA en P1.1 y SCL en P1.0.

    Hoy me esta entrando un bajón porque se esta complicando bastante y la placa esta no encunentro el vector de atencion ni de como usarlo y no se si las funciones I2C funcionarán en el micro.

    Dime si puedes cuando puedas que datasheet lo has buscado. He pensado en cambiar a un micro, algo más sencillo, lo mas parecido al 8051 con sus 4 puertos I/O, sus cuatro INT muy accesible.

    Muchisimas gracias por toda la ayuda.



  • Ya lo he visto, ese PDF no lo tenia, mil gracias.

    Mañana me lo leere entero, por loq ue he visto tiene 2 interrupciones externas que son las que a mi mas me interesan, a parte de las de los timers.

    Pero no viene fisicamente que pines son los que saca a la placa tini m400, tengo los esque maticos y solo viene 1 INTextern asi que faltaría otro puerto.

    Muchas gracias por la información, muchas gracias por todo.



  • Hola, me he estudiado todo lo que tiene la placa tini y el DS80c400, después he llamado a un compañero que hizo un robot para el concurso de Alcabot (hizo un robot de sumo) y me ha comentado que las placas ya hechas son mucho lio porque estan diseñadas para aspectos muy especificos, me ha dicho que mire algo de la serie msc-51 de intel.

    Después de mucho buscar y leer, he visto que esto se asemeja más a lo que buscaba. por ejemplo el 80c51fa es una buena opción o algun 83c51ah si quisiera más memoria.

    Estos 2 por ejemplo existen en encapsilado PDIP y hasta me facilitaría el "training" antes de montar en placa definitiva. Como te comente ayer accedo a todos los pines, y solo hay que alimentar y colocar un oscilador.
    Tiene sus 2 interrupciones externas, tiene sus timers y es más facilito.

    Bueno otro tema seria como meterle el programa pero eso ya mañana lo busco por internet.

    Lo bueno es que todo lo que he hecho de I2C, funciones, información, MAX73xx… todo eso no lo pierdo porque implementaría en 2 pines el protocolo I2C para expandir pines porque me harian falta alguno más.

    Te pido consejo de que harias tu, la verdad, leyendo los manuales (son los mismos que he visto en clase, eso es que el profesor copio todo), y las instrucciones y todo lo conozco. (modo de funcionamiento de los timers, puerto serie....)

    Te dejo el link a intel por si lo necesitas algún día.
    Muchas gracias
    http://www.intel.com/design/mcs51/docs_mcs51.htm



  • Pues la verdad es que si no te lo requiere el proyecto, usa lo que mejor se adapte a tus conocimientos, es lógico que esas placas vengan muy limitadas… bueno no limitadas sino especificas para algo. teniendo en cuenta que normalmente los microcontroladores usan una misma patilla para varias funciones, es algo imposible hacer una placa para englobar todos los periféricos del mismo.

    Fuera de rollos, siento no haberte podido escribir antes, pero espero que sepas perdonar(jeje) la verdad que me has pillado fuera de casa... (sin internet)

    Y en cuanto al pdf del que lo leí fue de la placa que me comentaste que estabas usando, y bajado de la página del fabricante.

    En cuanto al micro que me has indicado, tb habría opciones entre los 8051 de maxim (como sugerencia), siempre y antes de todo, estudia la viabilidad de los metodos de programación y hardware externo que necesitaras (memoria,etc) y la complicación de las pistas en placa... en fin lo típico....

    No hay que agradecer nada, la verdad que me gusta compartir electrónica con gente como yo...



  • No pasa nada, yo en mi pueblo (Guadalajara) no tengo internet, pero es bueno desconectar de vez en cuando.

    Hoy he estado leyendo mas sobre el 80C51FA y 80C51 de Intel y de Philips (de los 2) y es lo que más conozco, la verdad es lo que he estudiado y para no complicarme la vida es lo más fácil porque es el 8051 simple. 2 INT externas, 2-3 Timers y los registros. También tengo las funciones hechas de los laboratorios de configurar los registros a nivel mediante funciones.

    Mañana se lo comentaré al tutor a ver que me dice. La verdad es que me da pena no usar el DS80C400 pero sería más util y sobre todo para terminar el proyecto prontito.

    y las funciones las has hechado un vistazo??

    Bueno ya me contaras, la verdad que da gusto hablar de electronica con gente que entiende.

    Gracias por todo



  • "Gente que entiende" tanto como eso….
    pero bueno, yo diría que uno entiende de lo que quiere... (no sé si me explico)

    A ver si tienes suerte con tu tutor, la verdad que para no complicarte...es lo mejor: y además siempre tiras de apuntes y documentación ya utilizada... jeje

    En cuanto a las funciones no me las he mirado aún... pero tranquilo que en cuanto tenga un ratito le hecho un vistazo, a ver si te optimizo algo o te puedo hacer alguna sugerencia...

    Por cierto ahora con el puente tb estaré desconectado... la tranquilidad es la base de todas las ciencias, un buen reposo y depejandote, es cuando mejor te pueden salir las cosas (mira Newton que le cayó una manzana mientras descansaba debajo un arbol...) jeje


Accede para responder
 

Has perdido la conexión. Reconectando a Hardlimit.