hardrive9000

Al momento de programar una placa Arduino que no incluya un chip FTDI (Arduino Pro Mini, Flora, Arduino Mini Light 05, etc.) debemos utilizar un Adaptador USB - UART TTL para programar la placa. Si bien existen muchos adaptadores en el mercado, existe un modelo en particular que se destaca por ser mucho mas económico que los otros y utiliza el chip CP2102 fabricado por Silicon Labs. La placa del Adaptador USB - UART TTL se observa en la siguiente imagen: Lamentablemente, este adaptador no funciona correctamente en forma directa, sino que debemos realizar una pequeña modificación en la placa para poder utilizarlo. El problema es el siguiente, la característica de reinicio automático, que reinicia la placa Arduino luego de cargado el programa, no funciona. Esto se debe a que el pin de "Reset" (RST) del adaptador no corresponde verdaderamente a la señal de "Reset", sino que es un pin de entrada, es decir, se utiliza para reiniciar el chip CP2102, pero no es la señal de "Reset" que necesitamos para reiniciar nuestra placa. La señal de reinicio que necesita nuestra placa Arduino corresponde a un pad en la placa del adaptador rotulado "DTR" como se observa en la siguiente imagen: CP2102 Datasheet Por lo tanto, deberemos soldar un pin para así tener disponible la señal que necesitamos. En este caso he utilizado un cabezal macho de 1 X 4 pines (2.54mm) como se observa en la siguiente imagen: La conexión del adaptador a la placa Arduino Pro Mini es la siguiente: CP2102 USB UART TTL --> Arduino Pro Mini GND --> GND RXD --> RXI TXD --> TX0 DTR --> DTR 3.3V o 5V --> VCC CP2102 Driver Finalmente, en el IDE de Arduino seleccionamos la placa y el puerto serie correspondiente, luego cargamos un sketch de prueba, como "Blink", para verificar el correcto funcionamiento.

En publicaciones anteriores compartí con ustedes 2 (dos) circuitos amplificadores de audio con el circuito integrado LM386 (ver Amplificador de Audio LM386 o Amplificador de Audio LM386 v2). En esta publicación veremos cómo construir un amplificador de audio (Clase AB) estéreo con el circuito integrado TDA7297, el cual entrega una potencia de salida de 15W + 15W RMS, ideal para usar con la PC, laptop, tablet, MPx, etc. dada su alta impedancia de entrada (30KΩ). TDA7297 Datasheet El circuito tiene como elemento principal un circuito integrado TDA7297, en el cual se han agrupado todos los componentes necesarios para conformar una etapa de potencia de audio, internamente consta de dos amplificadores, cada uno en configuración "puente". Como puede observarse la cantidad de componentes externos es mínima, además cuenta con funciones de "Stand-By" y "Silencio", protección contra corto circuitos y protección contra exceso de temperatura. El rango de alimentación es amplio, desde 6V hasta 18V. Dentro de ese rango se encuentran los 12V que nos proporciona generosamente la fuente de la PC y dado que el consumo ronda los 2A a plena potencia, podemos alimentar el circuito con una fuente actual sin mayores inconvenientes. El circuito integrado debe ser dotado de un disipador de calor como se observa en la imagen de abajo. La grasa siliconada debe aplicarse en su justa medida (con una capa delgada es suficiente), ya que en exceso produce el efecto contrario. Además puede incluirse un led indicador de encendido del color y/o brillo que deseemos con una resistencia acorde al mismo. Ver Amplificador de Audio TDA7297 Lista de Componentes 1 Circuito Integrado TDA7297 1 Potenciómetro estéreo 50KΩ Logarítmico (A) [sin llave, para PCB] 1 Capacitor Electrolítico 10uF x 25V 2 Resistencias 47KΩ 0.25W 2 Capacitores 220nF x 100V [poliéster] 1 Capacitor Electrolítico 2200uF x 25V 1 Capacitor 100nF x 250V [poliéster] 1 Disipador de Calor Opcional 1 Resistencia 1.5KΩ 0.25W 1 LED a elección (indicador de encendido) A continuación se encuentra el PCB en escala 1:1 (el documento PDF debe ser impreso con la escala al 100%), el cual se encuentra listo para la aplicación por transferencia térmica (método "de planchado" ). Además se encuentra la vista de disposición de los componentes (layout) como información complementaria. Amplificador de Audio TDA7297 PCB Amplificador de Audio TDA7297 Layout

