Mikroc

Luis Hernn Pineda Camargo

Qu es Electrnica?
Es el campo de la ingeniera y de la
fsica aplicada que estudia el diseo y
fabricacin de los circuitos y dispositivos
electrnicos, a travs de la electrnica
es posible procesar y medir seales para
luego realizar acciones en el mundo.
De que le sirve saber a uno que
sustantivo es la palabra que como el
congreso agrupa animales y cosas.

RS232

Contador Arquitectura
// Declaracin de las constantes para el display.
const unsigned short DIGITOS[] =
{
0x3F, //Cdigo del dgito 0
0x06, //Cdigo del dgito 1
0x5B, //Cdigo del dgito 2
0x4F, //Cdigo del dgito 3
0x66, //Cdigo del dgito 4
0x6D, //Cdigo del dgito 5
0x7D, //Cdigo del dgito 6
0x07, //Cdigo del dgito 7
0x7F, //Cdigo del dgito 8
0x6F, //Cdigo del dgito 9
};
//Funcin para visualizar el display dinmico.
void VerDisplay( int Numero )
{
unsigned short U; //Variable para guardar las unidades.
unsigned short D; //Variable para guardar las decenas.
unsigned short C; //Variable para guardar las centenas.
unsigned short UM; //Variable para guardar las unidades de mil.
UM = Numero/1000; //Clculo de las unidades de mil.
C = (Numero-UM*1000)/100; //Clculo de las centenas.
D = (Numero-UM*1000-C*100)/10; //Clculo de las decenas.
U = (Numero-UM*1000-C*100-D*10); //Clculo de las unidades.
PORTB = DIGITOS[U]; //Visualiza las unidades.
PORTA.F0=1; //Activa en alto el primer display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
PORTB = DIGITOS[D]; //Visualiza las decenas.
PORTA.F1=1; //Activa en alto el segundo display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
PORTB = DIGITOS[C]; //Visualiza las centenas.
PORTA.F2=1; //Activa en alto el tercer display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
PORTB = DIGITOS[UM]; //Visualiza las unidades de mil.
PORTA.F3=1; //Activa en alto el cuarto display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
}
void main ( void )
{
int Numero=0;
TRISB = 128; //Configura el puerto B como salida
PORTB=0;
TRISA = 0; //Configura el puerto A como salida
PORTA = 0; //Se desactiva todos los displays
while( 1 ) //Bucle infinito
{
//Se visualiza el valor de Nmero.
VerDisplay( Numero ); //Est funcin dura aproximadamente 40m segundos.
//Se cuentan 12 incrementos en N para hacer un incremento
//en Nmero aproximadamente cada 500m segundos.
delay_ms(20);
if (Button(&PORTB,7,10,1)) numero++; //Cambio proporcionado el 25/11/2013
//if (RB7_bit==1) numero++;
while(RB7_bit==1);
if (Button(&PORTA,4,10,1)) numero--; //Cambio proporcionado el 25/11/2013
//if (RB7_bit==1) numero++;
while(RA4_bit==1);
if(numero>1000) numero=0;
}
}

// Declaracin de las constantes para el display.

const unsigned short DIGITOS[] =
{
0x3F, //Cdigo del dgito 0
0x06, //Cdigo del dgito 1
0x5B, //Cdigo del dgito 2
0x4F, //Cdigo del dgito 3
0x66, //Cdigo del dgito 4
0x6D, //Cdigo del dgito 5
0x7D, //Cdigo del dgito 6
0x07, //Cdigo del dgito 7
0x7F, //Cdigo del dgito 8
0x6F, //Cdigo del dgito 9
};
//Funcin para visualizar el display dinmico.
void VerDisplay( int Numero )
{
unsigned short U; //Variable para guardar las unidades.
unsigned short D; //Variable para guardar las decenas.
unsigned short C; //Variable para guardar las centenas.
unsigned short UM; //Variable para guardar las unidades de mil.
UM = Numero/1000; //Clculo de las unidades de mil.
C = (Numero-UM*1000)/100; //Clculo de las centenas.
D = (Numero-UM*1000-C*100)/10; //Clculo de las decenas.
U = (Numero-UM*1000-C*100-D*10); //Clculo de las unidades.
PORTB = DIGITOS[U]; //Visualiza las unidades.
PORTA.F0=1; //Activa en alto el primer display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
PORTB = DIGITOS[D]; //Visualiza las decenas.
PORTA.F1=1; //Activa en alto el segundo display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
PORTB = DIGITOS[C]; //Visualiza las centenas.
PORTA.F2=1; //Activa en alto el tercer display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
PORTB = DIGITOS[UM]; //Visualiza las unidades de mil.
PORTA.F3=1; //Activa en alto el cuarto display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
}
void main ( void )
{
unsigned short N=0; //Variable de conteo.
int Numero=0;
TRISB = 128; //Configura el puerto B como salida
TRISA = 16; //Configura el puerto A como salida
PORTA = 0; //Se desactiva todos los displays
while( 1 ) //Bucle infinito
{
EEPROM_Write(0,PORTB);
//Se visualiza el valor de Nmero.
VerDisplay( Numero ); //Est funcin dura aproximadamente 40m segundos.
//Se cuentan 12 incrementos en N para hacer un incremento
//en Nmero aproximadamente cada 500m segundos.
N++;
if( N==12 )
{
N=0; //Se reinicia el conteo de N.
if(Button(&PORTB,7,10,1)){
portb.f7=1;
Numero++; //Se incrementa el valor de Nmero.
//while(RB7_bit==0);
PORTB = EEPROM_Read(0);
}
if(Button(&PORTA,4,10,1)){
portb.f7=1;
Numero--; //Se incrementa el valor de Nmero.
//while(RB7_bit==0);
}
else if( Numero==10000 ) //Se evala si Nmero vale 10000
{
Numero=0; //y se reinicia en 0 si es 10000.
}
}
}
}
/*
void main ( void )
{
int Numero=0;
TRISB = 128; //Configura el puerto B como salida
PORTB=0;
TRISA = 0; //Configura el puerto A como salida
PORTA = 0; //Se desactiva todos los displays
while( 1 ) //Bucle infinito
{
//Se visualiza el valor de Nmero.
VerDisplay( Numero ); //Est funcin dura aproximadamente 40m segundos.
//Se cuentan 12 incrementos en N para hacer un incremento
//en Nmero aproximadamente cada 500m segundos.
delay_ms(20);
if (Button(&PORTB,7,10,1)) numero++; //Cambio proporcionado el 25/11/2013
//if (RB7_bit==1) numero++;
while(RB7_bit==1);
if (Button(&PORTA,4,10,1)) numero--; //Cambio proporcionado el 25/11/2013
//if (RB7_bit==1) numero++;
while(RA4_bit==1);
if(numero>1000) numero=0;
}
}

*/

MATERIALES
1 pic16f628A
2 74LS04 Not
10 resistencias 330
2 Resistencias 10K
2 Pulsadores
4 Display Ctodo Comn
Sensor de Proximidad
Comunicacin Inalambrica
Cable
Inversor Trigger Schmitt
40106

// Declaracin de las constantes para el display.

const unsigned short DI GITOS[] =
{
0x3F, //Cdigo del dgito 0
0x06, //Cdigo del dgito 1
0x5B, //Cdigo del dgito 2
0x4F, //Cdigo del dgito 3
0x66, //Cdigo del dgito 4
0x6D, //Cdigo del dgito 5
0x7D, //Cdigo del dgito 6
0x07, //Cdigo del dgito 7
0x7F, //Cdigo del dgito 8
0x6F, //Cdigo del dgito 9
};
//Funcin para visualizar el display dinmico.
void VerDisplay( int Numero )
{
unsigned short U; //Variable para guardar las unidades.
unsigned short D; //Variable para guardar las decenas.
unsigned short C; //Variable para guardar las centenas.
unsigned short UM; //Variable para guardar las unidades de mil.
UM = Numero/1000; //Clculo de las unidades de mil.
C = (Numero-UM*1000)/100; //Clculo de las centenas.
D = (Numero-UM*1000-C*100)/10; //Clculo de las decenas.
U = (Numero-UM*1000-C*100-D*10); //Clculo de las unidades.
PORTB = DI GITOS[U]; //Visualiza las unidades.
PORTA.F0=1; //Activa en alto el primer display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
PORTB = DI GITOS[D]; //Visualiza las decenas.
PORTA.F1=1; //Activa en alto el segundo display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
PORTB = DI GITOS[C]; //Visualiza las centenas.
PORTA.F2=1; //Activa en alto el tercer display
delay_ms(10); //Retado de 10m segundos
PORTA=0; //Desactiva todos los displays.
//PORTB = DIGITOS[UM]; //Visualiza las unidades de mil.
//PORTA.F3=1; //Activa en alto el cuarto display
//delay_ms(10); //Retado de 10m segundos
//PORTA=0; //Desactiva todos los displays.
}
void main ( void )
{
unsigned short N=0; //Variable de conteo.
int Numero=0;
TRISB = 128; //Configura el puerto B como salida
TRISA = 16; //Configura el puerto A como salida
PORTA = 0; //Se desactiva todos los displays
Numero = EEPROM_Read(0);
while( 1 ) //Bucle infinito
{
delay_ms(20);
//Se visualiza el valor de Nmero.
VerDisplay( Numero ); //Est funcin dura aproximadamente 40m segundos.
//Se cuentan 12 incrementos en N para hacer un incremento
//en Nmero aproximadamente cada 500m segundos.
N++;
if( N==12 )
{
N=0; //Se reinicia el conteo de N.
if(Button(&PORTB,7,1,1)){
portb.f7=1;
Numero++; //Se incrementa el valor de Nmero.
//while(RB7_bit==0);
}
if(Button(&PORTA,4,1,1)){
porta.f3=1;
Numero--; //Se incrementa el valor de Nmero.
//Numero=9999;
//while(RB7_bit==0);
}
/*
else if((portb.f7=1) && (porta.f3=1))
{
Numero=999; //y se reinicia en 0 si es 10000.
}
*/
else if( Numero==1000 ) //Se evala si Nmero vale 10000
{
Numero=0; //y se reinicia en 0 si es 10000.
}
}
EEPROM_Write(0,Numero);
//delay_ms(20);
}
}

