No es tan complicado como parece

El Tiristor como triac

2011-10-02T23:37:00.003+02:00

Cuando se manejan cargas inductivas, como los motores, se hace aconsejable el uso de tiristores en vez de triacs. Esto de debe al desfase entre la intensidad y la tensión que provoca una carga inductiva. Si el desfase es grande se pude producir el redisparo del Triac (corriente dt) lo que provoca el descontrol de la carga. Los tiristores aguantan mejor el desfase (mayor corriente dt) por lo que colocando dos en sentido opuesto hacen la misma función que el triac.

Se pude observar que el simbolo del triac son dos Tiristores.

Uniendo las dos puertas del tiristor ya podemos disfrutar de un triac mejorado.

Ahora vamos a mejorar la excitación del disparo para garantizar que NO se van a producir redisparos. La idea final es poder arrancar un motor trifásico.

Por el cable que viene de la izquierda vendría la alimentación y la carga la colocaríamos por la parte de abajo. Se pude colocar un solo opto acoplador. La finalidad de colocar dos es poder ir chequeando el estado en que se encuentra el circuito de potencia. Esto vendrá más tarde.

Lo que vamos a ver ahora es como simular una tensión Trifásica con Isis de Proteus

Simulación de tensión trifásica

Lo primero es ir al generador de funciones y pulsar sobres SINE

En Generador Name Identificamos la tensión (R, S o T) en la primera la identificamos como R. En Amplitude hay que colocar la tensión. En este caso, al ser una tensión compuesta, tenemos 230V por fase. Por tanto hay que colocar 325.266 que es la tensión de pico (se obtiene de multiplicar la tensión eficaz por la raiz cuadrada de dos). Esto nos dará la tensión entre fases de 400V. En Frequency colocamos la frecuencia de la Tensión. En este caso 50 Hz. En Phase colocamos el desfase que ha de tener. En caso de la R serán 0 Grados.

Con la Fase S procedemos igual. El único cambio es en Phase. Como son 360 grados el ciclo total tenemos que colocar la tercera parte que son 120 Grados. Con la Fase T son dos terceras partes por lo que son 240 Grados

Ya tenemos la red trifásica creada. Se procede a simular a ver si es verdad

Se puede observar que, respecto a un punto neutro que seria el Neutro de la Red eléctrica, existe la tensión monofásica de 230V y entre fases se obtienen los 400V de la red trifásica.

Cargador de baterías de plomo

2011-09-12T20:53:00.001+02:00

El circuito que se presenta sirve para cargar baterías de ácido de 12 V hasta 7.2A

El transformador ha de ser de 18V ( o 9 + 9) debido a las tensiónes que caen en los diodos rectificadores, el el estabilizador y el diodo que impide la descarga de la batería.
Si es mayor (24V) tendriamos una tensión de pico de 33,9 v que, con la caida de tensión de los diodos nos, no llega a la tensión máxima de entrada del estabilizador (35V) Lo único que notaremos es que se calienta más el estabilizador. De una forma u otra hay que dotarlo de disipador.

Proteus 7.8 sp2 2011

2011-07-02T01:39:00.018+02:00

Descargamos el programa desde:

http://www.fileserve.com/file/H5ea6KT/Proteus.part1.rar
http://www.fileserve.com/file/MNbzb3f/Proteus.part2.rar

Se descomprime el archivo y ejecutamos el instalador del programa que se encuentra dentro de la carpeta Install:

Setup.exe

Una vez instalado ejecutamos el crack: LXK Proteus 7.8 SP2 ENG v1.0.0 de ser en ruso hay que ejecutar el otro crack.

Al ejecutarlo aparece la siguiente ventana en la que hay que buscar la ubicación de la instalación. En algunos casos basta con cambiar Program File por Archivo de programa.

Clic sobre Update y si el camino del archivo es correcto nos responderá con la siguiente ventana:

Ya podemos disfrutar del programa.
Buen provecho.

Calcular una bobina

2011-03-26T17:00:00.007+01:00

Hoy en día, meterse en formulas complejas es lo más sencillo que hay. Una vez practicado y verificando que se hacen bien lo mejor es realizar un programa, aunque sea en excel y poder meter valores e ir viendo cual es la mejor opción.

Para desarrollar las bobinas que me hacen falta usaré el programa realizado por Fernando F. Almeida.

El programa está en portugués pero se entiende a la perfección. Los cálculos que realiza el programa los describe en consideraÇões | Para simple capa:

Para múltiples capas:

El programa es fácil de manejar y el autor ha tomado todas las precauciones para que no se meta la pata.

Da tres opciones de resultados y de esa forma se puede comparar una con otra con facilidad.

El único inconveniente es que no ha colocado bien los valores de la bobina y puede llevar a errores. Para comprobarlo realizamos el cálculo de una bobina de 1 mH y recalculamos con el otro mH

Al recalcular el resultado es el siguiente:

Como se aprecia, el número de espiras es demasiado grande para la bobina que buscamos. Debería de haber colocado MH. Es un error sin importancia pero por un despiste por nuestra parte nos puede llevar a realizar una bobina cuyo valor no es el deseado.
El programa, una vez revisados todos los archivos que lleva, parece ser de libre distribución. De ser lo contrario avisar. Se puede encontrar en la mulita o solicitandolo en mi E-mail. Es un archivo ZIP de un mega y poco.

Convertir tabla excel a facturaplus y viceversa

2011-03-24T18:12:00.005+01:00

Igual lo que hago es dar mucha vuelta pero funciona. El que tenga algo más rápido o mejor ya puede estar comunicándomelo.

Lo primero es hacer una copia de seguridad. Un error y el problema en que se puede uno encontrar es complicado de solucionar por no decir imposible.

Voy a pasar los artículos que me han pasado en formato excel a la base de datos de facturaplus.

Para que el formato excel sea el correcto se abre el acces y creamos una nueva base de datos vacía. Ahora se vincula con el archivo que hay que modificar. En este caso Articulos.dbf.

Nótese que se ha modificado el Tipo de archivo a dBASE 5 para poderlo localizar en la carpeta correspondiente. Al vincular Aparece la pestaña seleccionar los archivos de índice. La cancelamos.

Avisa de que ha sido correcta la vinculación y cerramos el aviso aceptando. Se procede a abrir el archivo vinculado y lo exportamos a excel. Archivo/Exportar.

Se modifica el Guardar como Tipo al excel que tenemos instalado y le damos el nombre del archivo que para no tener líos lo adaptamos a nosotros mismos.

En este caso Articulo1. Exportamos todo y ya tenemos generado el archivo excel. Lo abrimos y aparece todo lo que configura el facturaplus. En este caso es "Articulos1".

NOTA IMPORTANTE

HAY QUE AMPLIAR LAS COLUMNAS YA QUE LO CONTRARIO NO NOS CARGARA EL DATO CORRECTO. Es decir:

Ampliar las celdas (revisar todas) y dejar de forma que quepa todo el texto (las celdas con corchetes también, #######).

De lo contrario facturaplus sólo cogerá lo que se ve en la celda.

Nos dirigimos a la última linea de artículos y abrimos el archivo que hay que agregar. Una vez abierto seleccionamos todos los artículos y los copiamos al fina del archivo "Articulos" Es decir: agregamos los archivos que queremos.

Ahora hay que reorganizar lo que hemos añadido. Cada columna tiene que estar en su sitio. Como se aprecia los precios han caído sobre la columna de "Familia" (CCODFAM). Hay que desplazarla a "PVP" (NPVP) en este caso. (Sólo hay que desplazar la parte de la columna que hemos pegado)

Se guardar. Ahora guardar como y eliminamos el 1 para que se quede Artículo y nos informa que ya existe el archivo.

Le decimos que si y

le volvemos a decir que si.

Ya tenemos el archivo modificado sin ninguna pega. Ahora solo queda cerrar el archivo para dejarlo libre y que facturaplus tenga acceso completo al mismo.

Abrimos el programa y antes de acceder a cualquier archivo hay que reorganizar los ficheros con Util/Organización de ficheros.

Aparece el organizador de ficheros y le damos a SI

Una vez finalizado el proceso ya tenemos en nuestra base de datos todos los artículos con su precio.

Se pueden rellenar, en la hoja excel todos los datos que creamos apropiados. De esta forma nos ahorramos colocarlos uno a uno.

Clasificar componentes

2011-03-20T05:43:00.007+01:00

Lo más normal es tener un montón de componentes electrónicos esparcidos por diferentes sitios y cuando te hace falta uno tienes que comprarlo a sabiendas de que lo tienes.

Una forma sencilla de clasificarlos es adquirir cajones de plástico e ir metiéndolos.

El problema es el espacio y peor aún el precio. Pongamos por ejemplo las resistencias. Tan sólo con ellas tardaríamos una eternidad en amortizar la inversión para poder clasificar las de un pequeño taller. En tres cajas que ocupan menos espacio que la cajonera anterior las tengo perféctamente organizadas. Lo primero es elegir una caja de cartón. Luego recortamos folios con su anchura de la caja por el doble (o algo menos) de la profundidad y los doblamos por la mitad. Ya tenemos las resistencias de 1/4 de watio bien clasificadas y ordenadas.

En cada doblez de folio se introducen las resistencias y se rotula el valor en el folio. En esta caja están los valores a partir de 1k, en otra coloque las de 1k hasta los valores más bajos y el otra los valores de más potencia.

Las resistencias no se salen ni se mezclan a no ser que le des la vuelta a la caja. Cosa bastante fácil de hacer, por cierto. Esto se soluciona colocando una pequeña esponja cubriendo la parte superior.

Hemos clasificado un montón de material electrónico en un espacio reducido y manejable y a un precio de... deja que calcule bien... 0€. La caja era de un voltímetro para un cuadro y los folios son reciclados de pdf que ya no sirven (por poner un ejemplo) Acabamos de reciclar un montón de material sin querer.

Aprovechado el reciclado vamos a organizar los demás componentes.

¿Cómo podemos organizar todos los demás componentes ya que tienen tamaños diferentes?

La solución es bien sencilla: aprovechamos las cajetillas de tabaco de cartón duro. Aquí los tengo en cajón de la mesa del taller.

Después de clasificar todos los componentes electrónicos me sobraron un montón de huecos. Se pueden organizar por la numeración de los componentes pero surge el problema de meter varios en un compartimento. Si vamos obteniendo más materiales, cosa lógica, hay que ir reorganizándolos. La solución tampoco es complicada.

El programa que uso para facturación es el Facturaplus (se puede conseguir a un módico precio por la mulita)

Actualizado 17-10-2011 Existe un programa más potente que el Facturaplus y es totalmente gratuito. Se llama FactuSOL (pincha en el enlace para descargar). He probado la versión 2011 y funciona a la perfección en multipuesto y multiusuario. Encima permite pasar las empresas desde Facturaplus. Recomiendo Descargarse el manual de instrucciones y leerlo. Es simple si se conoce el funcionamiento de este tipo de programas.

El código del componente me sirve para introducirlo en la base de datos. Al final de la descripción le coloco el número de caja donde se encuentra. Veamos el BC546B que se encuentra en la caja 52.

De esta forma puedes ampliar todo lo que quieras que siempre lo tienes localizado. Se puede realizar en una hoja de cálculo perfectamente. Lo bueno de hacerlo con un programa de gestión es el control del stock.

Estos programas de gestión te permiten tener componentes en distintos lugares y siempre controlados ya que puedes ampliar todos los amacenes que quieras. Este componente, si lo quiero pasar al maletín de reparaciones puedo dar de alta otro almacén como "Maletín Reparaciones" y hacer un traspaso de almacén. En ese caso tendría el stock de un sitio, del otro y el total.

Aquí los tengo clasificados en una caja de plástico que tiene las medidas de altura justas de la cajetilla. Se pude colocar en una pared sin problemas (en vertical).

Poco espacio y del precio no hablemos. Viva el reciclado.

Generador de Tensión inversa

2011-03-17T05:00:00.015+01:00

Algunas veces se precisa de tensión inversa partiendo de una tensión de alimentación positiva. La intensidad no es crítica ya que la mayoría de veces es para trabajar con amplificadores operacionales. Estos operacionales consumen microamperios.

El siguiente circuito es capaz de ofrecer una intensidad de 20mA:

En la simulación está conectado a la alimentación y se obtiene una intensidad superior.

Tabla de conversión de porteros automáticos

2011-03-14T21:36:00.001+01:00

Tabla de equivalencias de porteros

*MODELO*	*ABREPUERTAS*	*MICRO*	*COMUN*	*ALTAVOZ*	*ZUMBADOR*	*BITONAL*
ACET	5	10	2	7	9
AMPER	F	L	N	M	E
AMPLIBOX	Z	R	O	T	1
ATEA	2	4	3	1	5
AUTA	10	3	4	7	12
AUTELCO	P5	a	1	b	2
AXIL	8	2	6	1	4
BOGEN	T	1	3	2	6
B.P.T.	2	1	4	5	3
CENTRAMATIC	4	2	1	3	5
CITESA	1	4	C	3	B
CITOFONIX	3	1	2	4	5
CITOVOX	5	10	9	7	T
COMELIT	P1	3	4	2	1
COSESA	R	A	+	B	Z
COSESA-TEF	D	A	C	B	E
ELVOX	2	6	9	4	+
FARFISA	5	1	3	2	6
FECLO	F	A	C	B	E
FAIVE	8	5	2	1	7
FERMAX CITY UNIVER.	1	2	3	6	4	5
FERMAX GONDOLA	4	1	3	2	V 6 5
FERMAX REKTO TF-4	P	A	C	B	E
FERMAX TF-1Z	1	2	3	6	4
FERMAX TN-Z	1	2	3	6	4
FRINGE	2	3	1	6	4	4
GAME	P	2	3	1	Z
GIRO	2	3	1	6	4
GOLMAR	X	M	A	S	N
GOLMAR	C2	5	3	10	7	0
GOLMAR	11	5	3	4	12
GOLMAR T-600	T	1	3	2	6
GOLMAR T-2800	4	5	3	10	7
GUARDAL	5	1	3/7	2	6
HIRSCHMANN	P	2	3	1	Z
INTALTEL	1	9	6	2	3
MICROVOX	3	1	2	4	5
MIGRIAVACCA	A	3	5/6	1	7
ORTIGOSA	5	2	4	3	1
OSTELVI	9	2	6	1	7
PAGANI COMPAC T-71	Abr	1	0	2	3
PORMAT	4	3	2/5	1	v
RIPOLLES	3	1	8	2	4
SAFNAT	4	1	2	3	v
SAFNAT	6	8	10	4	11
SIEMENS	6	9	5	2	10
TAGRA	8	2	6	1	4
TEGUI GL	3	4	2	5	1
TEGUI HORIZONTAL ZUMB.	3	4	2	5	1
TEGUI HORIZONTAL LL. ELEC.	3	4	2	5		1
TELEVES	4	2	3	1	T
TERRANEO	T1	1	3	2	6
TRANSIFON	1	5	6	7	1
TUNE	8	2	6	1	4
URMET	9	2	6	1	7
VEMEL	5	2	3	4	4

Volver a inicio
electro Volver a
inicio

El potenciómetro: El cortocircuito

2011-03-10T19:29:00.003+01:00

Ha la hora de realizar los diseños en los que incluimos potenciómetros cometemos un error que en ningún lado nos enseñan y es crítico a la hora de las reparaciones y de posibles mantenimientos por parte del cliente.

Si el potenciómetro se encuentra en el exterior (supongamos un variador de frecuencia y el potenciómetro en el panel del cuadro) La sustitución por parte del cliente es sencilla y el error fatal también. Otro caso es la prueba, en un futuro, de las conexiones del potenciómetro sin saber como iba conectado.

Vamos a la práctica de un diseño simulado:

Este es un circuito que se ve en el 99% de los diseños.
A la hora de sustituir un potenciómetro normal la cosa es casi sencilla: cada terminal seguido del siguiente. La cosa cambia al usar un multivueltas. La confianza en nosotros mismos, no apuntar lo que desconectamos, nos lleva a la duda a la hora de reconectar el potenciómetro.

El esquema que llevan grabado es bastante confuso y puedes llegar a conectarlo mal.

¿Qué ocurre si al conectar provocamos un corto entre el 0V y +5V?

Aquí es donde quería llegar. Puede llegar a pasar por el potenciometro la totalidad de intensidad y destruirlo. También podemos fastidiar el diseño que funcionaba tan bien o cualquier otra cosa.

Un cortocircuito en toda regla.
La solución más cómoda y sencilla es una Resistencia para limitar la intensidad.

La elección del valor de la R limitadora tendrá un valor dependiendo del diseño realizado y el valor del potenciómetro. Si elegimos bien el valor las modificaciones en nuestro programa serán mínimas. Ahora bien: la garantía que podemos ofrecer de nuestro producto es máxima.

TTL con mayor intensidad de salida

2011-03-01T14:04:00.004+01:00

De todos es sabido que los TTL tienen a su salida 10 mA como máximo y los CMOS 1 mA. A partir de estas intensidades la tensión a su salida empieza a caer. Si se quiere excitar un MOC3041 al cual le hacen falta 15 mA lo tenemos crudo. Mucho menos si queremos activar un relé.

Esto ocurre a nivel alto. Pero ¿qué ocurre a nivel bajo? La respuesta es sencilla: podemos activar incluso un relé ya que la resistencia interna del integrado es menor.

Para aclarar esto realizamos un ejemplo:

Conectamos dos relés con una R interna de 100 ohmios, por lo que le hace falta una intensidad de 50 mA para una excitación correcta, a dos puertas LS. Una para que excite a nivel alto y otra a nivel bajo.

Como se trata de una Nand con sus entradas al mismo nivel hacen la función de inversor. Por tanto tendremos a sus salidas un nivel alto. Esto hace que el U1:B se encuentre a nivel alto. El relé RL2 debería activarse.

Si observamos: la intensidad es de 45mA lo que debería excitar el relé pero la tensión ha caído a 0,32V debido a la resistencia interna del LS. Por tanto el relé no se activa.

Ahora colocamos la entrada de los inversores a nivel alto para obtener una salida a nivel bajo:

La intensidad para RL1 es parecida a la anterior pero la tensión en el relé TL1 es de 4,55. Lo que si excita el relé. Tan solo ha caído la tensión del transistor que lo pone a nivel bajo.

PRECAUCIÓN: Recordar que estos integrados no están preparados para trabajar con estas intensidades. Esto quiere decir que al aumentar significativamente la intensidad aumenta la potencia que tiene que disipar. Hay que llevar cuidado con la cantidad de relés que se activan al mismo tiempo. Cinco salidas al mismo tiempo seria 0,5A y eso es casi lo que soporta uno diseñado para esta función: el ULM2803 que son 8 salidas a colector abierto.

Proteus: Isis se cierra automáticamente

2011-02-10T05:00:00.008+01:00

Al reabrir un esquema guardado con anterioridad el programa se cierra automáticamente. Esto es un gran problema ya que no deja modificar no hacer nada con un esquema que ha llevado horas de trabajo. Esto sucede en programas pirateados.

Una solución es borrar una carpeta que se crea al guardar el circuito creado.

Lo primero es hacer una copia de seguridad de la carpeta donde se guarda el esquema. Una vez puesta la copia de seguridad a buen recaudo procedemos borrando el archivo PWI de la carpeta donde esta el DSN. Es decir: La carpeta a borrar se encuentra donde tenemos guardado el esquema que nos da el problema.

23-02-2011 Este archivo se crea al simular un programa con microcontrolador generalmente. Una forma de no tener que ir borrando el archivo cada vez que se guarda y reabre es el siguiente:

En la carpeta donde está el programa generamos un documento de texto con el mismo nombre que el circuito(terminación txt) y luego lo guardamos como pwi.

Al guardarlo da el aviso de que el archivo ya existe y si desemanos reemplazarlo. Le decimos que si.

Cerrramos y seleccionamos el archivo creado, boton derecho y porpiedades. En sus propiedades activamos la casilla de "sólo lectura".

Con esto ya apodemos abrir, simular, cerrar, reabrir... las veces que queramos sin problemas.

Arranque del módulo Telit

2011-01-25T19:28:00.004+01:00

          Esta es una forma sencilla de arrancar el módulo y ha de quedar claro que las variables y llamadas a otros subprogramas puedem quedar en otro lugar. Es un ejemplo que se puede seguir para la puesta en marcha.
          Si se desea el proyecto entero hay que pedirlo al correo electrónico o mediante un comentario. Este procedimiento se corresponde al esquema presentado en el enlace.

>>- - - - - - --
// arranque.c Arranca el módulo Telit
// SE inicia enviando un AT y tiene que responder ok.
void arranca(){
     do {
          inicbuff2(); // Borro buffer.
          puerto_b= 0;
          rcvchar=0x00; // último caracter recibido
          Rxnum=0x00; // Identifica la cantidad de bytes recibidos
          TimerCero=0x00;
          Timer_=0x00; //Variable de tiempo a temporizar en 10miliseg
          Retornos=0x00; //CAntidad de retornos a contar
          VarRetornos=0x00; //CAntidad de retornos a contar
          Desplaza=0x00; //cantidad de puestos que ha de desplazar para leer
          flagcommand=0; // Flag para indicar comando disponible
          flagOK=1;
          flagPrimero=0; //Flag de primer \n
          flagATOK = 1; //Flag de confirmación de interpretación correcta.
          repeat=1; //Repetir la función que se está ejecutando
          NoAutorizado= 1; //Flag de control de telefonos autorizados
// EstadoAlarma=0; //Estado de alarma activa al inicio

          output_high(PIN_C1); //Activa el reset
          delay_ms(610);
          output_low(PIN_C1); //desActiva el reset
          output_high(PIN_C0); //Activa el reset
          delay_ms(1110);
          output_low(PIN_C0); //desActiva el reset
          delay_ms(300); //Fin del reset
//_________________________________
          cargar();
          VarRetornos=2; // Espera la llegada del OK
          Desplaza = 0x07; //posiciona el la O de ok
          printf ("ATE0\r"); //1 Comando de no Eco (con cero al final)
          TempRecibe(300); //activa la temporización en la recepción
          while ((flagATOK) && (flagOK)) ; //Fin de recepción
          procesa();
          if (flagATOK == 0){//1
                    delay_ms(200); //Fin del reset
                    cargar();
                    VarRetornos=2; // Espera la llegada del OK
                    Desplaza = 0x02; //posiciona el la O de ok
                    printf ("AT+CMEE=1\r"); //2 Comando PARA DEVOLUCION DE ERRORES
                    TempRecibe(550); //activa la temporización en la recepción
                    while (flagATOK && flagOK) ; //Fin de recepción
                    procesa();
                    if (flagATOK == 0){//2
                              delay_ms(100); //Fin del reset
                              cargar();
                              VarRetornos=2; // Espera la llegada del OK
                              Desplaza = 0x02; //posiciona el la O de ok
                              printf ("AT+IPR=9600\r"); //3 Comando PARA DEVOLUCION DE ERRORES
                              TempRecibe(2020); //activa la temporización en la recepción
                              while (flagATOK && flagOK) ; //Fin de recepción
                              procesa();
                              if (flagATOK == 0){//3
                                        delay_ms(1000); //Fin del reset
                                        cargar();
                                        VarRetornos=2; // (4)Espera la llegada del OK
                                        Desplaza = 0x02; //posiciona el la O de ok
                                        TempRecibe(2020); //activa la temporización en la recepción
                                        printf ("AT+CPIN\r"); //5 Comando PARA DEVOLUCION DE ERRORES
                                        while (flagATOK && flagOK) ; //Fin de recepción
                                        procesa();
                                        if (flagATOK == 0){//4
                                                  output_high(PIN_B4);
                                                  delay_ms(14000); //Tiempo para que conecte con repetidor
                                                  output_low(PIN_B4);
                                                  do{
                                                            delay_ms(1010); //Fin del reset
                                                            cargar();
                                                            VarRetornos=2; // Espera la llegada del OK
                                                            Desplaza = 0x02; //posiciona el la O de ok
                                                            printf ("AT+CREG\r"); //Comando ESTADO CONEXION
                                                            TempRecibe(2500); //activa la temporización en la recepción
                                                            while (flagATOK && flagOK) ; //Fin de recepción
                                                            procesa();
                                                  }while(repeat);
                                                  delay_ms(500); //Fin del reset
                                                  if (flagATOK == 0){//5
                                                            cargar();
                                                            VarRetornos=4; // Espera la llegada del OK
                                                            Desplaza = 0x02; //posiciona el la O de ok
                                                            printf ("AT+CSQ\r"); //Comando CANTIDAD DE SEÑAL
                                                            TempRecibe(550); //activa la temporización en la recepción
                                                            while (flagATOK && flagOK) ; //Fin de recepción
                                                            procesa();
                                                            delay_ms(500); //Fin del reset
                                                            if (flagATOK == 0){//6
                                                                      cargar();
                                                                      VarRetornos=2; // Espera la llegada del OK
                                                                      Desplaza = 0x02; //posiciona el la O de ok
                                                                      printf ("AT+CMGF=1\r"); //Comando MODO TEXTO
                                                                      TempRecibe(550); //activa la temporización en la recepción
                                                                      while (flagATOK && flagOK) ; //Fin de recepción
                                                                      procesa();
                                                                      delay_ms(500); //Fin del reset
                                                                      if (flagATOK == 0){//7
                                                                                cargar();
                                                                                VarRetornos=2; // Espera la llegada del OK
                                                                                Desplaza = 0x02; //posiciona el la O de ok
                                                                                printf ("AT+CLIP=1\r"); //Comando MODO TEXTO
                                                                                TempRecibe(20000); //activa la temporización en la recepción
                                                                                while (flagATOK && flagOK) ; //Fin de recepción
                                                                                procesa();
                                                                                delay_ms(500); //Fin del reset delay_ms(1201); //Fin del reset
                                                                                if (flagATOK == 0){//8
                                                                                          cargar();
                                                                                          VarRetornos=2; // Espera la llegada del OK
                                                                                          Desplaza = 0x02; //posiciona el la O de ok
                                                                                          printf ("AT+CNMI=1,1,0,0,0\r"); //Configura el SMS
                                                                                          // TempRecibe(5050); //activa la temporización en la recepción
                                                                                          while (flagATOK) ; //Fin de recepción
                                                                                          procesa();
                                                                                } //8 /* */
                                                                      } //7
                                                            } //6
                                                  } //5
                                        } //4
                              } //3
                    } //2
          } //1

// } //O
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
          if (flagATOK == 0) {
                    cargar();
                    VarRetornos=4; // Espera la llegada del OK
                    Desplaza = 0x02; //posiciona el la O de ok
                    //Lo deja preparado para la recepción
                    repeat = 0;
                    output_high(PIN_B7);
          }
          else {
                    repeat = 1;
                    output_high(PIN_B6);
          }
          if( EstadoAlarma==1)
                    output_high(PIN_B4);
                    delay_ms(2000);
          // output_low(PIN_B4);
          inicbuff2();
          }while (repeat); //Secuencia de repeticion constante
} //Fin arranca
//_________________________________________________________
void cargar(void){
          output_high(PIN_B3); //Activa Transmision
          inicbuff2(); // Borro buffer.
          flagPrimero=0 ;
          flagOK = 1;
          flagATOK = 1;
          Rxnum =0 ; //Contador de entrada de bytes
          repeat= 1;
          Retornos=0;
          fagTiempo=1;
          rcvchar=0x00;
          TimerCero=0x00;
          Timer_=0x00; //Variable de tiempo a temporizar en 10miliseg
}
// VarRetornos=0x00; //CAntidad de retornos a contar
// NoAutorizado= 1; //Flag de control de telefonos autorizados
// EstadoAlarma=0; //Estado de alarma activa al inicio
//_______Activa temporización en transmisión______________________
void TempRecibe(long Temp){
          enable_interrupts(int_rtcc);
          disable_interrupts(int_rtcc);; // Habilita Interrupción RDA
          output_low(PIN_B3); //desactiva transmision
          Timer_ = Temp;
          set_rtcc(0); /* Se inicializa el timer a cero */
          enable_interrupts(int_rtcc); // Habilita Interrupción RDA
          flagOK=1;
          fagTiempo=1;
}
//________________________________________________________
void inicbuff2(void){ // Inicia a \0 cbuff -------------------
          int i;
          for(i=0;i
                    cbuff[i]=0x00; // caracteres en el buffer
                    }
          xbuff=0x00; // Inicializo el indice de siguiente
          // caracter
}
//________Identifica si hay o no que enviar el PIN
//_____________________ Tratamiento de errores____________________
void errores (void){
          int i = 15; // situta puntero en el numero de averia
          // disable_interrupts(int_rtcc);;
          switch(cbuff[i]) {
          case '0': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x00;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '1': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x01;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '2': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x02;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '3': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x03;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '4': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x04;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '5': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x05;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '6': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x06;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          case '7': { //Comprueba si el primer valor recibido es sincronizacion
          puerto_b=0x07;
          output_high(PIN_B3);
          delay_ms(500);
          // bloqueo();
          }
          default:flagATOK =1; //error en la transmision
          }
}
//__________ Comprueba si hay señal suficiente para ejecutar el proceso
void senyal (){
          int i= 8; // situta puntero al inicio de la averia
          disable_interrupts(int_rtcc);;
          if ((cbuff[i]>='1')&& (cbuff[i]<='3')&& (cbuff[(i+1)]>='0')&& (cbuff[(i+1)]<='9' )) {
                    flagATOK = 0;
                    }else {
                    flagATOK =1;
                    puerto_b= 0xE0;
                    bloqueo ();
          }
}
//__ Comprueba el estado de la conexion
void conection (){
          int i= 11; // situta puntero al inicio
          disable_interrupts(int_rtcc);;
          output_high(PIN_B7);
          delay_ms(20); // espera la llegada del OK
          switch(cbuff[i]) {
                    case ('0'): { //Comprueba si el primer
                    repeat = 1;
                    } break;
                    case ('1'): { //Comprueba si el primer
                    repeat = 0;
                    } break;
                    case ('2'): { //Comprueba si el primer
                    repeat = 1;
                    } break;
                    default:{
          flagATOK =1; //error en la transmision
          repeat = 1 ; //sale del bucle al tener un error seguramente.
          puerto_b= 0xE0;
          bloqueo();
          }
          }
}
//_____________________________________________________________
void procesa(){
          int i ;
          i= Desplaza;
          disable_interrupts(int_rtcc);; // Habilita Interrupción RDA
          if (flagOK==1){//PP
                    // disable_interrupts(int_rtcc);; // Habilita Interrupción RDA
                    if (cbuff[2]!= '+'){// 1
                              switch(cbuff[i]){
                              case 'O': { //Comprueba si el primer valor recibido es sincronizacion
                              flagATOK =0;
                              } break;
                              case 'R': { // RING Comprueba sI ES UNA LLAMADA
                              delay_ms(500);
                              llamada ();
                              } break;
                              default:flagATOK =1; //error en la transmision
                   }
          }//1
          else{ // sIGNIFICA QUE HA LLEGADO UN + ***************************
                    i= 4; // situta puntero al inicio de la averia
                    switch(cbuff[i]) {
                    case 'P': { //CPI Comprueba si el primer valor recibido es sincronizacion
                    // Enviar a tratamiento del pin
                    verPin ();
                    } break;
                    case 'M': { //CME Comprueba si el primer valor recibido es sincronizacion
                    // Enviara a tratamiento de error
                    // delay_ms(50);
                    errores();
                    } break;
                    case 'S': { //CSQ Comprueba si el primer valor recibido es sincronizacion
                    // Enviara a tratamiento de señal
                    senyal ();
                    } break;
                    case 'R' : { //CRE Comprueba si el primer valor recibido es sincronizacion
                    // Enviara a tratamiento de señal
                    conection ();
                    } break;
                    default:flagATOK =1; //error en la transmision
                    }
          }
          }//PP
}
//__________________________________________________
void verPin(void){
          int i= 9; //Situa al inicio de la palabra P ó S
          disable_interrupts(int_rtcc);;
          if (cbuff[i]== 'R'){ //Significa que es Ready por tanto vuelve sin más
                    flagATOK = 0; //No hace falta hacer nada (no envia pin)
                    delay_ms(700); //Espera a recibir el ok
          }
          else {
                    i=14;
                    delay_ms(700); //Espera a recibir el ok
                    if (cbuff[i]== 'I'){ //Tiene que enviar el Pin
                    cargar(); //Envia el Pin
                    VarRetornos=2; // Espera la llegada del OK
                    Desplaza = 0x02; //posiciona el la O de ok
                    printf ("AT+CPIN=4340\r"); //Comando ENVIA EL CODIGO PIN**
                    TempRecibe(2010); //activa la temporización en la recepción
                    while (flagATOK && flagOK){ //Fin de recepción
          } //Espera a que termine de recibir
          // disable_interrupts(int_rtcc);; // Habilita Interrupción RDA
          i=2;
          if (cbuff[i]== 'O') //Si ha llegado el Ok continua
                    flagATOK = 0; //hA SIDO CORRECTO
                    else flagATOK = 1; // Algo ha fallado en la recpecion del 0k final.
          }
          else {
                    puerto_b= 0xF0; //precisa del PUKV???
                    bloqueo();
          }
}
}

Leyes de Morgan

2010-12-02T06:00:00.003+01:00

La negación se verá representada por ~. Se obtiene pulsando Alt-Gr + 4.

La primera ley dice:

Un producto negado es igual a la suma de las negadas.

Representamos el primer miembro de la función que es una NAND:

Ahora representamos el segundo miembro de la función que es una OR con sus entradas negadas:

Fijándose en las tablas de la verdad, se observa que son iguales. Esto demuestra la la 1ª Ley de Morgan. Resumiendo:

La segunda ley dice:

Una suma negada es igual al producto de sus negadas

Representamos el primer miembro de la función que es una NOR:

Ahora representamos el segundo miembro de la función que es una AND con sus entradas negadas:

Fijándose en las dos tablas de la verdad se observa que son iguales. Esto demuestra la 2ª Ley de Morgan.

Con estas dos leyes se pueden realizar puertas lógicas a partir de otras. Veamos unos ejemplos:

Para obtener una puerta AND puedes utilizar una puerta NOR con sus entradas negadas

Para obtener una puerta OR puedes utilizar una puerta NAND con sus entradas negadas:

Para obtener una puerta NAND utiliza una puerta OR con sus dos entradas negadas, como indica la primera ley de De Morgan:

Para obtener una puerta NOR utiliza una puerta AND con sus entradas negadas, eso dice la 2º ley de De Morgan

La puerta XOR tiene la particularidad de entregar un nivel alto cuando una y sólo una de sus entradas se encuentra en nivel alto.

La ecuación indica las puertas a utilizar:

Para obtener una puerta EXNOR agregas una compuerta NOT a la salida de la puerta XOR vista anteriormente:

Para obtener Inversores (NOT) puedes hacer uso de compuertas NOR o compuertas NAND, simplemente uniendo sus entradas.

Generador de reset al conectar la alimentación

2010-10-22T05:13:00.002+02:00

En ocasiones la electrónica necesita resetearse al iniciarse la alimentación para poder predecir su estado en las salidas. Para poder realizar dicha función vamos a usar un comportamiento del condensador.

La mayoría de circuitos integrados generan un reset por nivel bajo. Vamos a resetear el 4532 que está alimentado a 12V.

Viendo el datasheet se observa que el reset es por nivel bajo. La misión es que la patilla del reset se encuentre a nivel bajo durante un tiempo y después se mantenga a nivel alto. Un condensador descargado es como un cortocircuito (ya se comentó en el detector de flancos) por ello lo conectamos a masa y para que se vaya cargando conectamos una resistencia a nivel alto.

La entrada de reset no es trigger smith y no podrá definir el tiempo de reset a la conexión. Es decir: cuando se alimenta el circuito el condensador está descargado. En el extremo conectado al reset, como se comporta como un cortocircuito, se refleja su conexión a masa y hay un nivel bajo y empieza a cargarse a través de la resistencia. Sabemos que el condensador se considera cargado transcurridos 5t (cinco tau) y no sabemos claramente cuando cuando tiempo se va mantener el reset. Para tener el tiempo controlado le añadimos un par de puertas inversoras trigger smith.

La puerta inversora (según el datasheet) verá el nivel alto a los 8,5V. Ya podemos calcular un tiempo de reset. Para ello usaremos la formula:

t = Tiempo

R = Resitencia

C = Capacidad

K = e * V/V-Vc

donde: e = logaritmo neperiano

V = Tensión

Vc = Tensión trigger

La corriente de carga tiene que ser muy pequeña ya que la entrada del CMOS apenas consume. Por ello probaremos con una resistencia elevada a ver que capacidad necesitamos. Determinamos un tiempo de 100us y probamos con una R de 100K:

     Como es un valor que no vamos a encontrar nos vamos al valor superior normalizado que es de 1nF y siempre será más fácil tenerlo en nuetro taller. El valor de la tensión (11,5) es el valor que consideramos de carga de los 5 tau.
     Por tanto podemos decir que con una R de 100k y un condensador de 1nF tendremos un reset aproximado de 100us. Digo aproximado por el valor del condensador y las tolerancias que vamos a encontrar en los componentes.
     Al desconectar la tensión la descarga del condensador se efectuará con el mismo tiempo que la carga lo que no garantiza un nuevo reset si la desconexión no es grande. Por ello hay que efectuar una descarga rápida del condensador. La descarga rápida se efectúa con un diodo inverso colocado en paralelo a la resistencia. El circuito quedará así:

El mapeado de memoria del 18F2550: escribir y leer la flash

2010-10-19T05:00:00.027+02:00

!! No es posible pregrabar el pic con la directiva #rom!! ¿¿o no sabemos hacerlo??

Si Belando es capaz de comprender esto sin sacarme de mis casillas es que el escribir y leer de la flash es tan sencillo como sumar o restar con los dedos. A ver como me explico sin meter caña.

El paso del 16F al 18F es duro y hay que tener paciencia. El mapeado es de 16bits o lo que es lo mismo 2 bytes de 8 bits cada uno. Vamos a demostrarlo sobre nuestro programa y visualizado con el Winpic800. Algo de publicidad hay que hacerle.

Aquí tenemos nuestro programa cargado:

Trabaja en 16 Bits ó 2Bytes de 8bits, que al caso es lo mismo, y numera de izquierda a derecha. Hasta aquí no hay nada raro. ¿Cómo numera contando a 8bits? pues no! no es de izquierda a derecha. De la posición 0x0000 (contado de 8 en 8bits el primero es el de la derecha y el segundo el de la izquierda del 0x0000. Vamos a contar la primera fila y queda más claro:

!Vaya! Ahora se entiende lo mal que va el compilador, va estupendamente. Verdaderamente no nos importa ya que guardamos o leemos sin importarnos donde lo hace. El problema viene cuando querremos grabar algo y el compilador hace lo que quiere (aparentemente,claro está) Nosotros somos los que no lo hacemos bien. Vamos a ver si es verdad lo dicho y entendemos como funciona la flash y así usarla de EEprom. Para ello vamos a usar:

write_program_eeprom (address, data); //para escribir

read_program_eeprom (address); //para leer

Para ello metemos en el programa que nos lea una posición de memoria y la grabe al final de la memoria y 0x3344 por la mitad:
ddd = read_program_eeprom(Alarm1[0]);

write_program_eeprom(0x5ff8,0x3344);
write_program_eeprom(0x7ff0,ddd);

La posición 0x5FF8 se sale del mapeado pero escribirá en la posición: 0x5FF8 / 2 = 0x2FFC . La otra: idem de lo mismo. Ejecutamos el programa y la posición 0x2FFC tiene que contener 0x44 en el octeto de menor peso y 0x33 en el de mayor peso. Vamos a verificar lo que ocurre:

Nos ha detectado el grabado. No hace falta que lo busquemos... Si! ya que vamos a realizar otra prueba:

y la otra al final:

Si todo lo dicho anteriormente es cierto: si grabamos a partir del 0x5ff9 (uno más) tiene que meter el 0x44 donde esta el 0x33 y el 0x33 dos octetos a la derecha de donde está el 0x44. Veamos al ejecutar write_program_eeprom(0x5ff9,0x3344); que ocurre:

Para empezar no está mal. El error lo da en la misma posición de memoria al verificar y se aprecia el 0x44 en el byte de mayor peso. Vamos a verlo en el mapeado:

Ahora es comprensible y ya no nos asusta que al grabar de la posición de memoria 8 a la 9 haya un poco de despiste (aparentemente lo graba al revés) y de la 9 a la A haya un mayor despiste (aparentemente se lo lleva a donde le da la gana y no es así). Espero que haya sido comprensible.

Comprendido esto ya podemos usar la directiva #rom. Ahora si sabemos como se hace y donde va a parar lo que hacemos.

#rom 0x7f18={0x1832,0x3053,0x1944,0x1f20,0x1143,0x2433,0x2631,0x3233,0x0d0a}
//FALLO DE ELCTRICIDAD pte programar 32 caracteres

#rom 0x7f28={0x1841,0x3053,0x1944,0x1f20,0x1143,0x2449,0x2641,0x1441,0x304c,0x1120
,0x1c41,0x3045,0x1e54,0x2241,0x1441,0x0a20,0x3030 ,0x0d0a}
//HA SIDO ACTIVADA LA LA ENTRADA: 0

Ahora si está controlada la cosa. Tampoco era tan dificil ¿no?

Enviar sms en formato PDU

2010-10-11T05:00:00.111+02:00

Al conectar nuestra alarma a siemens C60 se encuentra el problema del envío del sms en modo Texto. Este teléfono sólo acepta formato PDU.

Este formato parece complicado pero no lo es. Aquí tenemos las primeras pruebas enviando "Hola Mundo" al numero de teléfono 123456789.

Desglosando la trama:

00 Centro de envío del sms. Se usa el del teléfono.
11 Tipo de sms. se usa PDU.
00 Referencia sms. Es indiferente.
09 Longitud Telf destinatario. Es este caso 9
81 Tipo de Num Telf. Es nacional
21 Número de teléfono del destinatario. Como se ve hay que invertir los números
43 "
65 "
87 "
F9 "
00 Protocolo
00 Codificación
A7 Periodo de validez del sms (el máximo)
0A Número de bytes del Texto a enviar (no tiene porque coincidir una vez codificado a PDU)
C8 Texto del sms a enviar
37 "
3B "
0C "
6A "
D6 "
DD "
E4 "
37 "

Codificación del Número de teléfono a formato PDU

Por lo general lo tendremos en una cadena de caracteres. La forma más sencilla es leer el segundo caracter y restarle 0x30. Después desplazamos 4 veces a la izquierda y le sumamos el primer caracter -0x30.

               base= telefono[1]-0x30;
               base &lt;&lt;=4;
               code[xbuff++]= base+ (telefono[0]-0x30);

El número lo tenemos guardado en la cadena teléfono[] y guardamos sobre la cadena code[] para después enviar toda la secuencia. Sólo queda hacer lo mismo con los demás números hasta llegar al último que tenemos que rellenar el nibble más alto con F.

code[xbuff++]= 0xF0+ (telefono[8]-0x30);

Con esto ya tenemos el número codificado.

Codificación del Texto a enviar a formato PDU

Para moverse en código ASCII basta con 7bits por lo que se desaprovecha uno en la transmisión de bytes(8bits) El formato PDU aprovecha ese bit. Veamos como se hace:

Una forma de realizarlo, La más sencilla y comprensible es:

base = cadena[contador+1]& 0x01;

base <<=7;

code[xbuff++]=base+ cadena[contador+0]; //1

cadena[contador+1]>>=1;

base= cadena[contador+2] &0x03;

base <<=6;

code[xbuff++]=base+ cadena[contador+1]; //2

cadena[contador+2]>>=2;

base= cadena[contador+3] &0x07;

base <<=5;

code[xbuff++]=base+ cadena[contador+2]; //3

cadena[contador+3]>>=3;

base= cadena[contador+4] &0x0f;

base <<=4;

code[xbuff++]=base+ cadena[contador+3];

cadena[contador+4]>>=4;

base= cadena[contador+5] &0x1f;

base <<=3;

code[xbuff++]=base+ cadena[contador+4];

cadena[contador+5]>>=5;

base= cadena[contador+6] &0x3F;

base <<=2;

code[xbuff++]=base+ cadena[contador+5];

cadena[contador+6]>>=6;

base= cadena[contador+7] &0x7F;

base <<=1;

code[xbuff++]=base+ cadena[contador+6];

base = cadena[contador+9]& 0x01;

base <<=7;

code[xbuff++]=base+ cadena[contador+8]; //1

cadena[contador+9]>>=1;

base= cadena[contador+10] &0x03;

base <<=6;

code[xbuff++]=base+ cadena[contador+9]; //2
Ahora queda meterlo en una subrutina para poder manejar cualquier longitud de texto y simplificar lo expuesto y ya lo tenemos. No olvidar que hay que incluir otros datos antes detallados.Para ver si está correctamente configurado

Para enviarlo no queda ahí la cosa. Lo primero, al arrancar el móvil, le cargamos:

printf("AT+CSMS=0\r\n" ); //Formato PDU

Cuando deseemos enviar un sms procedemos así:

Enviamos: printf("AT+CMGS=");
Seguido de la cantidad de bytes a enviar (o la cantidad de septetos del sms +12) pero OJO en ascii y en decimal contando desde cero. Si tenemos 22 no lo podemos enviar tal cual. Hay que enviar 0x32 0x32. Ojo a eso!. Por tanto; printf("%U",22); seguido del retorno de carro; printf("\r");
Esperamos que nos devuelva ">" y le enviamos la cadena de texto (también es ascii) que tenemos: printf("00110009917689x99xFx0000AA0AC8373B0C6AD7DDE437");
seguido de ctrl+Z. o lo que es lo mismo 0x1A : printf("\x1A");
seguido de un fin de linea: printf("\r\n");

Ojo a la cadena que hemos formado que hay que enviarla en ascii. Es decir:
el primer dato de la cadena era 0x00. Por tanto hay que enviar 0x30,0x30. El segundo es 0x11. Por tanto hay que enviar 0x31,0x31. Así sucesivamente. Ojito a eso que se tiene la tendencia a enviar la cadena en hexadecimal y nos devuelve, al ratito de enviar la trama: +CMS: ERROR 500.

Rectificador Trifásico

2010-10-09T05:46:00.008+02:00

Un rectificador de tensión se realiza mediante cuatro diodos (puente Graetz). Para rectificar una red trifásica es tan sencillo como aplicar dos diodos más a dicho puente siguiendo el mismo procedimiento.

Los hay comerciales de potencia preparados para 400V y 25A.
12-01-2011 El VUO 36-12 NO8 aguanta los 1200V 35A.

Fuente de alimentación para alarma gsm con pic

2010-10-07T05:00:00.007+02:00

Después de tener la alarma funcionando calculados los consumos y vistos los reales se desecha el cargador del móvil como fuente de transformación por los armónicos que genera. Otra cosa que se desecha tras las pruebas con los módulos Telit es el móvil con batería. La fuente de alimentación que se presenta en una de las entradas soporta perfectamente los picos de comunicación con condensadores discretos (de bajo valor) y no ha presentado el LM317 calentamiento alguno incluso estando sin atornillar a la placa para una mejor disipación.

Se han colocado dos formatos de encapsulado para los estabilizadores por la sencilla razón que tengo de los dos. La disipación de calor del LM7812 y del LM 7805 si hay que tener cuidado. No dejar sin atornillar. No pasa nada pero no es recomendable. En ciertos momentos (y cargando la batería siempre) se calientan un poco. La PCB queda, del esquema, así:

Y la pcb por la cara de las pistas:

Los componentes smd son como la droga: si lo pruebas engancha. Una de las razones es la ausencia de taladros. El ruteado de pistas se complica pero se sale "al paso" mezclando los encapsulados.

No es que se tengan que montar los dos estabilizadores. O se monta uno u otro o mezclados. Lo bueno de este diseño es que tengas lo que tengas lo sacas adelante.

Como se verá en unas próximas revisiones, se ha colocado un cargador para pilas recargables NiCd y NiMH. En la foto "todo funcionando" el móvil se encuentra sin batería. La batería utilizada es de plomo. El consumo (visto en el amperímetro de la fuente) es de 90 mA con el móvil en reposo. En llamada el consumo alcanza algún pico de 300mA lo que hace que sea conveniente atornillar a la placa el LM317 por si se mantienen mucho las llamadas. LA explicación de la fuente ya la enlazaré.

Aquí lo tenemos: "todo funcionando"

A los dos reguladores 78xx se han atornillado a la placa y se ha puesto silicona térmica. En el montaje final se va a dotar de leds para el control de tensiones.

Programa del PC para comunicar con el PIC

2010-09-29T05:00:00.008+02:00

Ahora toca la programación del PC. Se realiza en C++ y se configura dependiendo del circuito que tenga conectado. En un principio la imagen pude ser algo parecido a esto:

Dependiendo de las salidas y entradas del dispositivo conectado se configura automáticamente. En una prueba de conexión con el dispositivo diseñado lo ha reconocido como: 1 entrada analógica, 6 entradas digitales y dos salidas.

La pantalla del PC muestra la siguiente imagen al conectar el dispositivo:

En esta otra está esperando para leer el micro. Este le pasa las variables cuando se sincronizan.

Al hacer clic sobre "Configurar tiempos" y hacer clic sobre una de las ventanas para cambiar un valor nos aparece otra ventana para facilitar la entrada de datos. Más o menos queda así:

Uso de dos puertos serie con un solo pic

2010-09-27T05:00:00.043+02:00

Viendo algún que otro foro queda bien explicado. El mejor el de Todopic.com. Esto implica el uso de cuatro puertas y otra para la interrupción. Esto es un despilfarro de patillas en el microcontrolador. No he encontrado nada más. Claro está que tampoco me he matado buscando.

A poco que se piense ha de poderse hacer con dos patillas: una para Tx y otra para Rx

Pensemos:

- La comunicación ha de ser del pic al móvil y viceversa y del pic al pc y viceversa.

- La transmisión del pic al móvil y al pc se puede hacer con la misma salida. Estos dos escuchan y sólo contestan si el comando es correcto.

La recepción también se puede hacer por el mismo puerto siempre que no se monten. Esto último lo puede gestionar el pic facilmente. Para poder hacerlo observamos las transmisiones. Cuando no hay nada que transmitir el valor que obtenemos a la salida del max232 y del móvil es un nivel alto. Pues con una AND lo solucionamos en un periquete. Al no disponer de ninguna se soluciona el problema con una NAND.

El puerto serie por J11 es el de comunicaciones con el PC y el J5 es el puerto de comunicaciones con el móvil. Se deja el puerto J1 para la monitorización de las tramas.

La R6 polariza la entrada a nivel alto ante la ausencia del móvil. Como no se pueden dejar entradas al aire se ha aprovechado la parte A y B. se podría conectar directamente. Usando una AND también funciona ya que dos puertas NAND montadas de esa forma hacen una....

Se ha usado un cmos (74HC00) ya que lo acepta tanto el max232 como el pic. Como el nivel alto es visto a partir de los 2V se convierte en un adaptador de tensiones para la salida del móvil.

No era tan difícil como parecía. Encima hemos ahorrado unas valiosísimas entradas/salidas. Gracias J.L. Calero por ser tan exigente como profesor. La electrónica no funciona a medias. O funciona o no funciona. Se aprende o se chapucea.

Calculando fuente alimentación: Diodo zener de protección y estabilización

2010-09-26T05:00:00.011+02:00

Para proteger nuestro circuito se ha pensado en un diodo zener ya que se alimenta de la misma fuente que sirve para cargar el móvil y la tensión es de 6V máxima en corriente continua. De ser una diferencia de tensión mayor de 2,5V se decantaría por un estabilizador 7805.

Para comenzar hacemos el circuito de las pretensiones. Consta de una entrada que puede variar entre 5,6V y 6V en la mayoría de los móviles para la carga. Una resistencia limitadora, un zener de 5,1V y la resistencia de carga (el consumo de nuestro circuito).

La intensidad que consume el circuito es de 30mA cuando está a pleno rendimiento. Para tener seguridad se puede aplicar el 20% de margen. Como se ampliará se calcula para una intensidad máxima de 60mA y así hay seguridad de sobra. La intensidad mínima vamos a colocarla en 0mA. No es la primera vez que se quita el pic u otros componentes y se aplica la alimentación. No digamos el quitar el micro sin quitar la alimentación. Toda previsión es poca.

Lo primero es aventurarse con la potencia del zener. Dispongo de de uno de 1W de potencia. Vamos a ver si nos vale. Este primer paso es aleatorio, se puede escoger cualquier potencia. Los cálculos nos darán la potencia exacta.

$Intensidad máxima zener=Potencia zener/Tensión zener = Pz/Vz$

Por tanto:

$Iz max = Pz/Vz=1W/5,1V = 0,196A$

Ahora calculamos la intensidad mínima del zener. Esta intensidad es la mínima que ha de pasar por el zener para la correcta estabilización.

$Intensidad Mínima zener=10% de la Iz max$

Eso es: Iz min es el diez por ciento de la Iz max. Por tanto:

$Iz min=10% 0,196A=0,0196A$

o lo que es lo mismo 19,6mA. Lo pasamos todo a nuestro circuito:

Ahora no hay más que calcular el valor mínimo de la resistencia limitadora ( RL ) y su valor máximo. Para ello están estas dos fórmulas;

$RL max=Tensión entrada mínima-Tensión del zener/Intensidad zener mínima+Intensidad R Carga máxima$

$RL min=Tensión entrada máxima-Tensión del zener/Intensidad zener máxima+Intensidad R Carga mínima$

Sustituyendo:

$RL max=Vp min-Vz/Iz min+IRC max=5,6V-5,1V/0,0196A+0,06A=0,5V/0,0796A=6,28Ohms$

$RL min=Vp max-Vz/Iz max+IRC min=6V-5,1V/0,196A+0A=0,9V/0,196A=4,59Ohms$

Ya tenemos un valor para la Resistencia Limitadora máximo y mínimo. Ahora hay que interpretar esto y los posibles resultados que nos pueda dar.

Si el valor de la Resistencia Limitadora mínima es mayor que la RL máxima hay que recalcular con una potencia de zener mayor. Es lógico que la Rmínima nunca puede ser mayor que la máxima.
Si la diferencia entre las dos resistencias es pequeña (como es el caso): recalcular con una potencia de zener mayor. Claro que funciona pero hay que garantizar los circuitos con márgenes de seguridad.

Rebuscando he encontrado otro de 2W (aprox. por el tamaño ya que no se ve la referencia). Recalculamos de nuevo todo:

$Iz max = Pz/Vz=2W/5,1V = 0,392A$
$Iz min=10% 0,392A=0,0392A$
$RL max=Vp min-Vz/Iz min+IRC max=5,6V-5,1V/0,0392A+0,06A=0,5V/0,0392A=12,755Ohms$
$RL min=Vp max-Vz/Iz max+IRC min=6V-5,1V/0,392A+0A=0,9V/0,392A=2.296Ohms$

Parece que la diferencia ha aumentado por tanto hay mayor seguridad.

Para escoger la R Limitadora nos vamos al valor central que es de 8,189Ohms El valor normalizado más cercano (por arriba o por debajo no importa ya que tenemos bastante seguridad) es: 8,2Ohm. También valdría 6,8Ohm ó 9,1Ohm

¿Seguro que funciona? Vamos a verlo. Siempre es conveniente asegurarse. Para ello:

$Intensidad max por RL= 6V-5,1V/8,2Ohm=0,109A$

$Intensidad min por RL= 5,6V-5,1V/8,2Ohm=0,0487A$

No se sobrepasa la intensidad máxima y pasa más de la Intensidad mínima. El valor de 8,2 Ohmios es correcto.

Ahora queda el último paso y por tanto cálculo: La potencia necesaria para la R Limitadora. Para ello:

$Potencia RL=I max RL * Caída tensión RL max= 0,109A * 0.9V=0,0981W$

Le aplicamos un margen de seguridad del 20% más y vemos que con un cuarto de watio es más que suficiente.

Como las fuentes basadas en zener tienen un consumo continuo y por tanto más elevado del que consume el circuito, queda descartado para este diseño. La caída se provoca por un diodo 1N4007. La fuente se calculará para 5,7V estabilizados.

Pcb de Alarma gsm con pic 16F876 a 20 Mhz

2010-09-24T05:00:00.029+02:00

Como siempre, al mismo tiempo que se trabaja en el proyecto, van saliendo formas para realizar algo mucho mejor. En esta ocasión se deja sin la parte analógica. Se coloca una base para poder soldar y realizar prototipos. El esquema se esta pcb

Se ha intentado realizar a una sola cara. Las pistar de la parte de los componentes ( Top, en rojo) pueden sustituirse por puentes. De esta forma la pcb cuesta menos dinero. Algunos conectores ( Jxx) son diodos de señalización. Ahora me doy cuenta que debería montarse un led para señalizar la alimentación (siempre se puede mejorar cualquier diseño). El primer prototipo, que va a ser para las pruebas definitivas, quedará así:

Se ha usado smd para el puerto serie y se han eliminado los transistores. Colocando unas NAND se pude contolar la comunicación con dos puertos serie. Uno para la comunicación con el móvil y otro para comunicarse con el PC. También vale para el ajuste de tensiones del móvil. Las entradas se han opto acoplado y filtrado para poder conectar volumétricos (detectores de movimiento). Se colocará un receptor de 433 Mhz para poder conectar inalámbricos.

Las pistas quedarán así:

Y hay que ponerse manos a la obra. Si funcionaba en la protoboar (ver entrada) ahora tiene que funcionar de maravilla. De hecho lo hace a las mil maravillas.

Placa realizada con el método de la plancha

Con los puentes soldados:

A falta del conector USB y sus condensadores ya que vamos a finalizarlo con el 16F876. Implementarlo a otro micro es sencillo.

No consigue enfocar correctamente la cámara. Asi se medio ven los componentes smd:

Aquí lo tenemos todo funcionando:

Problemas al usar la flash del pic como EEprom.

2010-09-21T05:00:00.055+02:00

Al intentar usar la fash como memoria EEprom de dos bytes vienen los problemas. El de mayor peso no es de 8 bits. Por eso al leer los bancos de memoria aparece 3FFF en los bytes vacios. Al intentar guardar los textos que se han de enviar: o se usan como un solo byte (se desperdicia un montón de memoria) o empleamos mayúsculas.

El valor menor que se usa es 0x30 (por si enviamos números) y el máximo es 0x5A (Z). Al programar le restamos 0x30 al valor que vaya al byte de mas peso y al leer le sumamos otros tantos (0x30) Es una forma sencilla de salir del paso. Cuando coincide el espacio en el byte alto (espacio=0x20) hay que colocar el valor 0x30. Al detectarlo, el programa envía el 0x20. Para terminar usaremos 0x0D0A que indicará que la frase ha llegado a su fin.

     Notas para el 16F876. Para otros micros hay que variar la dirección de memoria.
     Para grabar la EEprom interna desde el programa: #rom
          Para grabar en la última línea de la EEprom:
              #rom 0x21F8={0x00,0x00,0x00,0x00,0x00,0x00,0X00,0x00}
     Para grabar en la Flash desde el programa: #rom
          Para grabar en la última linea de la flash:
              #rom 0x1FF8={0x0011,0x0111,0x0211,0x0311,0x0411,0x0511,0x0611,0x0711}
     Para grabar el ID desde el programa: #rom
              #rom 0x2000={0x00,0x01,0x02,0x03}

     Para leer y grabar cualquiera de las memorias usaremos:
       read_program_eeprom(0x1ff8); // leerá la posición de memoria 0x1FF8 que pertenece a la Flash
       write_program_eeprom(0x1ff8,0x1221); // grabará 0x1221 en la posición 0x1FF8 de la Flash
       read_eeprom(0x2100); // lee la posición 0x00 de la EEprom interna del pic.
       write_eeprom(0x2100,0x12); grabará 0x12 en la posición 0x00 de la EEprom interna.

Hiper Terminal y el problema con Fbus

2010-09-18T19:13:00.004+02:00

A la hora de comunicar un microcontrolador con otro dispositivo por 232 es sencillo. El problema se tiene a la hora de interpretar todo lo que nos llega. Muchas pruebas se realizan con el Hiper Terminal de windows u otros programas similares. Estos programas van bien cuando el envío o recepción son códigos ASCII.

Supongamos una transmisión en hexadecimal. Intentamos enviar desde el microcontrolador la siguiente trama:

00 01 02 03 04 05 06

¿Qué aparece en el Hiper terminal? ¿Qué hace con los 00? ¿Configurar el Hiper Terminal?

Lo mejor es hacerse uno mismo un programa que se adapte a sus necesidades

Está desarrollado en C++ con Borland 2006 en un rato (falta por depurar) se conecta al terminal y hace las veces de pic. Modificando unas cuantas cosas recoge las tramas enviadas del pic al móvil. En la parte superior aparecen los valores en hexadecimal y abajo en ASCII.

Nokia y sus tramas FBUS

Los Nokia envían tramas Fbus al conectarse y desconectarse. Las tramas siguientes pertenecen al 6100.

-Al encender se suceden dos tramas. La primera:

55 55 55 55 55 55 55 55 1E FF 00 D0 00 03 01 01 E0 00 FF 2D.

y poco después:

1E FF 00 15 00 08 00 33 00 C0 01 04 01 C1 1E D4

-Al apagar:

55 55 55 55 55 55 55 55 1E FF 00 15 00 08 00 33 00 C0 00 04 01 C2 1F D7 00

- Al encender el móvil cargando se suceden dos tramas:

55 55 55 55 55 55 55 55 1E FF 00 D0 00 03 01 01 E0 00 FF 2D

1E FF 00 15 00 08 00 33 00 C0 01 04 01 C1 1E D4

- Al apagar el móvil cargando se suceden dos tramas:

55 55 55 55 55 55 55 55 1E FF 00 D0 00 03 01 01 E0 00 FF 2D

1E FF 00 15 00 08 00 33 00 C0 02 04 01 C1 1D D4

Claro que estando apagado sucede esto:

-Estando apagado, se conecta el cargador y se suceden dos tramas

55 55 55 55 55 55 55 55 1E FF 00 D0 00 03 01 01 E0 00 FF 2D

1E FF 00 15 00 08 00 33 00 C0 02 04 01 C1 1D D4

-Estando apagado, se desconecta el cargador

55 55 55 55 55 55 55 55 1E FF 00 15 00 08 00 33 00 C0 00 04 01 C2 1F D7 00

El programa tendrá en cuenta algunas tramas y de esta forma sabrá si se ha desconectado o conectado. El problema viene cuando se le envían comandos AT. En la desconexión no envía nada. El programa se encargará de detectar la desconexión.

Empezando: Encender los móviles sin batería. Sólo con una fuente de alimentación

2010-09-15T21:51:00.018+02:00

El móvil usado es un Nokia 6100. El programa está realizado para una tarjeta prepago de Movistar para el uso de las respuestas sms que genera por saldo, no disponible, etc.

Se puede adaptar a cualquier proveedor. Con ver los sms que se retornan es suficiente.

Para ver si funciona y que pase las pruebas radioeléctricas no hay nada como hacer un circuito con mucho cuidado y siguiendo unas reglas básicas. De no seguirlas es probable que de problemas.

Si, como a continuación se muestra, se monta en una placa para prototipos y funciona la cosa "pinta" bien. De hecho lo hace. Todas las pruebas se han realizado ahí.

Para empezar vamos a poner en marcha el móvil con una fuente de alimentación y así poder prescindir de la batería y la carga de la misma. No es necesario pero de esta forma se pueden reutilizar móviles.

El móvil se alimenta de la batería. Alimentando con una fuente de alimentación hay que tener en cuenta los picos de consumo que realiza al establecer comunicación. Los picos son elevados, unos 2 amperios, pero de corto intervalo. Por ello con una fuente de 1 amperio es más que suficiente. Para evitar problemas hay que colocar un condensador electrolítico de 2.200 uF (micro faradios) cerca de la toma de la batería. Colocando uno mayor se tendrán menos problemas. Ahora falta engañar al cargador interno del móvil. El terminal central de la batería se encarga de controlar la temperatura de carga. Colocando dos resistencias en serie de 33k entre el terminal central y el negativo arranca sin problemas. El valor es debido a que no tenia otras a mano. Recordar que esto se ha montado con piezas que voy teniendo por el taller. Lo cierto es que ha arrancado perfectamente un Nokia y un Siemens. De no arrancar la solución es colocar un potenciómetro ajustable e ir variando el valor entre 33k y 80k aproximadamente. Luego se mide el valor y se coloca una fija. De no tener el valor: ver el más aproximado, medir el valor en el ajustable y probar. Alimentando con 4V el indicador del móvil es del 95%. EL VALOR DE la resistencia 33K ha se sustituirse por el de 66K.

Se puede aplicar 3,7 V incluso 3,6V. Con una fuente de alimentación estabilizada de 5V, colocando dos diodos en serie ( 0,7V + 0,7V) Es suficiente caída de tensión. El 1n4007 funciona bien ya que los picos no le afectan. Tampoco hay que pasarse con el tamaño del condensador ya que eso podría destruir los diodos. Un condensador descargado es visto como un cortocircuito. (Esto se podrá calcular, ya se enlazará cuando se calcule la fuente de alimentacíon).