Actualmente, cuando realizamos proyectos que requieren cierto nivel de flexibilidad, pensar en utilizar un microcontrolador siempre es una buena idea y, siempre que el proyecto lo requiera, es interesante la aplicación de un RTC, es decir, un reloj en tiempo real. Además debo admitir que desde mi infancia tengo un interés muy particular en los relojes y la medición del tiempo. Si bien podemos adquirir el módulo armado, en esta publicación veremos cómo construir nuestro propio RTC dada su simplicidad y el reducido número de componentes necesarios. El circuito integrado que utilizaremos será el DS1307, fabricado actualmente por Maxim y Cypress. Su consumo de energía es bajo, dispone de reloj y calendario (ambos codificación BCD) con ajuste de año bisiesto hasta el año 2100 y ajuste automático de fin de mes (para meses con menos de 31 días). El reloj, por su parte, opera en formato de 12/24 horas (configurable) con indicador de AM/PM en caso de operar en formato de 12 horas. Además, el circuito integrado dispone de 56 bytes de memoria SRAM de escritura ilimitada y un pin de salida con señal lógica programable (pin 7: SQW/OUT). Presentado el componente principal de nuestro proyecto, observamos en la siguiente imagen el circuito: DS1307 Datasheet Como puede verse en el circuito, la cantidad de componentes externos es mínima. Las resistencias y el capacitor cerámico pueden adquirirse en cualquier comercio de electrónica y con respecto al cristal de cuarzo de 32768 kHz, recomiendo obtenerlo de un reloj (bastante lógico no?) en desuso ya que suelen ser más precisos y estables. En mi caso particular, al cristal lo obtuve de un reloj de pared en desuso como puede observarse en la siguiente imagen: La conexión de los pines de salida del DS1307 a la placa Arduino UNO es la siguiente: DS1307 --> Arduino UNO SDA(Pin 5) --> Arduino UNO (Pin A4) SCL(Pin 6) --> Arduino UNO (Pin A5) La alimentación para este circuito puede obtenerse directamente de la placa Arduino UNO. Existe en dicha placa un terminal que provee 5V. En la siguiente imagen se observa el reloj ya armado: Antes de continuar, recomiendo una lectura profunda y analítica de la hoja de datos del circuito integrado DS1307. Habiendo interconectado exitosamente nuestro reloj con la placa Arduino procederemos a escribir el programa cuya función será controlar nuestro reloj, nos permitirá: establecer fecha y hora, consultar fecha y hora, controlar el pin SQW/OUT y hacer un volcado de toda la memoria. Si bien existe una gran cantidad de librerías para controlar el DS1307, escribiremos nuestro propio programa con fines didácticos y además economizar recursos que a veces son desperdiciados con el uso de grandes librerías de las cuáles sólo necesitamos un par de funciones. En primer lugar, necesitamos comunicarnos con nuestro reloj a través del bus I2C, afortunadamente Arduino proporciona la librería "Wire" que nos permitirá comunicarnos con dispositivos I2C. En segundo lugar debemos conocer los registros y direcciones de memoria del DS1307. Los registros y sus direcciones se observan en la siguiente imagen: Podemos dividir la memoria del DS1307 en 3 (tres) segmentos: 1) 00h-006h: Registros de Fecha y Hora (resaltado amarillo). 2) 07h: Registro de Control (resaltado verde). 3) 08h-03Fh: RAM 56 bytes. Registros de Fecha y Hora El contenido de los registros de fecha y hora se almacena en codificación BCD. El registro "Día de la semana" (03h) se incrementa a la medianoche, el rango de valores es de 01-07 y la correspondencia con los días de la semana la define el usuario. El bit 7 del primer registro (00h) detiene o inicia el reloj, cuando el bit se establece en 1 se desactiva el oscilador, cuando el bit se establece en 0 sucede lo contrario. Inicialmente, el oscilador se encuentra desactivado (CH=1) y los registros de fecha y hora se inician con la fecha 01/01/00 01 00:00:00. El bit 6 del registro de hora (02h) permite seleccionar formato de 12/24 horas. En caso de seleccionar el formato de 24 horas (nuestro caso), el bit 5 del registro de hora (02h) nos indicará la veintena (20 a 23 horas). Cada vez que cambiemos el formato de 12/24 horas deberemos volver a introducir la hora. Por último, el ingreso de valores inválidos de fecha y hora darán como resultado un comportamiento inesperado. Registro de Control El registro de control (07h) se utiliza para controlar la operación del pin de salida SQW/OUT (pin 7). En la siguiente tabla observamos los posibles valores con sus respectivos resultados. He resaltado la frecuencia de 1Hz. No es menos importante señalar que puede obtenerse una frecuencia de 32768 kHz (la misma del cristal) con la cual podríamos, por ejemplo, poner en funcionamiento otro DS1307 sin necesidad de un segundo cristal. Memoria RAM Por último, disponemos de 56 bytes de SRAM para utilizarla según nuestras necesidades particulares. Son demasiadas las aplicaciones como para enumerarlas. El programa que permite controlar nuestro reloj es el siguiente: /* * Comandos: * T(00-59)(00-59)(00-23)(1-7)(01-31)(01-12)(00-99) * (segs )(mins )(hora )(dia)(dMes )(mes )(anio ) * Ejemplo, establecer fecha y hora: 19-Ago-13 @ 15:32:11 del dia 1 (Lunes) de la semana. * utilizar el comando: T1132151190813 * * W(0-5) Establece SQW/OUT 0=0|1=1|2=1Hz|3=4096kHz|4=8192kHz|5=32768kHz * Ejemplo, establecer la salida SQW/OUT en 1Hz * utilizar el comando: W2 * * Q Consultar fecha y hora * * D Volcado de Memoria * * NOTA: La norma ISO 8601 (convención internacional que indica el orden de los días de la semana) establece que la semana comienza el Lunes. */ #include <Wire.h> #define DS1307_I2C_ADDRESS 0x68 //Direccion DS1307 #define DS1307_TIMEKEEPER_REGISTERS 7 //Cantidad de registros de Fecha y Hora #define DS1307_BASE_ADDRESS 0x00 //Registro 00h #define DS1307_CTRLREG_ADDRESS 0x07 //Registro de control #define DS1307_MEMORY 64 //Total de memoria // Convertir valores decimales a valores BCD byte decToBcd(byte val) { return ((val / 10 * 16) + (val % 10)); } //Convertir valores BCD a valores decimales byte bcdToDec(byte val) { return ((val / 16 * 10) + (val % 16)); } //Convertir valores ASCII a valores decimales byte asciiToVal(int tens, int units) { return ((byte)((tens - 48) * 10 + (units - 48))); } //Establecer fecha DS1307 void setDateDs1307(int* buffer) { byte rtcDate[DS1307_TIMEKEEPER_REGISTERS]; rtcDate[0] = asciiToVal(buffer[0], buffer[1]); //segundos rtcDate[1] = asciiToVal(buffer[2], buffer[3]); //minutos rtcDate[2] = asciiToVal(buffer[4], buffer[5]); //horas rtcDate[3] = asciiToVal(48, buffer[6]); //dia de la semana rtcDate[4] = asciiToVal(buffer[7], buffer[8]); //dia del mes rtcDate[5] = asciiToVal(buffer[9], buffer[10]); //mes rtcDate[6] = asciiToVal(buffer[11], buffer[12]); //anio Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.write(DS1307_BASE_ADDRESS); Wire.write(decToBcd(rtcDate[0])); Wire.write(decToBcd(rtcDate[1])); Wire.write(decToBcd(rtcDate[2])); Wire.write(decToBcd(rtcDate[3])); Wire.write(decToBcd(rtcDate[4])); Wire.write(decToBcd(rtcDate[5])); Wire.write(decToBcd(rtcDate[6])); Wire.endTransmission(); } //Obtener fecha DS1307 byte* getDateDs1307() { byte* rtcDate = (byte*) malloc(DS1307_TIMEKEEPER_REGISTERS * sizeof(byte)); Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.write(DS1307_BASE_ADDRESS); Wire.endTransmission(); Wire.requestFrom(DS1307_I2C_ADDRESS, DS1307_TIMEKEEPER_REGISTERS); rtcDate[0] = bcdToDec(Wire.read() & 0x7f); rtcDate[1] = bcdToDec(Wire.read()); rtcDate[2] = bcdToDec(Wire.read() & 0x3f); rtcDate[3] = bcdToDec(Wire.read()); rtcDate[4] = bcdToDec(Wire.read()); rtcDate[5] = bcdToDec(Wire.read()); rtcDate[6] = bcdToDec(Wire.read()); return rtcDate; } //Establecer SQW/OUT void setSqwOutput(int out) { byte control; switch(out) { case '0': { control = 0x00; //SQWOUT = 0 break; } case '1': { control = 0x80; //SQWOUT = 1 break; } case '2': { control = 0x10; //SQWOUT = 1Hz break; } case '3': { control = 0x11; //SQWOUT = 4096kHz break; } case '4': { control = 0x12; //SQWOUT = 8192kHz break; } case '5': { control = 0x13; //SQWOUT = 32768kHz break; } default: { control = 0x00; //SQWOUT = 0 break; } } Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.write(DS1307_CTRLREG_ADDRESS); Wire.write(control); Wire.endTransmission(); } //Mostrar fecha con formato String showDate(byte* rtcDate) { String fullDate; if (rtcDate[2] < 10) { fullDate.concat("0"); } fullDate.concat(rtcDate[2]); fullDate.concat(":"); if (rtcDate[1] < 10) { fullDate.concat("0"); } fullDate.concat(rtcDate[1]); fullDate.concat(":"); if (rtcDate[0] < 10) { fullDate.concat("0"); } fullDate.concat(rtcDate[0]); fullDate.concat(" "); if (rtcDate[4] < 10) { fullDate.concat("0"); } fullDate.concat(rtcDate[4]); fullDate.concat("/"); switch (rtcDate[5]) { case 1: { fullDate.concat("Ene"); break; } case 2: { fullDate.concat("Feb"); break; } case 3: { fullDate.concat("Mar"); break; } case 4: { fullDate.concat("Abr"); break; } case 5: { fullDate.concat("May"); break; } case 6: { fullDate.concat("Jun"); break; } case 7: { fullDate.concat("Jul"); break; } case 8: { fullDate.concat("Ago"); break; } case 9: { fullDate.concat("Sep"); break; } case 10: { fullDate.concat("Oct"); break; } case 11: { fullDate.concat("Nov"); break; } case 12: { fullDate.concat("Dic"); break; } default: { fullDate.concat("Err_mes"); break; } } fullDate.concat("/"); fullDate.concat("20"); if (rtcDate[6] < 10) { fullDate.concat("0"); } fullDate.concat(rtcDate[6]); fullDate.concat(" Hoy es:"); switch (rtcDate[3]) { case 1: { fullDate.concat(" Lunes"); break; } case 2: { fullDate.concat(" Martes"); break; } case 3: { fullDate.concat(" Miercoles"); break; } case 4: { fullDate.concat(" Jueves"); break; } case 5: { fullDate.concat(" Viernes"); break; } case 6: { fullDate.concat(" Sabado"); break; } case 7: { fullDate.concat(" Domingo"); break; } default: { fullDate.concat("Err_dia"); break; } } return fullDate; } //Obtener volcado de memoria byte* getMemoryDump() { byte* dump = (byte*) malloc(DS1307_MEMORY * sizeof(byte)); Wire.beginTransmission(DS1307_I2C_ADDRESS); Wire.write(DS1307_BASE_ADDRESS); Wire.endTransmission(); Wire.requestFrom(DS1307_I2C_ADDRESS, DS1307_MEMORY); for (int i = 0; i < 64; i++) { dump = Wire.read(); } return dump; } void setup() { Wire.begin(); Serial.begin(57600); } void loop() { if (Serial.available()) { byte* rtc; int command = Serial.read(); switch(command) { case 'T': { delay(50); int i = 0; int buffer[13]; while(Serial.available() && i < 14) { buffer = Serial.read(); i++; } setDateDs1307(buffer); rtc = getDateDs1307(); Serial.println(showDate(rtc)); free(rtc); break; } case 'Q': { rtc = getDateDs1307(); Serial.println(showDate(rtc)); free(rtc); break; } case 'D': { rtc = getMemoryDump(); for (int i = 0; i < 64; i++) { Serial.print(i); Serial.print(":"); Serial.println(rtc, HEX); } free(rtc); break; } case 'W': { delay(50); if(Serial.available()) { command = Serial.read(); setSqwOutput(command); } break; } default: { Serial.println("Comando no valido."); break; } } } } Lógicamente es perfectible y cada uno puede adaptarlo a sus necesidades particulares.

