INSTITUTO POLITÉCNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y ELÉCTRICA

UNIDAD AZCAPOTZALCO

INGENIERIA MECANICA

PLANTAS DE BOMBEO

CIRCUITO DE CONTROL DE NIVEL Y TEMPERATURA DE UN TANQUE DE

ALMACENAMIENTO

INTEGRANTES:

• CHÁVEZ MENDOZA CÉSAR ALAN

• NUÑEZ GONZALEZ MARCO ALEXS

PROFESOR: ING. CRUZ ESPINOSA ANTONIO

FECHA: 04/DICIEMBRE/2017

Página 1
 Índice
OBJETIVO ............................................................................................................................................................................. 3
PROPUESTAS ....................................................................................................................................................................... 3
PLANTEAMIENTO DEL PROBLEMA ............................................................................................................................... 4
TABLA DE VERDAD ........................................................................................................................................................... 5
DIAGRAMA DE COMPUERTAS LÓGICAS DE LA EXPRESIÓN SIMPLIFICADA ...................................................... 7
IMPLEMENTACIÓN DE CIRCUITO DE CONTROL (PROPUESTA CON COMPUERTAS LÓGICAS) ...................... 7
CIRCUITO (PROPUESTA CON MICROCONTROLADOR) .............................................................................................. 8
SENSORES DE TEMPERATURA ........................................................................................................................................ 8
CÓDIGO .ASM PROPUESTA PARA IMPLEMENTARLO EN EL PIC PIC16F84A ........................................................ 9

Página 2
OBJETIVO
Elaborar un sistema de control de niveles mínimos y máximos para una cisterna de agua potable, la cual estará
variando su temperatura lo que afectará el llenado y descarga de dichos cisterna, esto supervisado por un
sistema de control electrónico haciendo uso de circuitos integrados de lógica fija o programable valorando
entre estas dos opciones sus ventajas y desventajas para el mejor desarrollo del circuito.

PROPUESTAS
Para poder realizar el circuito de control se proponen 3 opciones las cuales son por medio compuertas lógicas,
microcontrolador y PLC’s; en el siguiente cuadro comparativo se muestras las ventajas y desventajas que se
presentan al implementar cualquiera de estas 3 opciones para la resolución del problema:

COMPONENTE VENTAJAS DESVENTAJAS

COMPUERTAS El bajo consumo de potencia estática, Un mayor tiempo de elaboración
LOGICAS gracias a la alta impedancia de entrada de debido a la gran cantidad de
los transistores y a que, en estado de reposo, conexiones dependiendo del tipo de
un circuito con compuertas lógicas sólo circuito que se desea realizar.
experimentará corrientes parásitas.
Se generan gran cantidad de perdidas
No existe una complejidad alta al diseñarlo. (aunque pequeñas), debido a la serie
de cableados y a las diferentes
Muchas veces los componentes necesarios, compuertas lógicas que se utilizaron;
aunque sean más en cantidad suelen ser es decir, entre mayor cableado y
incluso de menor precio que algún compuertas lógicas, mayores serán sus
microcontrolador PIC. pérdidas, y por consiguiente una
menor eficiencia en el proyecto.

MICROCONTROLA Nos permite controlar, programar y Una de las pocas desventajas de un

DORES sincronizar tareas electrónicas a través del microcontrolador PIC es que se
tiempo simplemente realizando una correcta necesitan llamar a muchas
programación. Ya que el circuito integrado instrucciones para realizar una tarea en
hace todo por nosotros, sin necesidad de particular. Esto siempre y cuando el
usar distintas compuertas lógicas. proyecto sea complejo.


En el mercado existen varios softwares que Otra de las desventajas, pero no tan
nos ayudan a programar un significativas es que los PIC no son
microcontrolador de este tipo, como por tan baratos, ya que pueden llegar a
ejemplo el PICC, o el MPLAB. Aunque en tener un costo alto.
este proyecto la programación se realizara
por MPLAB. Direccionan poca memoria, son
demasiado sensibles a la
En la familia de los PIC, existen más de 300 electrostática.
modelos diferentes correspondientes al tipo
de PIC que se necesita, lo cual nos garantiza
que habrá un modelo que se adecue muy a la
medida de nuestras necesidades a la hora de
hacer un proyecto.