TRIGGER SCHMITT

RS232
Es
un
protocolo
de
comunicacin antiguo que
maneja niveles de voltaje
en un rango de 12V y
-12V, su objetivo es
transmitir informacin.
Este protocolo establece
que debe existir un bit de
inicio (bit de Start). Un bit
de paridad que puede o
no existir y final mente el
bit de parada.

Cdigo Led RGB Arduino

Cdigo Led RGB Arduino

RS232
Fin

PACKAGE-MANAGER
Esta relacionado con las libreras

tp://www.mikroe.com/package-manager/

Proyectos
http://www.prometec.net/contact/
RELOJ
http://danigommun.wix.com/danielgomez#!reloj/c3t
Librerias arduino
http://playground.arduino.cc/Code/Keypad
Cursos
https://
www.edx.org/course/so-you-want-become-biomedical-enginee
r-ieeex-biomed01x
http://www.mikroe.com/package-manager/

Compras
http://www.gearbest.com/?
gclid=CjwKEAjwq6m3BRCP7IfMq6Oo
9gESJACRc0bNBs-t9Mi2RsFplOb5CX
U2Cq-Mc33e4SAd6jawEh6vXBoC_onw
_wcB

PORTX Y TRISX
Estas instrucciones
configuran
el
estado lgico del
puerto que deseas
utilizar, hay que
tener en cuenta
que si se tienen
mal
configuradas
estas instrucciones
seguramente
el
programa no va a
funcionar

Condicional IF ELSE

ndo se utilice la librera Button, puedo condicionar con cualquier puerto excepto
el bit del puerto que esta configurado mi instruccin

Microcontrolad
ores

Dedicado a la programacin y a la
instrumentacin electrnica. Software
libre
Interrupcin RB0

Microcontroladores

Teclado Hexadecimal

 Para detectar si una tecla esta

pulsada se aplica a las filas un nivel
bajo y tres altos. Si se presiona
alguna tecla en la fila por la que se
aplica el nivel bajo, ese nivel bajo
aparecer en la columna
correspondiente con la que ha hecho
contacto. En el ejemplo de la figura
se pulsa la tecla 3 cuando el
microcontrolador explora la fila F1,

MDULOS DE COMUNICACIN SERIE

El USART es uno
de los primeros
sistemas
de
comunicacin
serie.
Las
versiones nuevas
de este sistema
estn actualizadas
y se les denomina
un poco diferente

EUSART
El mdulo Transmisor/Receptor Universal Sncrono/Asncrono
mejorado (Enhanced Universal Synchronous Asynchronous Receiver
Transmitter - EUSART) es un perifrico de comunicacin serie de
entrada/salida. Asimismo es conocido como Interfaz de comunicacin
serie (Serial Communications Interface - SCI). Contiene todos los
generadores de seales de reloj, registros de desplazamiento y
bfers de datos necesarios para realizar transmisin de datos serie
de entrada/salida, independientemente de la ejecucin de programa
del dispositivo. Como indica su nombre, aparte de utilizar el reloj
para la sincronizacin, este mdulo puede establecer la conexin
asncrona, lo que lo hace nico para algunas aplicaciones. Por
ejemplo, en caso de que sea difcil o imposible proporcionar canales
especiales para transmisin y recepcin de datos y seales de reloj
(por ejemplo, mando a distancia de radio o infrarrojas), el mdulo
EUSART es definitivamente la mejor opcin posible.

El EUSART integrado en el PIC16F887 posee las siguientes

caractersticas:

Transmisin y recepcin asncrona en

modo Full-duplex;
Caracteres de anchura de 8 9 bits
programables;
Deteccin de direccin en modo de 9 bits;
Deteccin de errores por saturacin del
bfer de entrada; y
Comunicacin Half Duplex en modo
sncrono.

VALOR MEDIO Y VALOR RMS DE UNA SEAL SENOIDAL

VALOR MEDIO Y VALOR RMS DE UNA SEAL SENOIDAL

Rectificador de onda completa

Valor RMS
Valor cuadrtico medio, valor eficaz.

TUBO NIXIE

TUBO NIXIE
Consiste en una vlvula utilizada para
representar visualmente una serie de
smbolos, normalmente las cifras 0 a 9,
punto (o coma), signos ms y menos,
etc.
Algunas
unidades
tambin
representan smbolos especiales, como
dlar, , mA, V, etc.

TECNOLOGA
El tubo nixie est formado por un nodo, que
es una rejilla delante de una serie de ctodos.
Estos tienen la forma del smbolo que se quiere
representar y se sitan apilados tras el nodo,
pero sin contacto galvnico entre ellos. El
conjunto va encerrado en una ampolla de
vidrio llena de gas a baja presin, normalmente
nen. Se iluminan con luz anaranjada, al
ionizarse el gas en las proximidades de los
ctodos. En algunos modelos la ampolla
incorpora un filtro rojo para mejorar la
visualizacin al aumentar el contraste. Dos son
las disposiciones ms comunes:
Decimal: Cada nodo va conectado a una
patilla y se excita independientemente.
Bi-quinario: Los dgitos se dividen en dos
grupos, cada uno de los cuales tiene un nodo
y la mitad de los ctodos. Se reduce el nmero
de patillas ya que cada ctodo de un grupo
comparte la patilla con un ctodo del otro
grupo. Es un tipo de multiplexacin.

Tubo Nixie iluminado. Se

ve
la rejilla del nodo delante

CARACTERSTICAS
El modo en que los dgitos de un tubo Nixie se
hallan dispuestos es visible en esta ilustracin
de un ZM1212.
El tubo nixie se comporta como la lmpara de
nen que es. Tienen una tensin de encendido
que suele ser unos 170 V y una tensin de
mantenimiento, bastante ms baja. Debe
utilizarse una resistencia para limitar la
corriente que atraviesa el display. Como el halo
luminoso se produce en los ctodos, el tubo
debe manejarse con corriente continua.

VENTAJAS DEL TUBO NIXIE

Es totalmente compatible con las

vlvulas termoinicas: funciona con una tensin
relativamente alta y requiere muy poca
corriente.
Es ms robusto y de vida ms larga que los
displays incandescentes (Numitron). Adems
consumen menos.
Existen tubos de diversos tamaos, llegando a
ser bastante grandes.
Los smbolos son claros y estn perfectamente
trazados.

INCONVENIENTES DEL TUBO NIXIE

Su peso y volumen.
Necesita una tensin alta.
Los smbolos no estn todos en el mismo
plano, lo que reduce el ngulo de visibilidad.
Son frgiles.
Con la aparicin de los displays
fluorescentes, de LED y, posteriormente, de
cristal lquido, los tubos nixie han cado en
desuso.

Historia
Los primeros displays de tubos Nixie fueron hechos
por un pequeo fabricante de tubos de vaco
llamado Haydu Brothers Laboratorie, y se
introdujeron en 1955 por la Burroughs Corporation,
que adquiri Haydu. El nombre Nixie deriva de "NIX
I" de Burroughs, una abreviatura de "Indicador
Numrico eXperimental n. 1" ( "Numeric Indicator
eXperimental No. 1") aunque puede haber sido un
retroacrnimo diseado para evocar una criatura
mtica. Cientos de variaciones de este diseo fueron
fabricados por muchas empresas, desde la dcada
de 1950 hasta la dcada de 1990.

RESURGIMIENTO
Un gran reloj de seis Nixies ZM1210, manufacturado por Telefunken.
Un reloj-pulsera Nixie en la mueca de Steve Wozniak, cofundador de Apple Inc.
Citando una insatisfaccin con la esttica de los displays digitales modernos y la
atraccin nostlgica por el styling de la tecnologa obsoleta, un buen nmero de
entusiastas de la electrnica ha mostrado en aos recientes inters en resucitar los
tubos Nixie. Los tubos sin vender que han estado almacenados en galpones durante
dcadas estn siendo sacados y usados, siendo la principal aplicacin en relojes
digitales de elaboracin casera. Esto es en cierto modo irnico, pues durante su
auge, los Nixies generalmente eran considerados demasiado costosos para ser
usados en bienes de consumo masivo como los relojes de pared. Este aumento
repentino en la demanda ha causado que los precios se eleven significativamente,
particularmente para los tubos voluminosos. El tubo Nixie ms voluminoso que se
sabe se halla en mano de coleccionistas el RODAN CR47/GR414 (22.1cm de alto)ha
sido vendido a cientos de dlares la unidad pero dichos tubos son extremadamente
raros y solamente hallados en unos pocos lugares del mundo por buscadores
perseverantes y afortunados. Los precios de otros Nixies voluminosos que exhiben
dgitos ms altos de 1 pulgada (2.5 cm) han subido el doble, triple o ms entre 1998
y 2005.

DIAGRAMA DE UN TUBO
NIXIE

Donde Comprar tubos

nixie?
http://www.ebay.com/sch/i.html?&_
nkw=nixie

Referencias
http://
es.wikipedia.org/wiki/Tubo_Nixie

Fuente

MANCHESTER CODE LIBRARY