Cualquiera que haya experimentado con la puesta a punto o el diagnóstico de un circuito digital apreciará la utilidad del instrumento que en este proyecto se propone. La punta lógica que resulta del ensamblado de este proyecto, permite establecer en forma audible el nivel lógico de un punto en un circuito digital sin que sea necesario retirar la vista del circuito para observar el resultado de la prueba en el instrumento. Descripción La punta lógica sensa el estado, alto o bajo, del punto bajo prueba, y emite en respuesta un tono audible de alta o baja frecuencia (agudo/grave) que permite identificar fácilmente el nivel lógico del punto de interés. Para niveles lógicos de 5V la frecuencia del tono es de 2.5kHz, y para niveles de 0V la frecuencia del tono es de 1.4kHz. Si el punto bajo prueba presenta condición de abierto, alta impedancia, la punta ignora el nivel de voltaje sensado y no emite señal audible alguna. El instrumento, además, opera a partir del voltaje de polarización del circuito bajo prueba, por lo cual no requiere de fuente de alimentación propia. Por su forma de construcción, puede ser utilizado tanto en circuitos TTL como en CMOS. El parlante utilizado es del tipo piezoeléctrico, lo que hace que esta punta lógica sea liviana y muy compacta. Funcionamiento El voltaje sensado por la punta de prueba (la sonda) es presentado a dos comparadores que se encargan de establecer la condición lógica del punto bajo prueba. El resultado de la comparación da origen a tres posibilidades claramente definidas. Por un lado, puede resultar que el punto sensado se ubique dentro del rango de voltajes que lo catalogue como alto, lo que además produce la activación del oscilador de alta frecuencia. Por el contrario, puede suceder que el resultado de la comparación establezca que el nivel de voltaje sensado se ubique en el rango de los voltajes bajos y, en consecuencia, será el oscilador de baja frecuencia el que se active. Si los comparadores de entrada determinan que el nivel sensado no cumple los requisitos que lo cataloguen como alto o como bajo, no se producirá la activación de ninguno de los osciladores y la punta lógica permanecerá en silencio, indicando la condición de voltaje anormal en el circuito. Como complemento a la anterior lógica de verificación de nivel y activación de osciladores, se dispone de un amplificador sencillo de audio y de un transductor piezoeléctrico que hace las veces de parlante. La lógica de detección de niveles está conformada por los dos amplificadores operacionales demarcados como A y B. La red de resistencias R3, R4 y R5 determinan los puntos de umbral para cada uno de los comparadores. El punto de ingreso de la sonda, P, se conecta al circuito a través de las resistencias R1 y R2, las cuales se encargan de establecer un nivel de voltaje exactamente igual a la mitad del voltaje de operación del circuito de la punta, por lo cual, cuando la sonda está al aire, el voltaje que llega a los dos comparadores se ubica justo a medio camino entre los niveles alto y bajo, por lo cual el resultado de la comparación no es alto ni bajo, inhibiendo así la operación de los osciladores de generación de tono audible. Las salidas de los comparadores del LM393 son de colector abierto, por lo cual es necesario el uso de las resistencias de pull-up R6 y R7. La salida de cada uno de los dos comparadores es la entrada de habilitación de los osciladores controlados, los cuales se implementan a partir de disparadores Schmitt con resistencia de alimentación para forzar la oscilación del circuito cuando su entrada de habilitación es uno lógico. La constante de tiempo del oscilador superior es de 1 milisegundo y la del oscilador inferior es de 2 milisegundos, lo que resulta en frecuencias aproximadas de operación de 1kHz y 500Hz respectivamente. Las compuertas Schmitt conectadas con sus entradas en corto proveen aislamiento (hacen las veces de buffer) entre los circuitos de oscilación y el amplificador de potencia. Los diodos D2 y D3 están conectados para operar como una compuerta OR discreta, permitiendo que la salida de cualquiera de los dos osciladores tenga acceso al amplificador de audio. Este último no es más que un transistor operando en modo de saturación y corte para amplificar en corriente los pulsos emitidos por cualquiera de los dos osciladores. El diodo D1 evita daño a la punta en caso de conectarse invertida a la polarización del circuito en prueba. Ver Punta Lógica Audible Lista de Componentes 1 Circuito Integrado LM393 1 Circuito Integrado CD4093 1 Transistor PN2222A 2 Resistencias 120KΩ 0.25W 2 Resistencias 47KΩ 0.25W 1 Resistencia 33KΩ 0.25W 3 Resistencias 10KΩ 0.25W 2 Resistencias 100KΩ 0.25W 1 Resistencia 10Ω 0.25W 3 Capacitores Cerámicos 10nF x 50V 1 Capacitor Electrolítico 47uF x 50V 3 Diodos 1N4148 1 Buzzer Piezoeléctrico 12V [sin oscilador] 1 Punta de Prueba Metálica