Página 3
PLC’s · Su instalación es bastante sencilla, además
· La principal desventaja es que se
de ocupar poco espacio y la posibilidad de requiere un personal calificado para el
manejar múltiples equipos de manera manejo de estos dispositivos, lo que
simultánea gracias a la automatización. implica no solo un costo relativamente
elevado, sino también la dificultad de
· Hay un mejor monitoreo de los procesos, encontrarlo.
lo que hace que la detección de fallos se
realice rápidamente. · Otra desventaja es que se deben tener
en cuenta múltiples detalles para que
· Se ahorran costos adicionales como los de la operación salga a la perfección,
operación, mantenimiento e incluso energía. tanto en la producción, como en el
código de programación.

· El elevado costo de inversión inicial

para la adquisición del dispositivo y
elementos necesarios para su
operación.

Actualmente, la mayoría de los aparatos electrónicos se realizan mediante el uso de microcontroladores,

precisamente para tener una mayor efectividad. Es por ello por lo que, para la propuesta que se va a realizar se
decidió el uso de microcontroladores (PIC16F84A), debido a la gran serie de ventajas, principalmente ya que,
como se mencionó anteriormente es un dispositivo el cual nos permite controlar y sincronizar tareas, y
prácticamente mediante una buena programación hace todo por nosotros. De esta manera reducimos el tiempo
de elaboración evitando el uso de diversas compuertas lógicas y gran cantidad de cableado. Así mismo, se
evitan mayores pérdidas mediante el uso de microcontroladores, además de la fácil programación para obtener
un funcionamiento adecuado. Por consiguiente, se nos hizo como mejor opción el uso de estos.

PLANTEAMIENTO DEL PROBLEMA

En esta aplicación a los sistemas digitales, se desarrolla la lógica de control de un sistema digital que permite
controlar el fluido que hay en una cisterna. El propósito de la lógica es mantener un nivel apropiado de fluido
controlando las válvulas de entrada y de salida. La lógica también tiene que controlar la temperatura del fluido
dentro de un determinado rango y disparar una alarma si el sensor de nivel o el sensor de temperatura fallan.
Las salidas de la lógica de control del sistema controlan la entrada de fluido, la salida de fluido y la temperatura
del mismo. La lógica de control actúa sobre una válvula de entrada que permite que el fluido entre en el tanque
hasta que el sensor de nivel alto se activa al quedar sumergido en el fluido. Cuando el sensor de nivel alto está
sumergido (activado) la lógica de control cierra la válvula de entrada. El fluido contenido en el tanque debe
mantenerse dentro de un rango de temperatura especificado, el cual queda determinado por dos sensores de
temperatura. Uno de los sensores de temperatura indica si el fluido está demasiado caliente y el otro si el fluido
está demasiado frío. La lógica de control activa un elemento de calefacción si los sensores de temperatura
indican que el fluido está demasiado frío. La lógica de control mantiene abierta la válvula de salida siempre que
el sensor de nivel bajo esté sumergido y el fluido se encuentre a la temperatura adecuada. Cuando el nivel de
fluido cae por debajo del sensor de nivel bajo, la lógica de control cierra la válvula de salida.
Los niveles máximo y mínimo de fluido quedan determinados por las posiciones de los sensores de nivel del
tanque. La salida de cada sensor estará a nivel ALTO mientras que esté sumergido en el fluido y estará a nivel
Página 4
BAJO cuando no quede sumergido. Cuando la salida del sensor de nivel alto está a nivel BAJO, la lógica de
control genera un nivel ALTO y abre la válvula de entrada. Cuando la salida del sensor de nivel alto está a nivel
ALTO, la lógica de control genera un nivel BAJO y cierra la válvula de entrada.
Antes de abrir la válvula de salida, el fluido debe encontrarse dentro del rango de temperatura especificado. Un
sensor genera un nivel ALTO cuando el fluido está muy caliente y el otro sensor de temperatura genera un nivel
ALTO cuando la temperatura es demasiado baja. La lógica de control genera un nivel ALTO para activar el
elemento de calefacción cuando se tiene la indicación de temperatura baja; en caso contrario, el elemento de
calefacción está apagado. Cuando aparece la condición de temperatura alta, se activa una alarma.
Cuando el sensor de nivel bajo genera una salida a nivel ALTO (lo que indica que está sumergido) y la salida de
los dos sensores de temperatura están a nivel BAJO (lo que indica que el fluido está a la temperatura correcta),
la lógica de control abre la válvula de salida. Si la salida del sensor de nivel bajo pasa a nivel BAJO o si las
salidas de los sensores de temperatura pasan a nivel ALTO, la lógica de control cierra la válvula de salida.
Si la lógica de control detecta un fallo en cualquiera de los sensores o una condición de temperatura muy alta, se
activa una alarma. Un fallo en un sensor de nivel se produce cuando el sensor de nivel alto está activado y el
sensor de nivel bajo no lo está. Un fallo en un sensor de temperatura se indica mediante la activación de los dos
sensores a un mismo tiempo.