Manchester Code Library

The mikroC PRO for PIC provides a library for handling
Manchester coded signals. The Manchester code is a code in
which data and clock signals are combined to form a single
self-synchronizing data stream; each encoded bit contains a
transition at the midpoint of a bit period, the direction of
transition determines whether the bit is 0 or 1; the second half
is the true bit value and the first half is the complement of the
true bit value (as shown in the figure below).

 La codificacin Manchester, tambin denominada

codificacin bifase-L, es un mtodo de codificacin
elctrica de una seal binaria en el que en cada tiempo de
bit hay una transicin entre dos niveles de seal. Es una
codificacin autosincronizada, ya que en cada bit se puede
obtener la seal de reloj, lo que hace posible una
sincronizacin precisa del flujo de datos. Una desventaja es
que consume el doble de ancho de banda que una
transmisin asncrona.
Hoy
en
da
hay
numerosas
codificaciones (8b/10b) que logran el mismo resultado pero
consumiendo menor ancho de banda que la codificacin
Manchester.
La codificacin Manchester se usa en muchos estndares de
telecomunicaciones, como por ejemplo Ethernet.

DESCRIPCIN

Las seales de datos y de reloj, se

combinan en una sola que autosincroniza el flujo de datos.
Cada bit codificado contiene una
transicin en la mitad del intervalo de
duracin de los bits.
Una transicin de negativo a positivo
representa un 1 y una transicin de
positivo a negativo representa un 0.

Los cdigos Manchester tienen una transicin en la mitad del periodo de cada
bit. Cuando se tienen bits iguales y consecutivos se produce una transicin al
inicio del segundo bit, la cual no es tenida en cuenta por el receptor al
momento de decodificar, solo las transiciones separadas uniformemente en el
tiempo son las que son consideradas por el receptor. Hay algunas transiciones
que no ocurren a mitad de bit. Estas transiciones no llevan informacin til, y
solo se usan para colocar la seal en el siguiente estado donde se llevar a
cabo la siguiente transicin. Aunque esto permite a la seal autosincronizarse, en realidad lo que hace es doblar el requerimiento de ancho de
banda, en comparacin con otros cdigos como por ejemplo los Cdigos NRZ.

Diseo de fuente de
voltaje
Comercial

Reguladores

Ecuaciones

CDIGO EN MIKROC
//Definicin de pines del LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;
//Definicin de los TRIS del LCD
sbit LCD_RS_Direction at
TRISB4_bit;
sbit LCD_EN_Direction at
TRISB5_bit;
sbit LCD_D7_Direction at
TRISB3_bit;
sbit LCD_D6_Direction at
TRISB2_bit;
sbit LCD_D5_Direction at
TRISB1_bit;
sbit LCD_D4_Direction at
TRISB0_bit;

void main( void )

{
//Declaracin de variables.
unsigned float Radc, DisI;
char Text[16];
//Inicio del LCD.
Lcd_Init();
//Borrado del cursor.
Lcd_Cmd(_LCD_CURSOR_OFF);
//Impresin de texto.
Lcd_Out( 1, 1, "Resistencia:");
while(1) //Bucle infinito.
{
//Lectura del canal anlogo.
Radc=ADC_Read(0);
//Implementacin del clculo de la LDR, ecuacin (13.20).
//DisI = (Radc*48.87585533)/(5.0-Radc*0.004887585);
DisI = (Radc*0.004887585)*2;
//Se convierte el valor entero largo, en cadena de texto.
floatToStr( DisI, Text );
//LongToStr( DisI, Text );
//Se imprime la lectura del sensor.
Lcd_Out( 2, 1, Text );
//Retardo de 100m segundos.
delay_ms(100);
}
}

CDIGO EN MIKROC
//Definicin de pines del LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;
//Definicin de los TRIS del LCD
sbit LCD_RS_Direction at
TRISB4_bit;
sbit LCD_EN_Direction at
TRISB5_bit;
sbit LCD_D7_Direction at
TRISB3_bit;
sbit LCD_D6_Direction at
TRISB2_bit;
sbit LCD_D5_Direction at
TRISB1_bit;
sbit LCD_D4_Direction at
TRISB0_bit;

void main( void )

{
//Declaracin de variables.
unsigned float Radc, DisI;
char Text[16];
//Inicio del LCD.
Lcd_Init();
//Borrado del cursor.
Lcd_Cmd(_LCD_CURSOR_OFF);
//Impresin de texto.
Lcd_Out( 1, 1, "Resistencia:");
while(1) //Bucle infinito.
{
//Lectura del canal anlogo.
Radc=ADC_Read(0);
//Implementacin del clculo de la LDR, ecuacin (13.20).
//DisI = (Radc*48.87585533)/(5.0-Radc*0.004887585);
DisI = (Radc*0.004887585)*10;
//Se convierte el valor entero largo, en cadena de texto.
floatToStr( DisI, Text );
//LongToStr( DisI, Text );
//Se imprime la lectura del sensor.
Lcd_Out( 2, 1, Text );
//Retardo de 100m segundos.
delay_ms(100);
}
}

Voltmetro con PIC16F887

//Definicin de pines del LCD
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D4 at RB0_bit;
//Definicin de los TRIS del LCD
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D7_Direction at TRISB3_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D4_Direction at TRISB0_bit;
void main( void )
{
//Declaracin de variables.
unsigned float Radc, DisI;
char Text[16];
ANSEL = 0;
// Configure AN pins as
digital I/O
ANSELH = 0;
C1ON_bit = 0;
// Disable comparators
C2ON_bit = 0;
//Inicio del LCD.
Lcd_Init();
//Borrado del cursor.
Lcd_Cmd(_LCD_CURSOR_OFF);
//Impresin de texto.
Lcd_Out( 1, 1, "Mecnica <Volt>:");
while(1) //Bucle infinito.
{
//Lectura del canal anlogo.
Radc=ADC_Read(0);
//Implementacin del clculo de la LDR, ecuacin
(13.20).
//DisI = (Radc*48.87585533)/(5.0Radc*0.004887585);
DisI = (Radc*0.004887585533)*10;
//Se convierte el valor entero largo, en cadena de
texto.
floatToStr( DisI, Text );
//LongToStr( DisI, Text );
//Se imprime la lectura del sensor.
Lcd_Out( 2, 1, Text );
//Retardo de 100m segundos.
delay_ms(100);
}
}

NOTA SOBRE EL
VOLTMETRO
No se porque el programa
anteriormente me funciono
con
la
ecuacin
DisI
=
(Radc*0.004887585)*10;

El programa es mas sencillo

de lo que porque solamente
necesito el Vadc.
El programa esta funcionando
perfectamente
con
la
ecuacin
DisI
=
(Radc*0.004887585)*10;

Donde sirve para dar valores

reales dependiendo del divisor
de voltaje este utilizando.

MDULO PUERTO SERIE SNCRONO MAESTRO (MSSP)

El MSSP (Puerto serie sncrono maestro -Master Synchronous Serial Port)
es un mdulo muy til, y a la vez uno de los circuitos ms complejos
dentro del microcontrolador. Este mdulo permite la comunicacin de alta
velocidad entre un microcontrolador y otros perifricos u otros
microcontroladores al utilizar varias lneas de E/S (como mximo dos o tres
lneas). Por eso, se utiliza con frecuencia para conectar el microcontrolador
a los visualizadores LCD, los convertidores A/D, las memorias EEPROM
seriales, los registros de desplazamiento etc. La caracterstica principal de
este tipo de comunicacin es que es sncrona y adecuada para ser
utilizada en sistemas con un slo maestro y uno o ms esclavos. Un
dispositivo maestro contiene un circuito para generacin de baudios y
adems, suministra seales de reloj a todos los dispositivos del sistema.
Los dispositivos esclavos no disponen de un circuito interno para
generacin de seales de reloj. El mdulo MSSP puede funcionar en uno
de dos modos:
1. Modulo SPI (Interfaz perifrica serial).
2. Modulo I2C (Circuito inter integrado).

Como se muestra en la siguiente figura, un mdulo MSSP representa slo una mitad de un hardware
necesario para establecer una comunicacin serial, mientras que la otra mitad se almacena en el
dispositivo con el que intercambia los datos. Aunque los mdulos en ambas puntas de lnea son los
mismos, sus modos de funcionamiento difieren esencialmente dependiendo de si el mdulo funciona
comoMaestroo comoEsclavo:
Si el microcontrolador a ser programado controla otro dispositivo o circuito (perifricos), deber
funcionar como un dispositivomaestro. Este mdulo generar seal de reloj cuando sea necesario, o
sea slo cuando se requiera recibir y transmitir los datos por software. Por consiguiente, el
establecimiento de conexin depende nicamente del dispositivo maestro.
De lo contrario, si el microcontrolador a ser programado est integrado en un dispositivo ms
complejo (por ejemplo en una PC), deber funcionar como un dispositivo esclavo. Como tal, un esclavo
siempre tiene que esperar a que un dispositivo maestro enve la solicitud de transmisin de datos.

SPI Interfaz perifrica

serial