Hace aproximadamente tres meses compartí con ustedes la primera versión de este TV-B-Gone utilizando como base de desarrollo la placa Arduino Pro Mini (5V/16MHz). Si bien es completamente funcional y el diseño es reducido, no alcanza a ser lo suficientemente discreto en ciertos lugares donde podemos ser continuamente observados por cierto público perspicaz. No debemos olvidar que, si bien el conjunto es pequeño, éste emplea una fuente de alimentación externa, en este caso se trata de un conjunto de cuatro baterías AAA (conectadas en serie) que reducen la discreción de nuestro TV-B-Gone. El análisis realizado en el párrafo anterior, me llevó a revisar nuevamente la teoría y principio de funcionamiento de este dispositivo. La versión original utiliza como base de desarrollo el microcontrolador ATtiny85, el cual dispone de 8KB de memoria flash y, para este caso, se ha fijado su frecuencia de reloj en 8MHz con oscilador externo. Otra característica importante a tener en cuenta en la versión original, es su tensión de alimentación de 3V, lo cual nos llevaría a reducir drásticamente las dimensiones de nuestra fuente de alimentación y emplear una batería tipo "botón", como la ampliamente conocida CR2032 utilizada en las motherboards. Luego, para continuar reduciendo aún más el diseño en aras de la discreción, he reducido el número de LED's infrarrojos a solamente uno. El siguiente punto de análisis fue el uso de un oscilador externo, ya que la presencia del mismo ocupa un pequeño espacio adicional en nuestra placa. Ventajas de utilizar un oscilador externo: • Es más preciso y presenta menos variaciones que el oscilador RC interno que posee el microcontrolador, lo cual puede marcar la diferencia en el correcto funcionamiento. Desventajas de utilizar un oscilador externo: • Pequeño costo adicional. • Ocupa un pequeño espacio adicional. • Agrega una pequeña complejidad a las conexiones. En particular, recomiendo imperativamente el uso de un oscilador externo en la medida de lo posible, salvo ciertas situaciones extremas como las ocurridas durante el desarrollo de este proyecto, a saber: • Inexistencia de resonador cerámico de 8MHz en las casas de electrónica de mi localidad y zonas aledañas. • Cristal de cuarzo de 8MHz encapsulado HC49/U únicamente (grandes dimensiones para nuestra pequeña placa). Los inconvenientes analizados en el párrafo anterior me llevaron a realizar pruebas de funcionamiento utilizando el oscilador RC interno de 8MHz que posee el microcontrolador y dichas pruebas resultaron exitosas bajo diferentes condiciones y, particularmente, me sorprendió la estabilidad del oscilador RC interno. No debemos olvidar que, por su naturaleza, un oscilador RC presenta variaciones de acuerdo al voltaje y temperatura de funcionamiento. Con el análisis realizado anteriormente, el diagrama esquemático de nuestro pequeño TV-B-Gone se observa en la siguiente imagen: Lista de Componentes 1 Microcontrolador ATtiny85-20PU 1 Pulsador tipo “push button” 6mm [4 terminales] o Interruptor SPST pequeño. 1 Transistor PN2222A 1 LED IR 5mm 940nm haz angosto [de apariencia blanco] 1 LED Rojo 3mm difuso [opcional ] 1 Resistencia 1KΩ 0.25W [opcional ] 1 Resistencia 150Ω 0.25W 1 Capacitor Electrolítico 100uF 16V 1 Capacitor Cerámico 100nf 50V 1 Portapilas para batería CR2032 Antes de comenzar con el montaje debemos realizar la carga del firmware correspondiente a nuestro microcontrolador. Utilizaremos el firmware provisto por Adafruit Industries para su kit TV-B-Gone de código abierto. Descargaremos el firmware correspondiente a la versión 1.1, ya que se adapta perfectamente a nuestro diseño. Autor: Adafruit Industries Web: www.adafruit.com Tamaño: 18887 SHA1 Hash: 8EE3E4CE97DFA2151692DA9E392D565618161F8E Descarga Del archivo “tvbgone11.zip” descargado anteriormente, debemos extraer el archivo “tvbgone.hex”. A continuación, debemos descargar e instalar el software WinAVR, el cual nos permitirá cargar en nuestro microcontrolador firmware descargado anteriormente. El lector perspicaz, ya inferirá que utilizaremos nuestra placa Arduino como programador para cargar el firmware en nuestro microcontrolador ATtiny85. Para ello, debemos lanzar el IDE de Arduino y, en la barra de menú seleccionamos “Archivo” --> “Ejemplos” --> “ArduinoISP”. A continuación, desplegamos el menú "Herramientas" --> “Tarjeta” --> “Arduino UNO” (o la placa que corresponda). Luego, desplegamos nuevamente el menú “Herramientas” --> “Puerto Serial” --> “COM9” (o el puerto serie que corresponda). Finalmente, hacemos click en el botón “Cargar”. Con lo realizado anteriormente, ya programamos nuestra placa Arduino UNO como programador AVRISP. En la siguiente imagen se observa cómo debemos realizar la interconexión entre nuestra placa Arduino UNO y el microcontrolador ATtiny85. ATtiny85 --> Arduino UNO RESET (Pin 1) --> Arduino UNO (Pin 10) MOSI (Pin 5) --> Arduino UNO (Pin 11) MISO (Pin 6) --> Arduino UNO (Pin 12) SCK (Pin 7) --> Arduino UNO (Pin 13) Capacitor electrolítico 10uF en placa Arduino UNO, terminal positivo a pin “RESET” y terminal negativo a pin “GND”. Llegados a este punto, y habiendo realizado exitosamente los pasos anteriores, ya estamos en condiciones de cargar el firmware TV-B-Gone v1.1 en nuestro microcontrolador ATtiny85. A continuación se encuentra el comando que debemos ejecutar y los resultados de la ejecución del mismo en caso de ser exitoso. C:\>avrdude -P com9 -b 19200 -c avrisp -p attiny85 -v -e -U lfuse:w:0xe2:m -U hfuse:w:0xdf:m -U efuse:w:0xff:m -U flash:w:tvbgone.hex:i avrdude: Version 5.10, compiled on Jan 19 2010 at 10:45:23 Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/ Copyright (c) 2007-2009 Joerg Wunsch System wide configuration file is "C:WinAVR-20100110binavrdude.conf" Using Port : com9 Using Programmer : avrisp Overriding Baud Rate : 19200 AVR Part : ATtiny85 Chip Erase delay : 4500 us PAGEL : P00 BS2 : P00 RESET disposition : possible i/o RETRY pulse : SCK serial program mode : yes parallel program mode : yes Timeout : 200 StabDelay : 100 CmdexeDelay : 25 SyncLoops : 32 ByteDelay : 0 PollIndex : 3 PollValue : 0x53 Memory Detail : Block Poll Page Polled Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack ----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- --------- eeprom 65 6 4 0 no 512 4 0 4000 4500 0xff 0xff flash 65 6 32 0 yes 8192 64 128 4500 4500 0xff 0xff signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00 lock 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00 lfuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00 hfuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00 efuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00 calibration 0 0 0 0 no 2 0 0 0 0 0x00 0x00 Programmer Type : STK500 Description : Atmel AVR ISP Hardware Version: 2 Firmware Version: 1.18 Topcard : Unknown Vtarget : 0.0 V Varef : 0.0 V Oscillator : Off SCK period : 0.1 us avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85 avrdude: AVR device initialized and ready to accept instructions Reading | ################################################## | 100% 0.11s avrdude: Device signature = 0x1e930b avrdude: safemode: lfuse reads as FE avrdude: safemode: hfuse reads as DF avrdude: safemode: efuse reads as FF avrdude: erasing chip avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85 avrdude: reading input file "0xe2" avrdude: writing lfuse (1 bytes): Writing | ################################################## | 100% 0.07s avrdude: 1 bytes of lfuse written avrdude: verifying lfuse memory against 0xe2: avrdude: load data lfuse data from input file 0xe2: avrdude: input file 0xe2 contains 1 bytes avrdude: reading on-chip lfuse data: Reading | ################################################## | 100% 0.03s avrdude: verifying ... avrdude: 1 bytes of lfuse verified avrdude: reading input file "0xdf" avrdude: writing hfuse (1 bytes): Writing | ################################################## | 100% 0.04s avrdude: 1 bytes of hfuse written avrdude: verifying hfuse memory against 0xdf: avrdude: load data hfuse data from input file 0xdf: avrdude: input file 0xdf contains 1 bytes avrdude: reading on-chip hfuse data: Reading | ################################################## | 100% 0.02s avrdude: verifying ... avrdude: 1 bytes of hfuse verified avrdude: reading input file "0xff" avrdude: writing efuse (1 bytes): Writing | ################################################## | 100% 0.03s avrdude: 1 bytes of efuse written avrdude: verifying efuse memory against 0xff: avrdude: load data efuse data from input file 0xff: avrdude: input file 0xff contains 1 bytes avrdude: reading on-chip efuse data: Reading | ################################################## | 100% 0.03s avrdude: verifying ... avrdude: 1 bytes of efuse verified avrdude: reading input file "tvbgone.hex" avrdude: writing flash (8132 bytes): Writing | ################################################## | 100% 15.85s avrdude: 8132 bytes of flash written avrdude: verifying flash memory against tvbgone.hex: avrdude: load data flash data from input file tvbgone.hex: avrdude: input file tvbgone.hex contains 8132 bytes avrdude: reading on-chip flash data: Reading | ################################################## | 100% 11.20s avrdude: verifying ... avrdude: 8132 bytes of flash verified avrdude: safemode: lfuse reads as E2 avrdude: safemode: hfuse reads as DF avrdude: safemode: efuse reads as FF avrdude: safemode: Fuses OK avrdude done. Thank you. Habiendo resultado exitosa la carga del firmware en nuestro microcontrolador, podemos proceder sin mayor demora a construir el circuito de acuerdo al diagrama esquemático mostrado anteriormente. La placa terminada se observa en la siguiente imagen: Como medida de protección adicional, podemos proteger nuestra pequeña placa con tubo termocontraíble de 1 pulgada.