TABLA DE VERDAD
A B C D w x y z
NA NB TA TB VE VS C A
0 0 0 0 1 0 0 0
0 0 0 1 1 0 1 0
0 0 1 0 0 0 0 1
0 0 1 1 0 0 0 1
0 1 0 0 1 1 0 0
0 1 0 1 1 0 1 0
0 1 1 0 0 0 0 1
0 1 1 1 0 0 0 1
1 0 0 0 0 0 0 1

Página 5
 1 0 0 1 0 0 0 1
1 0 1 0 0 0 0 1
1 0 1 1 0 0 0 1
1 1 0 0 0 1 0 0
1 1 0 1 0 0 1 0
1 1 1 0 0 0 0 1
1 1 1 1 0 0 0 1

1. Obtención de la expresión suma de productos

𝑤 = 𝐴̅𝐵̅𝐶̅ 𝐷̅ + 𝐴̅𝐵̅𝐶̅ 𝐷 + 𝐴̅𝐵𝐶̅ 𝐷
̅ + 𝐴̅𝐵𝐶̅ 𝐷
𝑥 = 𝐴̅𝐵̅𝐶̅ 𝐷̅ + 𝐴𝐵𝐶̅ 𝐷 ̅
𝑦 = 𝐴𝐵̅𝐶 𝐷 + 𝐴𝐵𝐶 𝐷 + 𝐴𝐵𝐶̅ 𝐷
̅ ̅ ̅ ̅
𝑧 = 𝐴̅𝐵̅𝐶𝐷 ̅ + 𝐴̅𝐵̅𝐶𝐷 + 𝐴̅𝐵𝐶𝐷 ̅ + 𝐴̅𝐵𝐶𝐷 + 𝐴𝐵̅𝐶̅ 𝐷
̅ + 𝐴𝐵̅𝐶̅ 𝐷 + 𝐴𝐵̅𝐶𝐷
̅ + 𝐴𝐵̅𝐶𝐷 + 𝐴𝐵𝐶𝐷
̅ + 𝐴𝐵𝐶𝐷

2. Simplificación de expresión

̅𝑩
𝒘=𝑨 ̅𝑫
̅𝑪 ̅ +𝑨
̅𝑩 ̅𝑫 + 𝑨
̅𝑪 ̅𝑫
̅ 𝑩𝑪 ̅ +𝑨 ̅𝑫
̅ 𝑩𝑪

CD
A B 00 01 11 10
0 0 1 1

0 1 1 1

1 1

1 0
𝑤 = 𝐴̅𝐶̅

̅𝑩
𝒙=𝑨 ̅𝑫
̅𝑪 ̅𝑫
̅ + 𝑨𝑩𝑪 ̅

CD
A B 00 01 11 10
0 0

0 1 1

1 1 1

1 0

𝑤 = 𝐵𝐶̅ 𝐷
̅

̅𝑩
𝒚=𝑨 ̅𝑫 + 𝑨
̅𝑪 ̅ 𝑫 + 𝑨𝑩𝑪
̅ 𝑩𝑪 ̅𝑫

CD
A B 00 01 11 10
0 0 1

0 1 1

1 1 1
Página 6
1 0
 𝑦 = 𝐴̅𝐶̅ 𝐷 + 𝐵𝐶̅ 𝐷