El modo SPI permite la transmisin y recepcin simultnea de datos de 8 bits al utilizar tres
lneas de entrada/salida
SDO-Serial Data Out(salida de datos serie )- lnea de transmisin;
SDI-Serial Data In(entrada de datos serie) - lnea de recepcin; y
SCK-Serial Clock(reloj de comunicacin) - lnea de sincronizacin.
Adicionalmente, hay una cuarta lnea (SS) que se puede utilizar si el microcontrolador
intercambia los datos con varios dispositivos perifricos. Refirase a la siguiente figura.
SS-Slave Select (Seleccin de esclavo)- Es una lnea adicional utilizada para la seleccin de un
dispositivo especfico. Esta lnea est activa slo si el microcontrolador funciona como esclavo, o
sea cuando el dispositivo externo - maestro requiere intercambiar los datos. Al funcionar en
modo SPI, el mdulo MSSP utiliza 4 registros en total:
SSPSTAT - registro de estado
SSPCON - registro de control
SSPBUF - bfer serie de transmisin/recepcin
SSPSR - registro de desplazamiento (no es accesible directamente)
Los primeros tres registros son de lectura/escritura y se pueden modificar en cualquier momento,
mientras que el cuarto, como no es accesible, se utiliza para convertir datos en formato serial.

El registro de desplazamiento (SSPRS) est directamente conectado a los pines

del microcontrolador y es utilizado para transmisin de datos en formato serie. El
registro SSPRS dispone de la entrada y salida para desplazar los datos hacia
dentro y hacia fuera del dispositivo. En otras palabras, cada bit que aparece en
la entrada (lnea de recepcin) desplaza simultneamente otro bit hacia la salida
(lnea de transmisin).
El registro SSPBUF (Bfer) es una parte de memoria utilizada para almacenar
temporalmente los datos antes de que se enven, o sea inmediatamente
despus de que se reciban. Despus de que todos los 8 bits hayan sido
recibidos, el byte se mueve del registro SSPRS al registro SSPBUF. Este proceso
de crear un doble bfer para recibir los datos permite iniciar la recepcin del
prximo byte antes de leer los datos que se acaban de recibir. Durante la
transmisin/recepcin de datos se ignora un intento de escribir un dato en el
registro SSBUF. Desde el punto de vista de un programador, este registro se
considera el ms importante por haber sido accedido con ms frecuencia.
Concretamente, si dejamos aparte el ajuste del modo de funcionamiento, la
transmisin de datos por el mdulo SPI no es nada ms que escritura y lectura
de datos de este registro, mientras que las dems acrobacias como mover los
registros, se llevan a cabo automticamente por el hardware.

Caractersticas SPI
Es full dplex.

Matlab

Regla de tres compuesta

X=45
A menor cantidad de grifos
Necesito mas horas, por tanto
Se tiene una relacin inversa
A mayor cantidad de
depsitos, mayor cantidad de
horas.
A mayor cantidad de
volumen, mayor cantidad de
horas.

VLAN
Agrupaciones lgicas de puerto,
VLAN ESTATICAS (SEGN EL PUERTO)
y VLAN DINAMICAS (SEGN LA MAC
ADDRESS)

ARDUINO

QU ES ARDUINO?
Es una herramienta de cdigo abierto
que nos permite construir sistemas
electrnicos.

 NOTA: Las versiones mas recientes

del IDE de Arduino no compilan bien
los programas, Lo mejor es usar
Arduino 1.0.5

Referencias
http://www.nickeugeny.com/mb/categ
ory/microcontroladores
/
http://www.nickeugeny.com/mb/cate
gory/programas
/
ppoiukjk

Teorema de Norton

Programas en Mikroc
void main()
{
PORTB=0;
TRISB=0;
PORTC=0;
TRISC=255;
while(1)
{
if (Button(&PORTC, 0, 100, 0))
{
if(portb.f3==1)
portb.f3=0;
else
portb.f3=1;
while(Button(&PORTC, 0, 100, 0));
}
}
}

DETECTOR DE METALES
La bobina tiene
aproximadament
e 200 vueltas
con cable de
cobre
esmaltado.

DETECTOR DE METALES

Proyecto
Display de 7
segmentos

atmega328

ATMEGA328

BOOTLOADER

Proyecto Display de 7
segmentos

MODELO IMPLEMENTADO
EN ISIS

Compilacin el Archivo .Hex

CDIGO PROFE GARCA

/* Contador decimal de dos Digigitos en 7 Segmentos usando multiplexacion

Por: http://elprofegarcia.com/

int retardo=10;
int var=0;

int unidad=0;
// cuenta las unidades (derecha)
int decena=0;
// cuenta las decenas (izquierda)
int conmutador=0;
// multiplexacion de uno a otro 7 segmentos
int cont=0;
// contador de ciclos de espera para cambiar de numero

void setup() {
pinMode(2, OUTPUT); //seg a
pinMode(3, OUTPUT); //seg b
pinMode(4, OUTPUT); //seg c
pinMode(5, OUTPUT); //seg d
pinMode(6, OUTPUT); //seg e
pinMode(7, OUTPUT); //seg f
pinMode(8, OUTPUT); //seg g

void loop() {

Conexiones: Las conexiones entre el Arduino y el Display deben realizarse

con una resistencia de 1K ohmio.
Ver plano en: https://www.dropbox.com/s/7xdksbf0cy36ji8/plano%20conexion%20arduino%207seg%2000-99.jpg?dl=0
ARDUINO Display 7 Segmentos (catodo comun)
2
a
3
b
4
c
5
d
6
e
7
f
8
g
9
P
10
COM digito izquierdo usando Transistor NPN
11
COM digito derecho usando Transistor NPN
Sitio donde se compro todos los componentes: http://dinastiatecnologica.com/producto/display-7-segmentos-doble/
*/
// tiempo que dura encendido cada 7 seg (10 mili segundos)
// Valor del digito que se va a desplegar por el 7 seg.

pinMode(10, OUTPUT); // activa digito 1 derecha (unidad)

pinMode(11, OUTPUT); // activa digito 2 izquierda (decena)
}

delay(retardo);

// tiempo que dura encendido cada 7seg antes de cambiar al otro

cont++;
// incrementa el contador de ciclos en Uno
if (cont==100){
// cada cuanto tiempo (ciclos)cambia un numero
cont=0;
// inicializa el contador de ciclos
unidad=unidad+1;
// incrementa la unidad, primer 7seg
if (unidad >= 10){
// cuando la unidad llegue a 10 incrementa la decena
decena=decena+1;
// incrementa la decena, segundo 7seg
unidad=0;
// regresa la unidad a cero
if (decena>=10){
// cuando la decena llegue a 10 se inicializa a cero
decena=0;
}
}
}

if (conmutador == 0) { // hace la multiplexacion conmutando entre los dos 7seg izq y der
digitalWrite(10, 1); // enciende el derecho
digitalWrite(11, 0); // apaga el izquierdo
var=unidad;
// iguala la variable que escribe el numero en el 7seg al valor de la unidad
conmutador=1;
// cambia el conmutador para que en el siguiente ciclo cumpla la otra condicion
}
else{
digitalWrite(10, 0);
digitalWrite(11, 1);
var=decena;
conmutador=0;

// apaga el derecho
// enciende el izquierdo
// iguala la variable que escribe el numero en el 7seg al valor de la decena
// cambia el conmutador para que en el siguiente ciclo cumpla la otra condicion

}
switch (var) {
case 1:
//escribe en el 7seg el numero 1
digitalWrite(2, 0);
digitalWrite(3, 1);
digitalWrite(4, 1);
digitalWrite(5, 0);
digitalWrite(6, 0);
digitalWrite(7, 0);
digitalWrite(8, 0);
break;
case 2:
//escribe en el 7seg el numero 2
digitalWrite(2, 1);
digitalWrite(3, 1);
digitalWrite(4, 0);
digitalWrite(5, 1);
digitalWrite(6, 1);
digitalWrite(7, 0);
digitalWrite(8, 1);
break;
case 3:
//escribe en el 7seg el numero 3
digitalWrite(2, 1);
digitalWrite(3, 1);
digitalWrite(4, 1);
digitalWrite(5, 1);
digitalWrite(6, 0);
digitalWrite(7, 0);
digitalWrite(8, 1);
break;
case 4:
//escribe en el 7seg el numero 4
digitalWrite(2, 0);
digitalWrite(3, 1);
digitalWrite(4, 1);
digitalWrite(5, 0);
digitalWrite(6, 0);
digitalWrite(7, 1);
digitalWrite(8, 1);
break;
case 5:
//escribe en el 7seg el numero 5
digitalWrite(2, 1);
digitalWrite(3, 0);
digitalWrite(4, 1);
digitalWrite(5, 1);
digitalWrite(6, 0);
digitalWrite(7, 1);
digitalWrite(8, 1);
break;
case 6:
//escribe en el 7seg el numero 6
digitalWrite(2, 1);
digitalWrite(3, 0);
digitalWrite(4, 1);
digitalWrite(5, 1);
digitalWrite(6, 1);
digitalWrite(7, 1);
digitalWrite(8, 1);
break;
case 7:
//escribe en el 7seg el numero 7
digitalWrite(2, 1);
digitalWrite(3, 1);
digitalWrite(4, 1);
digitalWrite(5, 0);
digitalWrite(6, 0);
digitalWrite(7, 0);
digitalWrite(8, 0);
break;
case 8:
//escribe en el 7seg el numero 8
digitalWrite(2, 1);
digitalWrite(3, 1);
digitalWrite(4, 1);
digitalWrite(5, 1);
digitalWrite(6, 1);
digitalWrite(7, 1);
digitalWrite(8, 1);
break;
case 9:
//escribe en el 7seg el numero 9
digitalWrite(2, 1);
digitalWrite(3, 1);
digitalWrite(4, 1);
digitalWrite(5, 0);
digitalWrite(6, 0);
digitalWrite(7, 1);
digitalWrite(8, 1);
break;
case 0:
//escribe en el 7seg el numero 0
digitalWrite(2, 1);
digitalWrite(3, 1);
digitalWrite(4, 1);
digitalWrite(5, 1);
digitalWrite(6, 1);
digitalWrite(7, 1);
digitalWrite(8, 0);
break;
default:
digitalWrite(2, 0);
digitalWrite(3, 0);
digitalWrite(4, 0);
digitalWrite(5, 0);
digitalWrite(6, 0);
digitalWrite(7, 0);
digitalWrite(8, 0);
}
}