El bloqueador infrarrojo (IR Jammer) es un proyecto que garantiza una diversión segura y no destructiva ya que permite dejar inoperativos temporalmente todos los controles remotos infrarrojos. El microcontrolador de este diseño tiene como objetivo abarcar las 6 frecuencias infrarrojas mas populares, haciendo universal el uso de este dispositivo, corrompiendo los datos enviados desde los controles remotos infrarrojos que utilicen cualquiera de las 6 frecuencias. Presionando una sola vez el pulsador S1, el dispositivo envía un flujo de pulsos infrarrojos a través de los 4 LEDs IR, 2 LEDs IR de haz ancho y 2 LEDs IR de haz angosto, durante 30 segundos. Cada vez que se presiona el pulsador se añaden 30 segundos más al temporizador. La placa, dada sus reducidas dimensiones puede ser montada directamente sobre su fuente de alimentación, en este caso una batería de 9V, ya que sus dimensiones son casi las mismas. El corazón del bloqueador infrarrojo es el microcontrolador PIC12F675, el cual fué programado para reproducir las 6 frecuencias infrarrojas más utilizadas actualmente: 30kHz, 33kHz, 36kHz, 38kHz, 40kHz y 56kHz. Cuando se presiona el pulsador, los dos transistores envían datos infrarrojos a través de 4 LEDs infrarrojos. Utilizando 2 LEDs IR de haz ancho y 2 LEDs IR de haz angosto, permite obtener una buena cobertura y facilidad de uso. El LED verde se utiliza para indicar el encendido del bloqueador destellando 3 veces y también para indicar que la unidad se encuentra operando emitiendo un destello rápido cada pocos segundos. Luego de encendida la unidad, el LED verde destellará 3 veces indicando que el bloqueador se encuentra listo para operar, entrando luego en modo de espera. Cambiará de estado cuando se produzca una interrupción en el pin 6 del microcontrolador, este cambio de estado sucede al presionar el pulsador S1, esto permite prolongar la vida útil de la batería cuando la unidad no se encuentra en funcionamiento. Cada vez que se presiona el pulsador S1, se suman 30 segundos adicionales de operación. Datasheet PIC12F675 (descarga desde el post original) El diagrama esquemático del bloqueador se observa en la siguiente imagen: Lista de Componentes 1 Microcontrolador PIC12F675 1 Diodo Rectificador 1N4001 2 Capacitores de Tantalio 47uF 35V 1 Capacior Cerámico 100nF 50V 1 Regulador de Tensión LM2931A 1 Pulsador N.A. o Push-Button N.A. 2 Transistores 2N4401 2 Resistencias 330Ω 0.25W 2 Resistencias 22Ω 0.25W 1 Resistencia 1KΩ 0.25W 1 LED Verde Difuso 3mm 2 LEDs IR 5mm 940nm Haz Ancho [de apariencia blanco] 2 LEDs IR 5mm 940nm Haz Angosto [de apariencia azulino] 1 Batería 9V 1 Portabatería 9V con interruptor [ opcional ] El código fuente del firmware del microcontrolador está escrito en el lenguaje PICBasic. Puede ser compilado sin ningún inconveniente utilizando la última versión del compilador PICBasic Pro Trial Version 3.0.7.1 y cargar el firmware en el PIC12F675 utilizando el programador PICKit 3 v3.01. '**************************************************************** '* Name : remote_jammer.BAS * '* Author : [Alan Parekh] * '* : Alan's Electronic Projects Inc. * '* Notice : Copyright (c) 2009 * '* : All Rights Reserved * '* Date : April 20, 2010 * '* Version : 1.0 * '* Notes : * '* : * '**************************************************************** 'setup the device #CONFIG __config _INTRC_OSC_NOCLKOUT & _WDT_OFF & _MCLRE_OFF #ENDCONFIG Define OSCCAL_1K 1 'calibrate internal oscillator [email protected][email protected] [email protected][email protected] IR out TRISIO.0 = 0 ' set output #0 as an output TRISIO.1 = 1 ' set output #1 as an input TRISIO.2 = 0 ' set output #2 as an output TRISIO.3 = 0 ' set output #3 as an output TRISIO.4 = 0 ' set output #4 as an output TRISIO.5 = 1 ' set output #5 as an input CMCON = 7 ' Comparators disabled ANSEL = 0 ' A/D disabled OPTION_REG.7 = 0 ' Turn on weak pull ups VRCON = 0 ' Turn off the voltage reference IOCB.1 = 1 ' Enable pin change interrupt on GPIO 1 IOCB.5 = 1 ' Enable pin change interrupt on GPIO 5 boardButton var GPIO.1 'push button on circuit board irLed var GPIO.2 'IR LED output indicatorLED var GPIO.4 'Indicator LED output forceOn var GPIO.5 'Ground to force on system, it will run till the pin is released runCounter var word 'keeps track of how long we need to run for runCounter = 0 'set it to 0 by default buttonActive con 0 'active button state buttonNonActive con 1 'non-active button state buttonDebounceCycles con 1 'number of cycles to ignore the button (debounce) buttonDebounceCyclesCounter var byte 'keeps track of the debounce progress buttonDebounceCyclesCounter = 0 'set the default to 0 lastKnownButtonState var bit 'keeps track of the last known push button state LastKnownButtonState = buttonNonActive 'defaults the push button state lastKnownForceOnSwitchState var bit 'keeps track of the last known force on switch state LastKnownForceOnSwitchState = buttonNonActive 'defaults the force on switch state flashCounter var word 'keeps track of the indication LED flashing off time flashcounter = 0 'set the default to 0 flashDelay con 40 'used to set how many cycles the indication LED should be off before it flashes once carrierCycles VAR BYTE 'number of carrier cycles carrierCycles = 145 ' min 1, max 255 runCounterIncrement con 635 'this is the number of cycles to add when the button is pressed (about 30 seconds) gosub startup 'run the startup routine, then run the main program '''''''''''''''''''''''' 'IR carrier generator routines. 'These routines are written in ASM to allow accurate control of the actual time delays '''''''''''''''''''''''' ' Generate "Cycles" number of ~30kHz pulses ' 33uS total (actual is 33uS) ASM _Pulse30 bsf IRTX,PIN ; 1uS, LED=on nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS bcf IRTX,PIN ; 1uS, LED=off nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS decfsz _carrierCycles,f ; 1uS goto _Pulse30 ; 2uS return ; Return to caller ENDASM ' Generate "Cycles" number of ~33kHz pulses ' 30.3uS total ASM _Pulse33 bsf IRTX,PIN ; 1uS, LED=on nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS bcf IRTX,PIN ; 1uS, LED=off nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS decfsz _carrierCycles,f ; 1uS goto _Pulse33 ; 2uS return ; Return to caller ENDASM ' Generate "Cycles" number of ~36kHz pulses ' 27.8uS total ASM _Pulse36 bsf IRTX,PIN ; 1uS, LED=on nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS bcf IRTX,PIN ; 1uS, LED=off nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS decfsz _carrierCycles,f ; 1uS goto _Pulse36 ; 2uS return ; Return to caller ENDASM ' Generate "Cycles" number of ~38kHz pulses ' 26.3uS total ASM _Pulse38 bsf IRTX,PIN ; 1uS, LED=on nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS bcf IRTX,PIN ; 1uS, LED=off nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS decfsz _carrierCycles,f ; 1uS goto _Pulse38 ; 2uS return ; Return to caller ENDASM ' Generate "Cycles" number of 40kHz pulses ' 25uS total ASM _Pulse40 bsf IRTX,PIN ; 1uS, LED=on nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS bcf IRTX,PIN ; 1uS, LED=off nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS decfsz _carrierCycles,f ; 1uS goto _Pulse40 ; 2uS return ; Return to caller ENDASM ' Generate "Cycles" number of ~56kHz pulses ' 17.9uS total ASM _Pulse56 bsf IRTX,PIN ; 1uS, LED=on nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS bcf IRTX,PIN ; 1uS, LED=off nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS nop ; 1uS decfsz _carrierCycles,f ; 1uS goto _Pulse56 ; 2uS return ; Return to caller ENDASM 'Low power routine, allows the device to sleep (very low power mode) until a button is pressed. 'When a button is pressed the main routine is run LowPowerSleep: INTCON.0 = 0 ' Reset pin change interrupt flag INTCON.3 = 1 ' enable global interrupts [email protected]'sleep until a pin interrupt wakes it up [email protected]'small pause to allow chip to wake up fully [email protected]'small pause to allow chip to wake up fully INTCON.0 = 0 ' Reset pin change interrupt flag INTCON.3 = 0 ' disable global interrupts goto main 'jump into the main program Main: 'check to see if the force on just got turned on, if so give a flash to indicate activation if (ForceOn = buttonActive and LastKnownForceOnSwitchState = buttonNonActive) then 'turn on the indicator LED to show that the system activated high IndicatorLED flashCounter = 0 'reset the counter so the next flash will be in about 2 seconds LastKnownForceOnSwitchState = buttonActive endif 'check to see if the user pressed the on-board button, if so add 30 seconds of run time if (boardButton = buttonActive and LastKnownButtonState = buttonNonActive and buttonDebounceCyclesCounter = 0) then 'turn on the indicator LED to show that the system activated high IndicatorLED flashCounter = 0 'reset the counter so the next flash will be in about 2 seconds 'don't allow the counter to roll over if (runcounter + runCounterIncrement [ 65000) then runCounter = runCounter + runCounterIncrement ' add 30 seconds worth of loops endif buttonDebounceCyclesCounter = buttonDebounceCycles 'set the debounce counter LastKnownButtonState = buttonActive 'set the fact that the button was pressed endif 'run through all 6 IR frequincies with a short pause between the blasts CALL Pulse30 low IRLED pause 1 CALL Pulse33 low IRLED pause 1 CALL Pulse36 low IRLED pause 1 CALL Pulse38 low IRLED pause 1 CALL Pulse40 low IRLED pause 1 CALL Pulse56 low IRLED pauseus 800 'smaller pause since there is some overhead below 'manage the run counter if (runCounter ] 0) then runCounter = runCounter - 1 ' we just finnished a loop decrement the counter if we are using it to time out endif 'manage the button Debounce Cycles Counter if (buttonDebounceCyclesCounter ] 0) then buttonDebounceCyclesCounter = buttonDebounceCyclesCounter - 1 endif 'update the current state of the board button if (boardButton = buttonNonActive) then LastKnownButtonState = buttonNonActive endif 'update the current state of the optional force on switch if (ForceOn = buttonNonActive) then LastKnownForceOnSwitchState = buttonNonActive endif 'if the run counter is out and the force on input is not activated enter low power sleep mode if (runCounter = 0 and ForceOn = buttonNonActive) then low IndicatorLED 'turn off the indication LED low IRLED 'turn off the IR LED goto lowpowersleep 'enter low power mode endif 'update the indication LED flash rate counter flashCounter = flashCounter + 1 'flash a short burst about every 2 seconds if ((flashCounter//flashDelay) = 0) then high IndicatorLED else low IndicatorLED endif GOTO Main 'Flash the LED once FlashLED: high IndicatorLED 'turn on the indicator LED pause 300 '300mS pause low indicatorLED 'turn off the indicator LED pause 300 '300mS pause return 'This will run once at startup (power up) Startup: low IRLED 'turn the IR LED off at startup 'startup flash pattern gosub flashLED gosub flashLED gosub flashLED 'if the force on switch is active or the board button is pressed when the system starts up jump right into the main rotine if (ForceOn = buttonActive or boardButton = buttonActive) then goto main endif 'no buttons are active just go to sleep (low power mode) and wait for the user to activate the system goto lowpowersleep End PICBasic Pro Trial Version 3.0.7.1 [incluye MPASM v8.90, Microcode Studio 5 (MCSX) para PBP v3, PBP 3.0.7.1] Tamaño: 123.1MB SHA1 Hash: C449786CFE50B26EB6818F9C35E10C718C36F6AD Descarga (desde el post original) PICKit 3 v3.01 Tamaño: 8.4MB SHA1 Hash: 34600B01B759F65DF993E1FA6408B4B3B3BA4AC9 Descarga (desde el post original) Además también se encuentra disponible para descargar el firmware ya compilado, listo para cargar en el microcontrolador. IR Remote Jammer v1.0 HEX Tamaño: 1KB SHA1 Hash: 59C4A7B28F56F52AC352439DBD7F154A4DE4D08F Descarga (desde el post original) (click para ampliar) (click para ampliar) (click para ampliar) (click para ampliar) (click para ampliar) (click para ampliar)