̅𝑩
𝒛=𝑨 ̅ 𝑪𝑫
̅ +𝑨
̅𝑩̅ 𝑪𝑫 + 𝑨
̅ 𝑩𝑪𝑫
̅ +𝑨
̅ 𝑩𝑪𝑫 + 𝑨𝑩
̅𝑪̅𝑫
̅ + 𝑨𝑩
̅𝑪̅ 𝑫 + 𝑨𝑩
̅ 𝑪𝑫
̅ + 𝑨𝑩
̅ 𝑪𝑫 + 𝑨𝑩𝑪𝑫
̅ + 𝑨𝑩𝑪𝑫

CD
A B 00 01 11 10
0 0 1 1

0 1 1 1

1 1 1 1

1 0 1 1 1 1

𝑧 = 𝐶 + 𝐴𝐵̅𝐶̅

DIAGRAMA DE COMPUERTAS LÓGICAS DE LA EXPRESIÓN SIMPLIFICADA

IMPLEMENTACIÓN DE CIRCUITO DE CONTROL (PROPUESTA CON COMPUERTAS

LÓGICAS)

Página 7
CIRCUITO (PROPUESTA CON MICROCONTROLADOR)

SENSORES DE TEMPERATURA

Página 8
CÓDIGO .ASM PROPUESTA PARA IMPLEMENTARLO EN EL PIC PIC16F84A

//Libreria universal para el sistema bolt cristal externo 20 mhz

//velocidad efectiva de 48 mhz

//definiciones de pines:

#define rele portabits.ra0

#define sw1 portabits.ra4

#define sw2 portabits.ra5

#define sw3 portcbits.rc0

#define sw4 portcbits.rc1

#define ra1 portabits.ra1

#define ra2 portabits.ra2

#define ra3 portabits.ra3

#define rb0 portbbits.rb0

Página 9
#define rb1 portbbits.rb1

#define rb2 portbbits.rb2

#define rb3 portbbits.rb3

#define rb4 portbbits.rb4

#define rb5 portbbits.rb5

#define rb6 portbbits.rb6

#define rb7 portbbits.rb7

#define delay_us delay10tcyx

//funciones disponibles:

Void writeeeprom(unsigned char addr,unsigned char byte); //escribe un dato en la eeprom

Unsigned char readeeprom(unsigned char addr); //lee un dato de la eeprom

Void init_bolt(void); //inicializa puertos leds y microswitches en bolt

Int microsw(void); //lee los microswitches, la función toma el valor de 0...15

Void delay_ms(int i); //delay con parámetro en milisegundos (i<32000)

Void enablelcd(void); //pulso de escritura

Void enablelcd2(void); //pulso de escritura

Void initlcd(void); //inicializa lcd

Void clearscreen(void); //borra lcd

Void gotoxy(unsigned char r, unsigned char c); //posiciona cursor en celda seleccionada

Void putlcd(char c); //escribe caracter en lcd parámetro en ascii

Void printstring(const char* s); //escribe string hasta 8 caracteres. Parámetro es el string.

Unsigned char getbot(void); //lee 1 caracter del teclado. La función regresa con el valor ascii de la tecla.

Void fin(void);

Void setbot(void); //lee un string del teclado terminando con "f". Lo guarda en el arreglo "bot[]"

Void row(void);

Void wrtbot(void); //escribe el string almacenado en el arreglo "bot[]" en el lcd.

//función también disponible: delay_us(); parámetro <250.

Void delay_ms(int i)

long int j;