Anexos
GitHub: Es unaforja(plataforma de
desarrollo colaborativo) para alojar proyectos
utilizando el sistema decontrol de versiones
Git. Utiliza elframeworkRuby on Rails
porGitHub, Inc.(anteriormente conocida
comoLogical Awesome). Desde enero de
2010, GitHub opera bajo el nombre
deGitHub, Inc.El cdigo se almacena de
formapblica, aunque tambin se puede
hacer de forma privada, creando una cuenta
de pago.

Luz Nocturna Automtica

TRIAC
Es
un
dispositivo
semiconductor
que
acta
como
interruptor
capaz
de
conmutar
la
corriente
alterna.

CNY 70

CNY 70

Diseo de paginas Web

Wordpress

RELOJ

Reloj

Diseo Con Arduino

A=11
B=12
C=8
D=7
E=6
F=10
G=9

INFRARROJO
Diseo bsico

DISEO DEL AUTO

DISEO DEL AUTO

DISEO DEL AUTO

DISEO DEL AUTO

DISEO DEL AUTO

DISEO DEL AUTO

Carro con Bluetooth

Puente H

PUENTE H

SERVOMOTORES
Los servomotores tuvieron que ser
modificados para que rueden los
360, por su precisin son muy
recomendados para este tipo de
proyectos, estos dispositivos
funcionan en un rango de 3,5V a 5V
donde nuestra tarjeta Arduino se
adapta al puente h y a este tipo de
motores.

Trucar los servomotores

CDIGO
/* C arro Inalambrico Bluetooth
Dibujo de las conexiones en www.elprofegarcia.com
ARDUINO L293D(Puente H)
5
10
6
15
9
7
10
2
5V
1, 9, 16
GND
4, 5, 12, 13
El motor 1 se conecta a los pines 3 y 6 del Puente H
El motor 2 se conecta a los pines 11 y 14 del Puente H
La fuente de alimentacion de los Motores se conecta a tierra y
el positivo al pin 8 del puennte H.
Conexion del Modulo Bluetooth HC-06 y el Arduino
ARDUINO Bluetooth HC-06
0 (RX)
TX
1 (TX)
RX
5V
VCC
GND
GND
!!Cuidado!! Las conexiones de TX y RX al modulo Bluetooth deben estar desconectadas
en el momento que se realiza la carga del codigo (Sketch) al Arduino.
Conexion Sensor Ultrasonido HC-SR04
ARDUINO Ultrasonido HC-SR 04
2
Echo
3
Trig
5V
VCC
GND
Gnd
*/
int izqA = 5;
int izqB = 6;
int derA = 9;
int derB = 10;
int vel = 255;
// Velocidad de los motores (0-255)
int estado = 'g';
// inicia detenido
int pecho = 2;
// define el pin 2 como (pecho) para el Ultrasonido
int ptrig = 3;
// define el pin 3 como (ptrig) para el Ultrasonido
int duracion, distancia; // para Calcular distacia
void setup() {
Serial.begin(9600); // inicia el puerto serial para comunicacion con el Bluetooth
pinMode(derA, OUTPUT);
pinMode(derB, OUTPUT);
pinMode(izqA, OUTPUT);
pinMode(izqB, OUTPUT);
pinMode(pecho, INPUT);
pinMode(ptrig,OUTPUT);
pinMode(13,OUTPUT);

// defi ne el pin 2 como entrada (pecho)

// defi ne el pin 3 como salida (ptrig)

}
void loop() {
if(Serial.available()>0){
// lee el bluetooth y almacena en estado
estado = Serial.read();
}
if(estado=='a'){
// Boton desplazar al Frente
analogWrite(derB, 0);
analogWrite(izqB, 0);
analogWrite(derA, vel);
analogWrite(izqA, vel);
}
if(estado=='b'){
// Boton IZQ
analogWrite(derB, 0);
analogWrite(izqB, 0);
analogWrite(derA, 0);
analogWrite(izqA, vel);
}
if(estado=='c'){
// Boton Parar
analogWrite(derB, 0);
analogWrite(izqB, 0);
analogWrite(derA, 0);
analogWrite(izqA, 0);
}
if(estado=='d'){
// Boton DER
analogWrite(derB, 0);
analogWrite(izqB, 0);
analogWrite(izqA, 0);
analogWrite(derA, vel);
}
if(estado=='e'){
// Boton Reversa
analogWrite(derA, 0);
analogWrite(izqA, 0);
analogWrite(derB, vel);
analogWrite(izqB, vel);
}
if (estado =='f'){

// Boton ON, se muev e sensando distancia

digitalWrite(ptrig, HIGH);
delay(0.01);
digitalWrite(ptrig, LOW);

// genera el pulso de trigger por 10us

duracion = pulseIn(pecho, HIGH);

distancia = (duracion/2) / 29;
delay(10);

// Lee el tiempo del Echo

// calcula la distancia en centimetros

if (distancia <= 15 && distancia >=2){ // si la distancia es menor de 15cm

digitalWrite(13,HIGH);
// Enciende LED
analogWrite(derB, 0);
analogWrite(izqB, 0);
analogWrite(derA, 0);
analogWrite(izqA, 0);
delay (200);
analogWrite(derB, vel);
analogWrite(izqB, vel);
delay(500);
analogWrite(derB, 0);
analogWrite(izqB, 0);
analogWrite(derA, 0);
analogWrite(izqA, vel);
delay(1100);

// Parar los motores por 200 mili segundos

// Rev ersa durante 500 mili segundos

// Girar durante 1100 milisegundos

digitalWrite(13,LOW);
}
else{
// Si no hay obstaculos se desplaza al frente
analogWrite(derB, 0);
analogWrite(izqB, 0);
analogWrite(derA, vel);
analogWrite(izqA, vel);
}
}
if(estado=='g'){
// Boton OFF, detiene los motores no hace nada
analogWrite(derB, 0);
analogWrite(izqB, 0);
analogWrite(derA, 0);
analogWrite(izqA, 0);
}
}

HC-SR04 Sensor de distancia ultrasnico

SENSOR DE DISTANCIA
ULTRASNICO
Este sensor funciona enviando una frecuencia
de ultrasonido y calcula el tiempo que tarda
en llegar al obstculo y devolverse.
Por tal razn nuestro carro llega a una
distancia mayor de 2cm y este sensor
detecta el obstculo y hace que nuestro
programa cargado en la tarjeta de la orden al
puente h de cambiar los sentidos a los
motores, de manera que nuestro auto no
valla a chocar.

CARACTERSTICAS SENSOR DE
DISTANCIA ULTRASNICO
Alimentacin de 5 volts
Interfaz sencilla: Solamente 4 hilos Vcc,
Trigger, Echo, GND
Rango de medicin:2 cm a 400 cm
Corriente de alimentacin: 15 mA
Frecuencia del pulso: 40 Khz
Apertura del pulso ultrasnico: 15
Seal de disparo: 10uS
Dimensiones del mdulo: 45x20x15 mm.

Arduino Utilizando
Bluetooth
int led13=13;
int estado=0;
void setup(){
Serial.begin(9600);
pinMode(led13,OUTPUT);
}
void loop(){
if(Serial.available()>0){
estado = Serial.read();
}
if (estado =='1'){
digitalWrite(led13,HIGH);
}
if(estado=='2'){
digitalWrite(led13,LOW);
}
}

Bluetooth
Este mdulo es apto para conectar como esclavo a un
adaptador Bluetooth al PC, o un telfono Bluetooth. .
Pueden ajustarse los parmetros del mdulo mediante
comandos de control emitidos a travs de comandos AT.
Dispone de dos conexiones de salida para indicar el estado:
no conectado, conectado, as mismo se puede conectar a
diodos LED o a un pin de entrada de un microcontrolador y
analizar su estado. Es ideal como alternativa inalmbrica a
la transmisin en serie, todos los parametros se configuran
con Comandos AT. Una vez configurado se puede asumir
que es un cable serie. Con la base de conexin es an ms
fcil de utilizar, no es necesario adaptar los niveles lgicos
de la alimentacin a 3.3V (se puede alimentar hasta a 6V) y
adems de esto, puede adaptarse en una protoboard

ARDUINO +
LABVIEW

NOTAS
Estas practicas va a ser un poco molestas,
porque as el programa este bien va a
presentar errores o simplemente no se va a
ejecutar.
Por ejemplo al cargar el programa Lifa_Base en
nuestra tarjeta arduino se tiene que cerrar
Labview u otro programa que este ocupando el
puerto que tiene la tarjeta.
Si el programo elaborado est bien pero no se
ejecuta desde la interface, lo mas practico es
cerrar Labview y ejecutar nuevamente.

Prender y apagar un Led

Hola Mundo

CONEXIONES
Est conexin
es vital para el
funcionamient
o de nuestro
programa.

LIFA_BASE

Practica

Medicina

Medicina

http://www.fucsalud.edu.co/index.ph
p/es/plan-de-estudios-medicina

Universidad Nacional
http://programasacademicos.unal.edu
.co/?
pt=2

Universidad Nacional
Programas
http://programasacademicos.unal.edu
.co/?
pt=2

REFERENCIAS
https://www.wevolver.com/gael.langevin/inmoov-robot/inmoov-robot/
description
/
https://www.wevolver.com/wevolver.staf /
Ingreso a posgrado
http://admisiones.unal.edu.co /
http://www.ingbiomedica.unal.edu.co/Admision.html
http://www.advancertechnologies.com/p/tutorials.html
http://www.ardumotive.com/new-cnc-plotter.html
IDE de Arduino Online
https://codebender.cc/static/walkthrough/page/4