¿Qué es el DNI? El DNI es el Documento Nacional de Identidad que certifica en forma exclusiva la identidad de las personas, a partir de la Base de Datos que administra el Registro Nacional de las Personas. El DNI es el único instrumento que acredita la identidad de una persona. Explícitamente en ningún lugar indica que es único, pero todos creemos que es así. Actualmente existe un gran número de personas que poseen su número de DNI duplicado. Es decir, hay dos personas en la República Argentina con el mismo número de DNI. Parece un poco complicado de entender al principio pero esta situación es algo común, si es que se le puede llamar así. La explicación más lógica: la distribución de los números de DNI depende de personas, y donde existe una persona, existe la posibilidad de error. Por esta razón, entre otras, surgió el identificador de CUIL – CUIT (Código Único de Identificación Laboral – Código Único de Identificación Tributaria). De esta manera, por más que existiera un número de DNI duplicado, el CUIL – CUIT los diferenciaría. Para ello se diseñó un algoritmo capaz de calcular dicho número. ¿Qué es el CUIL/T? El CUIL/T es el Código Único de Identificación Laboral – Código Único de Identificación Tributaria. El mismo consta de 11 (once) números. Los 10 (diez) primeros (2 + 8) conforman el Código de Identificación y el último conforma el Digito de Verificación. Para obtener los elementos mencionados en el párrafo anterior se aplica el siguiente algoritmo matemático: XY – 12345678 – Z XY: Indican el Tipo (Hombre, Mujer, Sociedad o Empresa) 12345678: Número de DNI Z: Dígito de Verificación Se determina XY de la siguiente manera: Hombre = 20 Mujer = 27 Empresa o Sociedad = 30 Se multiplica XY 12345678 por un número de forma separada: Dado XY = 20, a modo de ejemplo. 2 * 5 = 10 0 * 4 = 0 1 * 3 = 3 2 * 2 = 4 3 * 7 = 21 4 * 6 = 24 5 * 5 = 25 6 * 4 = 24 7 * 3 = 21 8 * 2 = 16 Ahora se suman los resultados de las multiplicaciones como se muestra a continuación: 10 + 0 + 3 + 4 + 21 + 24 + 25 + 24 + 21 + 16 = 148 El resultado calculado en el paso anterior se divide por 11 (once) y se obtiene el resto de dicha división. 148 / 11 = 13 (División Entera) Resto: 148 – (13 * 11) = 5 Una vez determinado el resto se aplican las siguientes reglas: Si el resto es igual a 0 (cero), entonces Z (Dígito de Verificación) es igual a 0 (cero). Si el resto es igual a 1 (uno) ocurre lo siguiente: • Si es Hombre, entonces Z (Dígito de Verificación) es igual a 9 (nueve) y XY es igual a 23 (veintitrés). • Si es Mujer, entonces Z (Dígito de Verificación) es igual a 4 (cuatro) y XY es igual a 23 (veintitrés). • En cualquier otro caso Z (Dígito de Verificación) es igual a 11 (once) menos el resto del cociente. Resto = 5 11 – 5 = 6 Z = 6 CUIL: 20 – 12345678 – 6 No debe olvidarse el hecho de que fue una persona quien diseñó el algoritmo presentado anteriormente y por esta razón existen personas cuyo número de CUIL/T no se ajusta a este algoritmo, o sí en cierta manera...duh... CUIL/T Calculator v1.0 Implementación en ANSI C del algoritmo matemático empleado para calcular el CUIL/T. Código Fuente en ANSI C Autor: Hardr!ve Web: virushardrive.wordpress.com Tamaño: 4800 SHA1 Hash: 09515D6FB0EE58A6BDCDC092D1CF515BAB24BA8E Descarga