for(j=0;j<i;j++)
Página
10
 {

delay1ktcyx(12); //a 48 mhz mhz, 1 ms aprox.

//inicializa los puertos a, b y c

Void init_bolt(void)

Adcon1=0x0f; //deshabilita convertidores a/d

Cmcon=7;

Trisb=0; //portb son salidas

Trisa=0x30; //ra4,ra5 son entradas (microswitches). Ra0,ra1,ra2,ra3 son salidas

Trisc=0x0f; //rc0,rc1 son entradas (microswitches)

Intcon2bits.rbpu=0; //selecciona resistencias de pull up en puerto b (rb4...rb7).

Portb=0;

Rele=0; //apaga leds y relevador

/*microswitches*/

//lee los microswitches. Regresa con un valor de 0...15.

Int microsw(void)

Int i;

I=(sw1*1)+(sw2*2)+(sw3*4)+(sw4*8);

Return i;

/*lcd*/

Void enablelcd(void) {

ra1=0; delay_us(50); //rs= 0

ra2=1; delay_us(50); //e = 1

ra2=0; delay_us(50); //e = 0

}
Página
11
Void enablelcd2(void) {

ra1=1; delay_us(50); //rs=1

ra2=1; delay_us(50); //e =1

ra2=0; delay_us(50); //e =0

Void initlcd(void) {

portb=0x38; enablelcd(); delay_ms(50);

portb=0x01; enablelcd(); delay_ms(50);

portb=0x0d; enablelcd(); delay_ms(50);

portb=0x06; enablelcd(); delay_ms(50);

Void clearscreen(void) {

portb=0x01;

enablelcd();

delay_ms(10);

Void gotoxy(unsigned char r, unsigned char c) {

portb=0x02; enablelcd();

delay_ms(10);

for(r=r*40+c, c=0; c<r; c++) {

portb= 0x14;

enablelcd();

delay_us(50);

Página
12
Void putlcd(char c) {

portb = c; enablelcd2(); delay_us(50);

Void printstring(const char* s) {

while( *s ) putlcd(*(s++));

/*teclado*/

Char key[16] = {0xee,0xed,0xeb,0xe7,0xde,0xdd,0xdb,0xd7,0xbe,0xbd,0xbb,0xb7,0x7e,0x7d,0x7b,0x77};

Char asc[16] = {0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x41,0x42,0x43,0x44,0x45,0x46};

Unsigned char aa,bb,cc,dd,ee,ff,xx,yy,zz,boton;

Char bot[9];

Unsigned char getbot(void) //la variable de salida se define como unsigned char

Loop:

ee=0;

trisa=0x30; /*puerto a:ra0,ra1,ra2 salidas; ra4,ra5 entradas*/

trisb=0xf0;

// rbpu=0; //registro option, bit7. Ver función init_bolt()

// porta=0; /*puerto b rb0..rb3 salidas, rb4..rb7*/

aa=0xef;

portb=aa;

bb=4;

while (bb>0) /*4 corrimientos hacia la derecha*/

{aa=aa/2;

portb=aa; /*escribe en portb rb0..rb3*/

/*lee puerto rb4..rb7*/

delay_ms(5);

if (rb4==0||rb5==0||rb6==0||rb7==0)fin();

if (ee==1)return (ff); /*regresa con el valor de la tecla en ascii*/

Página
13
 bb=bb-1;}

goto loop;

Void fin(void){ /*tecla oprimida*/

trisb=0xf0;

dd=portb;

cc=(dd & 0xf0); /*bits rb0..rb3 =0, conserva rb4..rb7*/

aa=(aa & 0x0f); /*bits rb4..rb7 =0, conserva rb0..rb3*/

aa=(aa | cc); /*la variable "a" contiene el código rengón columna de la tecla oprimida*/

Malla:

dd=portb;

cc=(dd & 0xf0); /*bits rb0..rb3 =0, conserva rb4..rb7*/

if(cc!=0xf0)goto malla; /*espera que la tecla se libere*/

trisb=0;

row();

ff=xx; /*convierte a código ascii*/

ee=1;

void row(void)

for(yy=0;yy<16;yy=yy+1)

{if (aa==key[yy])xx=asc[yy];} /*la variable "x" contiene el valor ascii*/

portb=xx;

delay_ms(100);

Void setbot(void)

For(zz=0;zz<7;zz++)

{boton=getbot();

Bot[zz]=boton;
Página
14
If(bot[zz]==0x46)goto qu;

Else putlcd(boton);}

Qu:bot[zz]=0x00;

Void wrtbot(void)

For(zz=0;zz<7;zz++)

{putlcd(bot[zz]);

If(bot[zz+1]==0)goto ka;}

Ka:zz=zz; //expresión dummy

/*funciones para escribir y leer en la eeprom interna*/

Void writeeeprom(unsigned char addr,unsigned char byte)

Unsigned char i=intconbits.gieh;

Intconbits.gieh = 0; //disable interrupts

Eecon1bits.eepgd=0; //write to eeprom

Eecon1bits.cfgs=0; //eeprom not config bits

Eecon1bits.wren=1; //allows write

Eeadr=addr;

Eedata=byte;

Eecon2=0x55;

Eecon2=0xaa;

Eecon1bits.wr=1;

While(eecon1bits.wr); //wait until written

//while(!pir2bits.eeif);

//pir2bits.eeif=0;

Eecon1bits.wren=0; //no more write

Intconbits.gieh = i; //restore interrupts

Página
15
Unsigned char readeeprom(unsigned char addr)

Eecon1bits.cfgs=0; //eeprom not config bits

Eecon1bits.eepgd=0;

Eeadr=addr;

Eecon1bits.rd=1;

Return (unsigned int) eedata;

//ONEWIRE-BOLT.h

//ARCHIVO AUXILIAR CON LAS FUNCIONES PARA LEER LA

//TEMPERATURA DEL SENSOR DS18B20 DEL SISTEMA BOLT.

//USA EL PIN RA3 PARA CONECTARSE AL DS18B20

//LA FUNCION ds1820_read() REGRESA UN VALOR

//DE PUNTO FLOTANTE CON LA TEMPERATURA LEIDA.

//VALOR CON DOS ENTEROS Y UN DECIMAL.

//NO OLVIDE INSERTAR EL SENSOR DS18B20 EN SU BASE

//DE 3 PINES EN EL MODULO BOLT.

//PROGRAMA INICIALMENTE DESARROLLADO PARA

//EL COMPILADOR CCS,CON MODIFICACIONES Y

//ADAPTACIONES PARA EL COMPILADOR C18,Y EL SISTEMA

//18F2550, REALIZADA POR PUNTO FLOTANTE S.A.

float ds1820_read(void);

void onewire_reset(void);

void onewire_write(int data);

int onewire_read(void);

float ds1820_read(void)

int busy=0, temp1, temp2;

long signed int temp3,temp4;

float result;

onewire_reset();

onewire_write(0xCC); //Skip ROM, address all devices

Página
16
 onewire_write(0x44); //Start temperature conversion

while(busy == 0) //Wait while busy (bus is low)

busy = onewire_read();

onewire_reset();

onewire_write(0xCC); //Skip ROM, address all devices

onewire_write(0xBE); //Read scratchpad

temp1 = onewire_read();

temp2 = onewire_read();

temp3 = temp1+(temp2*256);

result=(float)temp3/16;

delay_ms(200);

return result;

void onewire_reset(void)

TRISA=0X00; //RA4 salida

RA3=0; // RA4=0

delay_ms(1);

TRISA=0X08; //Alta impedancia

delay_ms(1); //espera fin de pulso

void onewire_write(int data)

int i,count;

for(count = 0; count < 8; ++count)

TRISA=0X00;

RA3=0;

delay_us(2); // pull 1-wire low to initiate write time-slot.

i=(data&0x01); //output_bit(ONE_WIRE_PIN, shift_right(&data, 1, 0)); // set output

bit on 1-wire

if(i==1)RA3=1;

if(i==0)RA3=0;

Página
17
 delay_us(60); // wait until end of write slot.

TRISA=0X08; //output_float(ONE_WIRE_PIN); // set 1-wire high again,

delay_us(2); // for more than 1 us minimum.

data=(data>>1);

int onewire_read(void)

int count, data;

for(count = 0; count < 8; ++count)

TRISA=0X00; //RA4 es salida;

RA3=0; //output_low(ONE_WIRE_PIN);

delay_us(2); // pull 1-wire low to initiate read time-slot.

TRISA=0X08; //RA4 ES ENTRADA

delay_us(8); // let device state stabilise,

data=data>>1; //shift_right(&data, 1, input(ONE_WIRE_PIN)); // and load result.

if(RA3==1)

data=(data|0x80); //MSB=1

if(RA3==0)

data=(data&0x7F); //MSB=0

delay_us(120); // wait until end of read slot.

return data;

Página
18