PROBLEMAS
PROPUESTO
S

MIKROC
TABLAS DE MULTIPLICAR EN LCD 16 X2

Este
problema
inicialmente
fue
planteado en JAVA pero surgi la idea
de llevarlo a MIKROC con la misma
lgica que se tuvo en Java.

Solucin del Problema

// LCD module connections
sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D4 at RB0_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D7 at RB3_bit;
sbit LCD_RS_Direction at TRISB4_bit;
sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;
// End LCD module connections
char
char
char
char

txt1[] =
txt2[] =
txt3[] =
txt4[] =

"Tablas Multiplicar";
"X";
"=";
"example";

char i;
char text0[10];
char text[10];
char text1[10];
int j,k,o;
int Result, Resultado;
void Move_Delay() {
Delay_ms(500);
}
void main(){
ANSEL = 0;
ANSELH = 0;
C1ON_bit = 0;
C2ON_bit = 0;
Lcd_Init();

// Loop variable

// Function used for text moving

// You can change the moving speed here

// Configure AN pins as digital I/O

// Disable comparators
// Initialize LCD

Lcd_Cmd(_LCD_CLEAR);
// Clear display
Lcd_Cmd(_LCD_CURSOR_OFF);
// Cursor of
//Lcd_Out(1,1,txt1);
// Write text in first row
//Lcd_Out(1,7,txt2);
for(j=1;j<=10;j++){
for(k=1;k<=10;k++){
Result=j*k;
IntToStr( j, text1 );
IntToStr( k, text0 );
IntToStr( Result, text );
//IntToStr( o, text1 );
//Lcd_Out(1,2,text1);
Lcd_Out(1,1,text1);
delay_ms(200);
Lcd_Out(1,7,txt2);
Lcd_Out(1,8,text0);
delay_ms(200);
Lcd_Out(2,1,txt3);
Lcd_Out(2,2,text);
delay_ms(200);
//o=j;
//Resultado=Result;
//
}
}
}

Aqu esta el primer

cdigo claro que hay
que
hacer
unos
ajuste
pero
se
cumpli
con
el
objetivo.

Programa Mejorado Tablas de

multiplicar

// LCD module connections

sbit LCD_RS at RB4_bit;
sbit LCD_EN at RB5_bit;
sbit LCD_D4 at RB0_bit;
sbit LCD_D5 at RB1_bit;
sbit LCD_D6 at RB2_bit;
sbit LCD_D7 at RB3_bit;

sbit LCD_RS_Direction at TRISB4_bit;

sbit LCD_EN_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB0_bit;
sbit LCD_D5_Direction at TRISB1_bit;
sbit LCD_D6_Direction at TRISB2_bit;
sbit LCD_D7_Direction at TRISB3_bit;
// End LCD module connections
//________________________________________________________
char text0[20];
char text[20];
char text1[20];
char txt2[] = "X";
char txt3[] = "=";
const time=100;
int j,k,o;
int Result, Resultado;
//__________________________________________________
void main(){
//Characteristics of the pic 16f887________________
ANSEL = 0; // Configure AN pins as digital I/O
ANSELH = 0;
C1ON_bit = 0; // Disable comparators
C2ON_bit = 0;
//__________________________________________________
Lcd_Init();
// Initialize LCD
Lcd_Cmd(_LCD_CLEAR);
// Clear display
Lcd_Cmd(_LCD_CURSOR_OFF);
// Cursor of
//___________________________________________________
Lcd_Out(1,7,txt2); //Simbolo de la multiplicacin
//delay_ms(200);
Lcd_Out(2,1,txt3); //Sibolo de igual " = "
//delay_ms(200);
for(j=1;j<=10;j++){
for(k=1;k<=10;k++){
Result=j*k;
IntToStr( j, text1 );
Lcd_Out(1,1,text1);
delay_ms(time);
IntToStr( k, text0 );
Lcd_Out(1,8,text0);
delay_ms(time);
IntToStr( Result, text );
Lcd_Out(2,2,text);
delay_ms(time);
}
}
}

NMEROS PRIMOS
void main(){
//Characteristics of the pic 16f887________________
ANSEL = 0; // Configure AN pins as digital I/O
ANSELH = 0;
C1ON_bit = 0; // Disable comparators
C2ON_bit = 0;
//__________________________________________________
Lcd_Init();
// Initialize LCD
Lcd_Cmd(_LCD_CLEAR);
// Clear display
Lcd_Cmd(_LCD_CURSOR_OFF);
// Cursor of
//___________________________________________________
Lcd_Out(1,7,txt2); //Simbolo de la multiplicacin
//delay_ms(200);
Lcd_Out(2,1,txt3); //Sibolo de igual " = "
//delay_ms(200);
for(i=1;i<=limite;i++){
int cont=0;
for(j=1;j<=i;j++){
if(i%j==0)
cont++;
}
if(cont==2)
IntToStr( i, text1 );
Lcd_Out(2,2,text1);
delay_us(time);
}
}

CONEXIN DE
SERVOMOTORES

CERRADURA
ELECTRNICA

CERRADURA ELECTRNICA
Cdigo

unsigned short k p;
char code1[10] ,user1[4];
char msg1[20] = "...SYSTEM...",msg2[12] = "ENTER CODE";
char msg3[] = "ACCESS GRANTED",msg4[15] = "ACCESS DENIED";
char msg5[15] = "Enter New Code",msg6[] = " PROTECTED " ;
char msg7[] = " *WELCOME* " , msg8[] = " *WARNING* ";
char msg9[] = " SUCCESSFUL ",msg10[] = "*Done*";
void Move_Delay() {
Delay_ms(500);
}
int i=0,j,cnt,u=0;

char keypadPort at PORTD;

///////////////////////////////////////
sbit LCD_RS at R B2_bit;
sbit LCD_EN at R B3_bit;
sbit LCD_D4 at R B4_bit;
sbit LCD_D5 at R B5_bit;
sbit LCD_D6 at R B6_bit;
sbit LCD_D7 at R B7_bit;
sbit LCD_RS_Direction at TRISB2_bit;
sbit LCD_EN_Direction at TRISB3_bit;
sbit LCD_D4_Direction at TRISB4_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D7_Direction at TRISB7_bit;
//////////////////////////////////////

void code_enter()
{
kp = 0;

do

kp = Key pad_Key_Click();
while (!kp);

switch (kp)
{
case 1: kp = 49; break; // 1
case 2: kp = 50; break; // 2
case 3: kp = 51; break; // 3
case 5: kp = 52; break; // 4
case 6: kp = 53; break; // 5
case 7: kp = 54; break; // 6
case 9: kp = 55; break; // 7
case 10: kp = 56; break; // 8
case 11: kp = 57; break; // 9
case 4: kp = 65; break; // A
case 8: kp = 66; break; // B
case 12: kp = 67; break; // C
case 16: kp = 68; break; // D
case 13: kp = 42; break; // *
case 14: kp = 48; break; // 0
case 15: kp = 35; break; // #
}
code1[i] = kp;
Lcd_Chr(2, i+6, code1[i]);
i++;
}
void delay_20ms()
{
Delay_ms(20);

////////Bloque desconocido para mi////////////////

void code_read()
{
delay_20ms();
user1[0] = EEPR OM_Read(0x00);
delay_20ms();
user1[1] = EEPR OM_Read(0x01);
delay_20ms();
user1[2] = EEPR OM_Read(0x02);
delay_20ms();
user1[3] = EEPR OM_Read(0x03);
delay_20ms();
}
////////Bloque desconocido para mi////////////////
void code_write()
{
delay_20ms();
EEPROM_Write(0x 00,code1[0]);
delay_20ms();
EEPROM_Write(0x 01,code1[1]);
delay_20ms();
EEPROM_Write(0x 02,code1[2]);
delay_20ms();
EEPROM_Write(0x 03,code1[3]);
}
/////////////_______________________//////////////

//_______________________________________________
void change_code()
{ top2:
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1, 2, "Enter new code");
Delay_ms(500);
i=0;
code_enter();
if(code1[0] == 42)
{goto top2 ;}
code_enter();
if(code1[1] == 42)
{goto top2 ;}
code_enter();
if(code1[2] == 42)
{goto top2 ;}
code_enter();
if(code1[3] == 42)
{goto top2 ;}
code_enter();
if(code1[4] == 42)
{goto top2 ;}
if(code1[4] == 35){
code_write();
code_read();
Delay_ms(500);
Lcd_Out(2,5,msg10);
Delay_ms(1500);
}
else {
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1,7, "ER ROR");
Delay_ms(1000); }
}

//____________________________________________________

void main()
{
ADCON1 |= 0x07;
TR ISA = 0x00;

Keypad_Init();
Lcd_Init();
code_read();

if(user1[0] == 0x FF && user1[1] == 0xFF && user1[2] == 0xFF && user1[3] == 0xFF
)
{
EEPROM_Write(0x 00,'2');
delay_20ms();
EEPROM_Write(0x 01,'5');
delay_20ms();
EEPROM_Write(0x 02,'8');

delay_20ms();
EEPROM_Write(0x 03,'0');
}
code_read();
Lcd_Cmd(_LCD_CLEAR );
Lcd_Cmd(_LCD_CURSOR_OFF );
Delay_ms(500);
Lcd_Out(1, 2,msg1 );
Lcd_Out(2, 3,msg6 );
Delay_ms(3000);
Lcd_Cmd(_LCD_CLEAR );
cnt=0;
do
{ top:
PORTA.B0=1;
PORTA.B3=0;
Lcd_Cmd(_LCD_CLEAR );
Lcd_Out(2, 4, " Press '*'");
i = 0;
code_enter();
if(code1[0] == 42)
{ top3:
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1, 4, msg2);

i = 0;
code_enter();
if(code1[0] ==
{goto top3 ;}
code_enter();
if(code1[1] ==
{goto top3 ;}
code_enter();
if(code1[2] ==
{goto top3 ;}
code_enter();
if(code1[3] ==
{goto top3 ;}
code_enter();
if(code1[4] ==
{goto top3 ;}

if(code1[0] == '2' && code1[1] == '3' && code1[2] == '4' && code1[3] == '5' && code1[4] == '5') //check master code
{
code_enter();
if(code1[5] == 35)
{
change_code();
goto top ;
}
}
if(cnt<3 && code1[0] == user1[0] && code1[1] == user1[1] && code1[2] == user1
[2] && code1[3] == user1[3] && code1[4] == 35)
{ if(PORTA.B2 == 1)
{
PORTA.B2=0;
cnt=0;
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1,2,msg1);
Delay_ms(3000);
Lcd_Cmd(_LCD_CLEAR);
goto top ;
}

42)

42)

42)

42)

42)

Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1, 2, msg3);
Lcd_Out(2, 2, msg7);
cnt=0;
PORTA.B0=0;
PORTA.B2=1;
Delay_ms(6000);
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(2, 2, msg7);

for(i=0; i<3; i++) {

Lcd_Cmd(_LCD_SHIFT_RIGHT);
Move_Delay();}
Delay_ms(500);
for(i=0; i<5; i++) {
Lcd_Cmd(_LCD_SHIFT_LEFT);
Move_Delay();}
Delay_ms(500);
for(i=0; i<2; i++) {
Lcd_Cmd(_LCD_SHIFT_RIGHT);
Move_Delay();}
Delay_ms(2000);
}

else
{
cnt++;
Lcd_Cmd(_LCD_CLEAR);
Lcd_Out(1, 3,msg4 );
Delay_ms(2000);
}
if(cnt>=3)
{
do
{
PORTA.B2=0;
PORTA.B0=0;
PORTA.B3=1;
while(u<3) {
Lcd_Cmd(_LCD_CLEAR);
Delay_ms(500);
Lcd_Out(1, 3, msg8 );
Delay_ms(500);
Lcd_Cmd(_LCD_CLEAR);
Delay_ms(500);
Lcd_Out(1, 3, msg8 );
Delay_ms(1000);
u++;
}
cnt=2;
u=0;
goto top ;
}
while(1);
}
}
}
while(1);
}

Cerradura Electrnica con

Arduino

Cerradura Electrnica con

Arduino

/*
Programa: Control de Acceso a Puertas con Clave y Display LCD
Autor:
Web: www.humbertohiginio.com
Canal de Youtube: https://www.youtube.com/user/HHSolis
Video Exclusivo para mi canal de Youtube
Todos los Derechos Reservados - 2016
Cdigo de Dominio Pblico
*/

#include <Password.h> //Incluimos la libreria Password

#include <Keypad.h> //Incluimos la libreria Keypad
#include <LiquidCrystal.h> //Incluimos la libreria LiquidCrystal

// Definimos el Keymap
char keys[R OWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};

byte rowPins[ROWS] = { 9,8,7,6 };// C onectar los keypads ROW1, R OW2, R OW3 y ROW4 a esos Pines de Arduino.
byte colPins[COLS] = { 5,4,3,2, };// C onectar los keypads COL1, COL2, COL3 y COL4 a esos Pines de Arduino.

Humberto Higinio

Password password = Password("1A2B3"); //Definimos el Password

int dlugosc = 5;
//Largo del Password
LiquidCry stal lcd(A0, A1, A2, A3, A4, A5); //Definimos los pines del LCD
int buzzer = 10; //Creamos las Variables de salida
int ledRed = 11;
int ledGreen = 12;
int ilosc; //Numero de Clicks
const byte ROWS = 4; // Cuatro Filas
const byte COLS = 4; // Cuatro Columnas

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup()
{
Serial.begin(9600);
keypad.addEventListener(keypadEvent);
pinMode(ledRed, OUTPUT);
pinMode(ledGreen, OUTPUT);
pinMode(buzzer, OUTPUT);
digitalWrite(ledRed, HIGH);
digitalWrite(ledGreen, LOW);
lcd.begin(16, 2);
lcd.setCursor(0,0);
lcd.print(" *Bienv enido*");
lcd.setCursor(0,1);
lcd.print("FAVOR ENTRE PIN");
}
void loop()
{
keypad.getKey();
}
void keypadEvent(KeypadEvent eKey)
{
switch (keypad.getState())
{
case PRESSED:
int i;
for( i = 1; i <= 1; i++ )
{
digitalWrite(buzzer, HIGH);
delay(200);
digitalWrite(buzzer, LOW);
delay(100);
}
Serial.print("Pressed: ");
Serial.println(eKey);
switch (eKey)
{
/*
case '#':
break;
case '*':
break;
*/
default:
ilosc=ilosc+1;
password.append(eKey);
}
//Serial.println(ilosc);
if(ilosc == 1)
{
lcd.clear();
lcd.setCursor(1,0);
lcd.print(" < PIN >");
lcd.setCursor(0,1);
lcd.print("*_");
}
if(ilosc == 2)
{
lcd.clear();
lcd.setCursor(1,0);
lcd.print(" < PIN >");
lcd.setCursor(0,1);
lcd.print("**_");
}
if(ilosc == 3)
{
lcd.clear();
lcd.setCursor(1,0);
lcd.print(" < PIN >");
lcd.setCursor(0,1);
lcd.print("***_");
}
if(ilosc == 4)
{
lcd.clear();
lcd.setCursor(1,0);
lcd.print(" < PIN >");
lcd.setCursor(0,1);
lcd.print("****_");
}
if(ilosc == 5)
{
lcd.clear();
lcd.setCursor(1,0);
lcd.print(" < PIN >");
lcd.setCursor(0,1);
lcd.print("*****_");
}
if(ilosc == 6)
{
lcd.clear();
lcd.setCursor(1,0);
lcd.print(" < PIN >");
lcd.setCursor(0,1);
lcd.print("******_");
}
if(ilosc == 7)
{
lcd.clear();
lcd.setCursor(1,0);
lcd.print(" < PIN >");
lcd.setCursor(0,1);
lcd.print("*******_");
}
if(ilosc == 8)
{
lcd.clear();
lcd.setCursor(1,0);
lcd.print(" < PIN >");
lcd.setCursor(0,1);
lcd.print("********");
}
if(ilosc == dlugosc)
{
delay(250);
checkPassword();
ilosc = 0;
}
}
}
void checkPassword()
{
if (password.evaluate())
{
int i;
for( i = 1; i <= 3; i++ )
{
digitalWrite(buzzer, HIGH);
delay(120);
digitalWrite(buzzer, LOW);
delay(70);
}
ilosc = 0;
password.reset();
Serial.println("Correcto");
digitalWrite(ledRed, LOW);
digitalWrite(ledGreen, HIGH);
lcd.clear();
lcd.setCursor(0,1);
lcd.print("<<PIN C ORRECTO>>");
delay(2000);
digitalWrite(ledGreen, LOW);
digitalWrite(ledRed, HIGH);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" *Bienvenido*");
lcd.setCursor(0,1);
lcd.print("FAVOR ENTRE PIN");
}
else
{
int i;
for( i = 1; i <= 1; i++ )
{
digitalWrite(buzzer, HIGH);
delay(300);
digitalWrite(buzzer, LOW);
delay(100);
}
ilosc = 0;
password.reset();
Serial.println("Error");
digitalWrite(ledGreen, LOW);
digitalWrite(ledRed, HIGH);
lcd.clear();
lcd.setCursor(0,1);
lcd.print("<<PIN ER RONEO>>");
delay(2000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print(" *Bienvenido*");
lcd.setCursor(0,1);
lcd.print("FAVOR ENTRE PIN");
}
}

CNC

Otros

Otros

XBOX 360

CONDENSADORES

Ethernet

Proyecto Comunicaciones

Ejercicio Sis

Ejercicio SiS

Solucin al Ejercicio

Robot seguidor de linea

TRANSISTOR

https://
bogotacity.olx.com.co/analizador-fluke-199-iid-894972136

Cdigo facilito
usuario [email protected]
contrasea wilpi7185467

MEDIDOR DE BATERAS
Este dispositivo nos permitir, por medio de dos LED's de color, saber el estado de
la carga de una batera cualquiera.
El circuito es mas que simple, cuando la tensin en el cursor del preset supera el
valor del diodo zener (Zx) + la tensin base-emisor del transistor mas la cada de
tensin de la resistencia de 33K el transistor se disparar, haciendo que el LED
verde brille. Al dispararse este transistor el segundo queda con su base a masa lo
cual hace que el LED rojo no ilumine.
Ahora, si la tensin presente en la base del primer transistor cae por debajo del
nivel de disparo el mismo se abrir, quedando sin masa el LED verde lo que har
que ste se apague. En este momento el LED verde se comporta como un diodo
en directa, haciendo que la base del segundo transistor quede exitada y
obligndolo a conducir. Al conducir este transistor hace que el LED rojo brille. De
esta forma tenemos un LED verde que brilla cuando la tensin de entrada alcanza
o supera la establecida en el preset y, cuando esta tensin no logra el nivel
requerido, el LED rojo es el que enciende.
Dado que quisimos hacer que este sistema sea apropiado para bateras de
diversas tensiones a continuacin proveemos una tabla que nos da los valores de
Zx y Rx apropiados segn la tensin de trabajo.
En nuestras pruebas estos valores fueron mas que correctos, pero si se desea
lograr mas brillo en los LED's bastar con reducir un poco los valores de Rx.

MEDIDOR DE BATERAS

COMPRAS
https://
www.banggood.com/es/Wholesale-Ardu
ino-SCM-and-3D-Printer-Acc-c-21530-1-1-45-0_page2.html

CMD
shutdown -s -t 3600
Temporizar
shutdown a Cancelar
Temp.
Cerrar un programa a las
malas
Tasklist (Lista de los
programas)
Taskkill / PID xxx /F

Alternador
Dispositivo que convierte la energa
mecnica en energa elctrica.

CIRCUITO DE UN RELOJ DIGITAL

CON PIC16F877A

CIRCUITO DE UN RELOJ DIGITAL CON PIC16F877A

Circuito del reloj digital con PIC 16F877A y display de 7 segmentos.
La hora se muestra en formato de 24 horas; por ejemplo 14:35 (dos
de la tarde y 35 minutos).
Dispone de botones para ajuste de horas y minutos. Un botn
adicional permite activar la presentacin (encender el display) por
un lapso de 1 segundo.
Luego de lo cual el display se apaga pero el conteo del tiempo
sigue corriendo. Un pin se activa por un lapso de 1 segundo a dos
horas diferentes programables por software.
REFERENCIAS
http
://www.programarpicenc.com/articulos/circuito-de-un-reloj-digital-c
on-pic16f877a
/

RELOJ DIGITAL EN MIKROC PRO CON EL PIC16F877A

A continuacin se muestra el cdigo completo

para este reloj digital, con el PIC16F877A
trabajando con el cristal oscilador externo de
4MHz.
Luego de varios intentos fallidos de simulacin en
Proteus ISIS pude comprobar que el problema se
debe a un error generado por el propio simulador,
para eso me val de un ejemplo muy sencillo con
el cual pude comparar los resultados
experimentales y simulados. Aparentemente falta
depurar esta versin del famoso simulador pues
presenta problemas con el puerto E.

Programa
//reloj7seg.c
//Microcontrolador: PIC16F877A
//Oscilador: Externo 4MHz (modo HS)
//******
//El Proteus 7.5 Professional no acepta la simulacin del puerto E y presenta un mensaje de error
//al intentar su simulacin. Se prob un ejemplo bsico para encender un LED el cual
//funcion perfectamente en la prctica pero el Proteus generaba el error "Internal Exception:
//acces violation in module PIC16.DLL".
//******
//Entradas:
//AA: Avance Automtico al mantener presionado (tambin avance paso a paso al pulsar y soltar).
//Ajuste de HORAS (AA) ->RB7(40)
//Ajuste de MI NUTOS (AA) ->RC7(26)
//ACTI VAR ->RD7(30)
//Salidas:
//Horas -> Puertos A y B
//Minutos -> Puertos C y D
//Dos puntos (:) ->RE1(9)
//Pulso de 1 segundo -> RE0(8)
//Funcin para transformar de binario(decimal) a 7 segmentos:
char Bin2_7seg(char digit){
switch (digit){
case 0: return 0x3F; //0x3F es el cdigo 7-segmentos del 0.
case 1: return 0x06; //0x06 es el cdigo 7-segmentos del 1.
case 2: return 0x5B;
case 3: return 0x4F;
case 4: return 0x66;
case 5: return 0x6D;
case 6: return 0x7D;
case 7: return 0x07;
case 8: return 0x7F;
case 9: return 0x67;
}
}
char contador=0,segundos=0,minutos=0,horas=0, minutosBCD, unidades, decenas, horasBCD, j=0;
bit activar;
void main(){
PORTA=0x00;
RE0_bit=0;
RE1_bit=0;
ADCON1=0x06; //Pines RA<5:0> como E/S digital.
PORTB=0x00; //Inicializacin.
PORTC=0x00;
PORTD=0x00;
TRISA=0x00; //Puerto A como salida.
TRISB=0x80; //RB7 como entrada. RB<6:0> como salidas.
TRISC=0x80; //RC7 como entrada. RC<6:0> como salidas.
TRISD=0x80; //RD7 como entrada. RD<6:0> como salidas.
TRISE0_bit=0; //RE0 como salida.
TRISE1_bit=0; //RE1 como salida.
OPTION_REG=0b01010111;
//Pull ups habilitados.Timer0 como temporizador.
//Prescaler asignado al Timer0. Prescaler 1:256.
TMR0=61;
//Valor inicial del TMR0. Interrupcin cada 50 ms.
GIE_bit=1;
//I nterrupciones habilitadas.
T0IE_bit=1;
//Interrupcin del Timer0 habilitada.
activar=1;
while (1){
if (segundos==60){
minutos++;
segundos=0;
}
if (minutos==60){
horas++;
minutos=0;
}
if (horas==24) horas=0;
//Encender los displays por 1 segundo al presionar ACTIVAR:
if (activar==1){
//Encender los dos puntos ":" :
RE1_bit=1;
//Transformar los minutos para su presentacin:
minutosBCD=Dec2Bcd(minutos);
//Transforma de binario a BCD.
unidades=0b1111&minutosBCD;
//Sacar las unidades.
decenas=0b11110000&minutosBCD;
//Sacar las decenas.
decenas=decenas>>4;
//Desplazar 4 bits a la derecha.
PORTD=Bin2_7seg(unidades);
//Unidades al puerto D.
PORTC=Bin2_7seg(decenas);
//Decenas al puerto C.
//Transformar las horas para su presentacin:
horasBCD=Dec2Bcd(horas);
//Transforma de binario a BCD.
unidades=0b1111&horasBCD;
//Sacar las unidades.
decenas=0b11110000&horasBCD;
//Sacar las decenas.
decenas=decenas>>4;
//Desplazar 4 bits a la derecha.
PORTB=Bin2_7seg(unidades);
//Unidades al puerto B.
if (decenas==1)
PORTA=Bin2_7seg(decenas);
//Decenas al puerto A.
if (decenas==2)
PORTA=0x3B;
//Formar el nmero "2".
if (decenas==0) PORTA=0;
//Apagar las decenas cuando valgan cero.
}
else{
PORTA=0;
PORTB=0;
PORTC=0;
PORTD=0;
PORTE=0;
}
//Generar un pulso a una determinada hora, por ejemplo a las 2h01.
if (horas==2 && minutos==01 && segundos==0)
RE0_bit=1;
if (horas==2 && minutos==01 && segundos==1)
RE0_bit=0;
//Generar un pulso a una determinada hora, por ejemplo a las 15h25.
if (horas==15 && minutos==25 && segundos==0)
RE0_bit=1;
if (horas==15 && minutos==25 && segundos==1)
RE0_bit=0;
}
}
void interrupt(void){
//Botn HORAS presionado:
if (Button(&PORTB,7,1,0)){
activar=1;
horas++;
if (horas==24) horas=0;
Delay_ms(200);
}
//Botn MINUTOS presionado:
if (Button(&PORTC,7,1,0)){
activar=1;
minutos++;
if (minutos==60) minutos=0;
Delay_ms(200);
}
//Botn ACTI VAR presionado:
if (Button(&PORTD,7,1,0))
activar=1;
//Medir 1 segundo (para el encendido de los displays):
if (activar==1){
j++;
if (j==20){
j=0;
activar=0;
}
}
//Medidor de segundos (para el reloj):
TMR0=61;
//Valor inicial del TMR0. Interrupcin cada 50 ms.
contador++;
if (contador==20){
segundos++;
contador=0;
}
T0IF_bit=0;
//Borra la bandera de interrupcin.
}

Logaritmos

Conexin Delta Estrella

Paginas de desarrollo
http://
elecnote.blogspot.com.co/search/label/Re
al%20Time%20Clock
Reparacin de celulares
http://www.movilcenterperu.com/
Logos
https://es.cooltext.com/Logo-Design-Burning

Programacin c

Variables Locales y Globales

A las variables locales se les asigna
valor y dicho valor no cambia de esa
funcin establecida, sin embargo,es
muy comun usar variables globales
como parmetros a una funcin ya
que de esta forma se puede hacer
uso de dichos valores fuera de la
funcion en la que se utilizo

Funciones con parmetros por

defecto
Si nosotros llamamos la funcin y no
le pasamos los argumentos, la
funcin va a tomar un valor por
defecto que nosotros le vamos
asignar.

Parmetros por referencia

Aqu no se pasa el valor sino la
direccin de memoria donde est
almacenado dicho valor.

Informacin del curso

WhatsApp 3124819511
INGENIERA ELSA MARIA JUNCA
BERNAL

Biografa Programacin en
C++
http://ingenieriaalainformatica.jimdo
.com/ejercicios-de-lenguaje-c
/

CONCEPTOS FSICOS
Permeabilidad: es la capacidad que tiene un material
de permitirle a un flujo que lo atraviese sin alterar su
estructura interna. Se afirma que un material es
permeable si deja pasar a travs de l una cantidad
apreciable de fluido en un tiempo dado, e impermeable
si la cantidad de fluido es despreciable.
Interpolacin: Es la obtencin de nuevos puntos
partiendo del conocimiento de un conjunto discreto de
puntos.
En ingeniera y algunas ciencias es frecuente disponer
de un cierto nmero de puntos obtenidos por muestreo
o a partir de un experimento y pretender construir una
funcin que los ajuste.

Amplificador Sumador

AMPLIFICADOR
SUMADOR

VALOR RMS

5V
Valor Pico a Pico=10V