Niple - Manual de Usuario PDF

PROGRAMACIÓN VISUAL DE MICROCONTROLADORES
NIPLE SOFTWARE
Manual de Usuario
NIPLE - PROGRAMACIÓN VISUAL DE MICROCONTROLADORES PIC
Tabla de contenidos
INTRODUCCIÓN A LOS MICROCONTROLADORES ..................................................................................... 6

¿Qué es un microcontrolador? ...................................................................................................................... 6
Los microcontroladores “PIC” ........................................................................................................................ 6
Estructura de un microcontrolador................................................................................................................ 7
El procesador o CPU .................................................................................................................................. 7
Memoria ROM ........................................................................................................................................... 8
Memoria RAM ........................................................................................................................................... 9
Registros y Bits ........................................................................................................................................... 9
Líneas de entrada y salida (E/S) – Puertos ............................................................................................... 13
Temporizadores internos (TMRs) ............................................................................................................ 14
Utilizando un microcontrolador ................................................................................................................... 16
Niple: Programación Visual de microcontroladores PIC .............................................................................. 18
INTRODUCCIÓN A NIPLE ....................................................................................................................... 20
Entorno Visual de desarrollo para programación de microcontroladores PIC ............................................ 20
Funciones disponible.................................................................................................................................... 21
Herramientas adicionales ............................................................................................................................ 23
METODOLOGÍA DE PROGRAMACIÓN CON NIPLE .................................................................................... 25
Conceptos básicos ........................................................................................................................................ 25
Instrucciones ............................................................................................................................................ 25
Etiquetas .................................................................................................................................................. 26
Interrupciones ......................................................................................................................................... 27
Subrutinas de usuario .............................................................................................................................. 28
La interfaz de Niple .................................................................................................................................. 29
Secciones de trabajo ................................................................................................................................ 29
Entornos .................................................................................................................................................. 33
Crear un nuevo entorno .......................................................................................................................... 34
Seleccionar el entorno actual de trabajo ................................................................................................. 34
Borrar un entorno .................................................................................................................................... 34
Bloques .................................................................................................................................................... 35
Interpretación de los bloques:................................................................................................................. 35
Selección de bloques o vínculos .............................................................................................................. 36
Mover un bloque ..................................................................................................................................... 37
2
Estirar un bloque ..................................................................................................................................... 38

Borrar bloques ......................................................................................................................................... 38
Editar bloques .......................................................................................................................................... 39
Duplicar bloques ...................................................................................................................................... 39
Habilitar e inhabilitar bloques ................................................................................................................. 40
Vínculos entre bloques (Flechas) ............................................................................................................. 41
Crear un vínculo ....................................................................................................................................... 43
Cambiar el estilo de un vínculo ................................................................................................................ 43
Borrar vínculos ......................................................................................................................................... 44
Ingreso de datos ...................................................................................................................................... 44
Control de ingreso de nombres de registros ........................................................................................... 45
Control de ingreso de valores literales .................................................................................................... 46
Modos de trabajo: Nivel de Usuario ........................................................................................................ 46
Rutinas de usuario ....................................................................................................................................... 47
Exportar una rutina de usuario ................................................................................................................ 47
Importar una rutina de usuario ............................................................................................................... 49
Exportar imagen ...................................................................................................................................... 49
Programando con Niple ............................................................................................................................... 50
Crear un nuevo proyecto ......................................................................................................................... 50
Declaración de registros .......................................................................................................................... 53
Borrar un registro .................................................................................................................................... 55
Declaración de bits .................................................................................................................................. 55
Borrar un bit de usuario........................................................................................................................... 56
Cambiar el nombre a un bit de usuario ................................................................................................... 56
Insertar bloques ....................................................................................................................................... 58
Descripción de las funciones ................................................................................................................... 62
Instrucciones ............................................................................................................................................ 62
Instrucciones orientadas a registros ........................................................................................................ 62
Instrucciones orientadas a bits ................................................................................................................ 63
Instrucciones orientadas a literales ......................................................................................................... 63
Instrucciones orientadas a control .......................................................................................................... 64
Rutinas básicas......................................................................................................................................... 64
Iniciar programa ...................................................................................................................................... 66
Asignar valor a un Bit ............................................................................................................................... 66
3
Asignar valor a un registro ....................................................................................................................... 67

Configurar puerto .................................................................................................................................... 68
Leer puerto .............................................................................................................................................. 69
Escribir puerto ......................................................................................................................................... 69
Conversión Analógica/Digital................................................................................................................... 70
Configuración de los canales A/D ............................................................................................................ 70
Conversión A/D ........................................................................................................................................ 71
Condición ................................................................................................................................................. 73
Comparar bit ............................................................................................................................................ 73
Comparar registro .................................................................................................................................... 75
Cálculos matemáticos .............................................................................................................................. 77
Suma ........................................................................................................................................................ 77
Resta ........................................................................................................................................................ 78
Multiplicación .......................................................................................................................................... 79
División .................................................................................................................................................... 80
Incrementar uno ...................................................................................................................................... 81
Decrementar uno ..................................................................................................................................... 83
Dec a BCD................................................................................................................................................. 84
Convertir valor BCD a registro ................................................................................................................. 85
Escalado proporcional ............................................................................................................................. 86
Tablas ....................................................................................................................................................... 87
Crear una nueva tabla.............................................................................................................................. 88
Consultar tabla......................................................................................................................................... 90
Tiempos por bucles .................................................................................................................................. 91
Memoria EEPROM interna....................................................................................................................... 92
Declaración de Registros EEPROM .......................................................................................................... 92
Leer EEPROM ........................................................................................................................................... 93
Grabar EEPROM ....................................................................................................................................... 94
DECLARACIÓN DE DISPOSITIVOS ........................................................................................................... 95
Display de siete segmentos sin codificador ................................................................................................. 95
Display de 7 segmentos con codificador ...................................................................................................... 96
Implementación en el diagrama de flujo ................................................................................................. 96
Pantalla LCD ............................................................................................................................................... 100
Configurar LCD ....................................................................................................................................... 102
4
Utilizando más de una pantalla LCD ...................................................................................................... 105

Generar un nuevo mensaje ................................................................................................................... 107
Visualizando valores variables en un mensaje ...................................................................................... 111
Mostrar Mensaje ................................................................................................................................... 114
Optimización del código Assembler ...................................................................................................... 115
Enviar comandos ................................................................................................................................... 115
Enviar caracteres ................................................................................................................................... 117
Teclado Matricial........................................................................................................................................ 118
Memorias EEPROM I2C .............................................................................................................................. 119
Leer memoria EEPROM I2C.................................................................................................................... 120
Escribir memoria EEPROM I2C ............................................................................................................... 122
Memorias RAM .......................................................................................................................................... 123
Leer memoria RAM I2C .......................................................................................................................... 124
Escribir memoria RAM I2C ..................................................................................................................... 126
Reloj de tiempo real PCF8583 .................................................................................................................... 128
Declaración del dispositivo .................................................................................................................... 128
Implementación..................................................................................................................................... 129
Inicialización........................................................................................................................................... 130
Escritura ................................................................................................................................................. 131
Configuración de alarmas ...................................................................................................................... 135
Lectura ................................................................................................................................................... 137
Comunicación RS232 .................................................................................................................................. 138
Comunicación RS485 .................................................................................................................................. 142
Modo maestro ....................................................................................................................................... 144
Interrogar ............................................................................................................................................... 148
Procedimiento para programación de los PIC12F6xx ................................................................................ 149
5
INTRODUCCIÓN A LOS MICROCONTROLADORES
¿Qué es un microcontrolador?
Los microcontroladores hicieron su aparición a principio de los ’80 y se trata de un circuito

integrado programable que contiene toda la estructura (arquitectura) de una microcomputadora.
Es decir que, dentro de un microcontrolador podemos encontrar:
• CPU (Unidad Central de Proceso)

• Memoria RAM
• Memoria ROM
• Memoria EEPROM (Memoria de lectura y
escritura no volátil, es decir, que no se
pierden los datos cuando el circuito es
desconectado)
• Puertos de Entrada/Salida (Pines de E/S)
• Módulos periféricos: conversores
analógico/digital (A/D), módulos PWM
(control por ancho de pulso), módulos de
comunicaciones seriales o en paralelo, y más.
Todo esto lo podemos encontrar dentro del mismo circuito integrado.
Cada vez existen más productos que incorporan microcontroladores con el fin de aumentar
sustancialmente sus prestaciones, reducir su tamaño y costo, mejorar su confiabilidad y disminuir
el consumo de energía.
Los microcontroladores “PIC”
Los microcontroladores denominados “PIC” corresponden exclusivamente a la marca Microchip.

PIC significa “Peripheral Interface Controller” y fue desarrollado por Microchip a principio de los
80.
Existe una gran cantidad de modelos de microcontroladores cuyas características y prestaciones

varían de un modelo a otro. De esta manera los desarrolladores pueden seleccionar el modelo que
mejor se ajuste a sus necesidades.
6
Los distintos modelos de microcontroladores se agrupan por “familia”. Una familia puede estar
formada por un conjunto de modelos cuyas características y prestaciones son bastante similares.
Cuando compramos un microcontrolador, la memoria del mismo se encuentra “vacía” y para que
funcione es necesario que sea “programado”, es decir que, el desarrollador debe escribir un
programa que contenga todos los procesos que el microcontrolador debe ejecutar.
Este programa se escribe en un lenguaje llamado “Assembler” (ensamblador) cuya principal

característica es su alta complejidad ya que se trata de un lenguaje “de bajo nivel”, es decir, que se
encuentra “más cercano” al lenguaje de la máquina que del lenguaje humano.
Por esto, sólo los técnicos altamente capacitados están en condiciones de realizar desarrollos
electrónicos que incluyan microcontroladores. Incluso a estos especialistas les implica un gran
esfuerzo intelectual y mucho tiempo de desarrollo.
Estructura de un microcontrolador
Básicamente, un microcontrolador está compuesto por los siguientes componentes:
• Procesador o CPU (del inglés Central Processing Unit o Unidad Central de Proceso).
• Memoria para el programa tipo ROM.
• Memoria RAM para contener los datos.
• Líneas de E/S para comunicarse con el exterior.
• Diversos módulos para el control de periféricos (temporizadores, Puertas Serie y Paralelo,
CAD: Conversores Analógico/Digital, CDA: Conversores Digital/Analógico, etc.).
El procesador o CPU
Es el elemento más importante del microcontrolador y determina sus principales características,

tanto a nivel hardware como software. La CPU (Central Processing Unit o Unidad Central de
Proceso) se encarga la decodificación y ejecución del programa.
Actualmente, existen 3 tipos de arquitectura de procesadores:
• CISC (Computadores de Juego de Instrucciones Complejo): disponen de más de 80

instrucciones en su repertorio, algunas de las cuales son muy sofisticadas y potentes,
requiriendo muchos ciclos para su ejecución. Una ventaja de los procesadores CISC es que
ofrecen instrucciones complejas que actúan como macros.
7
• RISC (Computadores de Juego de Instrucciones Reducido): En estos procesadores el

repertorio de instrucciones es muy reducido y las instrucciones son simples y
generalmente se ejecutan en un ciclo. La ventaja de éstos es que la sencillez y rapidez de
las instrucciones permiten optimizar el hardware y el software del procesador.
• SISC (Computadores de Juego de Instrucciones Específico): En los microcontroladores

destinados a aplicaciones muy concretas, el juego de instrucciones, además de ser
reducido, es “específico”, o sea, las instrucciones se adaptan a las necesidades de la
aplicación prevista.
Memoria ROM
La memoria ROM es una memoria no volátil, es decir, que no se pierden los datos al desconectar
el equipo y se destina a contener el programa de instrucciones que gobierna la aplicación. Los
microcontroladores disponen de capacidades de ROM comprendidas entre 512 bytes y 8 k bytes.
Existen distintos tipos de memorias ROM, la cual determinará la aplicación del microcontrolador.
• ROM con máscara: Es una memoria no volátil de sólo lectura cuyo contenido se graba
durante la fabricación del chip. El elevado costo del diseño de la máscara sólo hace
aconsejable el empleo de los microcontroladores con este tipo de memoria cuando se
precisan cantidades superiores a varios miles de unidades.
• OTP: El microcontrolador contiene una memoria no volátil de sólo lectura “programable

una sola vez” por el usuario. OTP (One Time Programmable). Es el usuario quien puede
escribir el programa en el chip mediante un sencillo grabador controlado por un programa
desde una PC. La versión OTP es recomendable cuando es muy corto el ciclo de diseño del
producto, o bien, en la construcción de prototipos y series muy pequeñas. Tanto en este
tipo de memoria como en la EPROM, se suele usar la encriptación mediante fusibles para
proteger el código contenido.
• EPROM: Los microcontroladores que disponen de memoria EPROM (Erasable

Programmable Read OnIy Memory) pueden borrarse y grabarse muchas veces. La
grabación se realiza, como en el caso de los OTP, con un grabador gobernado desde un PC.
Si, posteriormente, se desea borrar el contenido, disponen de una ventana de cristal en su
superficie por la que se somete a la EPROM a rayos ultravioleta durante varios minutos.
Las cápsulas son de material cerámico y son más caros que los microcontroladores con
memoria OTP que están hechos con material plástico.
8
• EEPROM: Se trata de memorias de sólo lectura, las cuales se puede escribir y borrar
eléctricamente. EEPROM (Electrical Erasable Programmable Read OnIy Memory). Tanto la
programación como el borrado, se realizan eléctricamente desde el propio grabador y bajo
el control programado de un PC. Es muy cómoda y rápida la operación de grabado y la de
borrado. No disponen de ventana de cristal en la superficie. Los microcontroladores
dotados de memoria EEPROM una vez instalados en el circuito, pueden grabarse y
borrarse cuantas veces se quiera sin ser retirados de dicho circuito. Para ello se usan
“grabadores en circuito” que confieren una gran flexibilidad y rapidez a la hora de realizar
modificaciones en el programa de trabajo. El número de veces que puede grabarse y
borrarse una memoria EEPROM es finito, por lo que no es recomendable una
reprogramación continua. Son muy idóneos para la enseñanza y la Ingeniería de diseño. Se
va extendiendo en los fabricantes la tendencia de incluir una pequeña zona de memoria
EEPROM en los circuitos programables para guardar y modificar cómodamente una serie
de parámetros que adecuan el dispositivo a las condiciones del entorno. Este tipo de
memoria es relativamente lenta.
• FLASH: Se trata de una memoria no volátil, de bajo consumo, que se puede escribir y
borrar. Funciona como una ROM y una RAM pero consume menos y es más pequeña. A
diferencia de la ROM, la memoria FLASH es programable en el circuito. Es más rápida y de
mayor densidad que la EEPROM. La alternativa FLASH está recomendada frente a la
EEPROM cuando se precisa gran cantidad de memoria de programa no volátil. Es más
veloz y tolera más ciclos de escritura y borrado.
Memoria RAM
La memoria RAM es una memoria volátil, es decir, que se pierden los datos al desconectar el
equipo, y se destina a guardar las variables y los datos. Los microcontroladores disponen de
capacidades de RAM comprendidas entre 20 y 512 bytes.
Registros y Bits
Un registro es una posición de memoria en la cual se puede almacenar un dato. Es decir que la
memoria está dividida en pequeñas “partes” llamadas “Registros”.
Dentro de la memoria, cada registro se identifica mediante un número, el cual se denomina

“Dirección de memoria” y generalmente está expresado en formato Hexadecimal. El primer
registro de una memoria corresponde a la dirección 00H.
9
Dado que identificar a cada registro mediante un número hexadecimal puede resultar muy
complejo a la hora de diseñar el programa, existe la posibilidad de asignar un “nombre” a una
dirección de registro. En general, este nombre está directamente relacionado con la función que
cada registro cumple dentro del sistema.
Los registros no solo son utilizados por el programador (usuario) para almacenar los datos que la
aplicación debe procesar, sino que, además, sirven para controlar todo el funcionamiento del
microcontrolador en su conjunto. Esta función, la cumple un conjunto de registros que ya vienen
“Predefinidos” desde la fábrica. Es decir, que el fabricante asigna las funciones de configuración y
control del microcontrolador en un grupo de registros y el usuario no puede modificar la función
que cumple cada uno de éstos.
Cada Registro está dividido en 8 “partes” a los cuales se los denomina “Bits”. Entonces podemos
decir que un Registro está formado por un conjunto de 8 bits.
El Bit es la menor unidad de información que un sistema digital puede procesar y solo puede
contener los valores lógicos 0 y 1.
La palabra BIT proviene de la contracción de las palabras “Binary Digit”
Los sistemas digitales representan la información en forma de bits porque sus circuitos sólo
pueden tener 2 estados: encendido o apagado. En general podemos decir que:
1 = Encendido = Verdadero = “SI” = +5V
0 = Apagado = Falso = “NO” = 0V
Cada Bit se identifica por la posición que ocupa dentro del registro, siendo el primer Bit el número
0, que es el que se encuentra en el extremo derecho del registro.
Al igual que los registros, se puede asignar un nombre a cada Bit para facilitar su identificación. En
un registro se puede almacenar una combinación 8 ceros y unos. Esto nos da una cantidad de 2^8
combinaciones, es decir, 256 posibles combinaciones de ceros y unos. Esto significa que un
registro puede procesar valores entre 0 y 255.
Esta característica de procesar números (“Dígitos”) es lo que da el nombre a la “Electrónica

Digital”. La electrónica digital procesa números formados por combinaciones de ceros y unos.
Cualquier señal analógica debe ser “digitalizada”, es decir, convertida a números, para poder ser
procesada en un sistema digital.
10
Podemos decir que el conjunto de ceros y unos almacenados en un registro se trata de un número
entre 0 y 255, expresado en sistema Binario, esto es, en base 2. Para interpretar dicho número
debemos realizar el cálculo de conversión de base para poder expresarlo en sistema decimal.
El siguiente ejemplo muestra el desarrollo de un cálculo de conversión de base de sistema binario

(base 2) a sistema decimal (base 10):
Se llama “Peso Binario” al valor que representa un Bit según la posición que ocupa dentro del
registro. El Bit que está ubicado más hacia la derecha del registro, es el Bit menos significativo
(LSB, Least Significant Bit) y tiene un peso de 2^0=1. El Bit del extremo izquierdo del registro es el
Bit más significativo (MSB, Most Significant Bit) y tiene un peso de 2^7=128. Los pesos binarios
crecen de derecha a izquierda en potencias de 2.
Una manera de simplificar el cálculo de conversión de binario a decimal, es, directamente sumar
los valores de los pesos binarios de los bits cuyo valor sea 1.
11
El sistema hexadecimal es un sistema en base 16 y consta de 16 dígitos diferentes que son: del 0 al
9 y luego de la letra “A” a la “F”, es decir, 10 dígitos numéricos y seis caracteres alfabéticos.
El sistema hexadecimal se usa como forma simplificada de representación de números binarios y

debido a que 16 es una potencia de 2 (2^4=16), resulta muy sencilla la conversión de los números
del sistema binario al hexadecimal y viceversa.
Mediante el sistema hexadecimal podemos representar un valor numérico de 8 bits utilizando sólo
2 dígitos. De ésta manera estamos dividiendo el registro de 8 bits en 2 partes de 4 bits cada una
llamada Nibble. Al nibble correspondiente a los 4 bits menos significativos, se lo denomina “Nibble
Bajo” y al nibble correspondiente a los 4 bits más significativos se lo denomina “Nibble Alto”.
El sistema hexadecimal es utilizado para identificar las direcciones de registros de las memorias en
sistemas digitales porque permite representar el valor de un Nibble con sólo 1 digito, ya que:
12
NIPLE - PROGRAMACIÓN
RAMACIÓN VISUAL DE MICROCONTROLADORES PIC
Esto permite representar números grandes utilizando unos pocos dígitos. Por ejemplo:
En la programación de microcontroladores, es habitual utilizar los 3 sistemas de numeración

(Binario, Decimal y Hexadecimal) dependiendo del proceso que necesitemos realizar. Por eso es
fundamental tener claros estos conceptos.
Líneas de entrada y salida

alida (E/S) – Puertos
Los microcontroladores cuentan con una una serie de pines destinados a entrada y salida de datos o
señales digitales. A estos pines se les denomina “Puerto”.
Como mencionamos anteriormente, todo el funcionamiento del microcontrolador está controlado

a través de los registros. Los puertos no son la excepción, también están controlados por los
registros. Por esto, un puerto no puede estar formado por más de 8 pines; 1 Pin por cada Bit de un
registro. Un puerto si puede estar formado por menos de 8 pines.
Un microcontrolador puede contener varios p

puertos
uertos dependiendo del modelo.
A cada puerto se lo identifica con una letra. Por ejemplo; “Puerto A”, “Puerto B”, etc.
13
Para poder utilizar un puerto, primero el mismo debe ser configurado. Cada pin de un puerto
puede ser configurado como entrada o salida independientemente del resto de los pines del
mismo puerto.
Temporizadores internos (TMRs)
Un temporizador interno (TMR) es un módulo de hardware incluido en el mismo microcontrolador

el cual está especialmente diseñado para incrementar automáticamente el valor de un registro
asociado al TMR cada vez que el módulo TMR recibe un pulso. A este pulso se lo llama “señal de
reloj”.
El módulo TMR siempre incrementa el valor del registro asociado, nunca decrementa dicho valor
Algunos microcontroladores pueden incluir más de un módulo TMR y la señal de reloj de cada uno
de éstos puede ser de origen interno o externo.
Si el origen de la señal de reloj está configurado como externo, el módulo temporizador puede ser
utilizado como un contador de eventos externos, incrementando el TMR con cada pulso recibido
mediante el pin correspondiente.
Si el origen de la señal de reloj es interno, el TMR incrementa con cada ciclo del oscilador. Esto
permite utilizar el temporizador como “contador de ciclos de programa”, donde, un ciclo
corresponde al tiempo de ejecución de una instrucción, lo cual se puede calcular con la siguiente
fórmula:
1
ó / 4
Donde “Frecuencia de Oscilación” es la frecuencia del oscilador utilizado.
Dado que la velocidad de ejecución del microcontrolador corresponde a ¼ de la velocidad del

cristal utilizado, cada ciclo de programa se ejecuta en un tiempo determinado según el cristal que
estemos utilizando.
Por ejemplo; con un cristal de 4Mhz la velocidad real de procesamiento del microcontrolador es
de 1 Mhz. Aplicando la siguiente fórmula:
1
4.000.000/4
1
1.000.000
0,000001 = 1 ( )
14
Esto significa que cada ciclo de programa se ejecuta a 1/1.000.000 (1 uS) y dado que cada
incremento del TMR corresponde a un ciclo de programa, si contamos los incrementos de un TMR,
indirectamente podremos calcular el tiempo transcurrido.
El incremento del TMR se realiza de manera automática y de forma paralela a la ejecución del
resto del programa. Esto significa que el programa no debe “controlar” el incremento del TMR, lo
cual sí debe realizarse en las temporizaciones por bucles, en las cuales el microcontrolador se
queda “esperando” a que transcurra un tiempo, y no pueden ejecutarse otras tareas mientras no
finalice la temporización.
Entonces el TMR puede ser utilizado como temporizador mientras el microcontrolador ejecuta
otros procesos. Por ejemplo: si diseñamos un programa que encienda y apague un led cada 1
segundo, el microcontrolador enciende el led y luego puede ocuparse de esperar a que
transcurran los ciclos correspondientes a 1 segundo, luego apaga el led y continua esperando.
Pero si el microcontrolador debe realizar alguna otra tarea además de temporizar, por ejemplo,
mostrar valores en dígitos de 7 segmentos, el micro no puede quedarse temporizando por bucles
ya que mientras se encuentre temporizando no podrá realizar el proceso de muestreo de los datos
en los displays, y como resultado tendremos que los displays se apagan mientras el
microcontrolador se encuentra temporizando.
En este caso, se utiliza un TMR para realizar la temporización mientras el microcontrolador se

ocupa de mostrar los datos en los displays.
En general los microcontroladores cuentan con una interrupción por desbordamiento del TRM, es
decir que, el microcontrolador se interrumpe cuando el TMR0 pasa de 255 (B’11111111’) a 0
(B’00000000’) en los temporizadores de 8 bits y cuando pasa de 65535 (B’11111111_111111’) a 0
(B’00000000_00000000’) en los temporizadores de 16 bits.
Dado que 256 uS es un tiempo relativamente corto (para un TMR de 8 bits a 4 Mhz.), existe la
posibilidad de preescalar el TMR0 para que el registro asociado al TMR se incremente cada 2, 4,
8,o más ciclos. De esta manera, estamos multiplicando la cantidad de ciclos que deben ejecutarse
para realizar un incremento del TMR. Al prescalador también se lo denomina predivisor.
Por ejemplo, con un predivisor de 8, cada incremento del TMR se realiza cada 8 ciclos de programa
y el desbordamiento del TMR se realizara cada 2048 ciclos (255 incrementos * 8 ciclos).
Así podemos realizar interrupciones con periodos de tiempo mayores.
15
Utilizando un microcontrolador
Como mencionamos anteriormente, el microcontrolador tiene una memoria de programa, donde

grabamos las instrucciones necesarias para que el micro realice el trabajo que necesitamos.
Cuando compramos un microcontrolador, la memoria de programa viene vacía. Para que un
microcontrolador funcione es necesario “programarlo”.
Los microcontroladores se programan en un lenguaje de programación llamado Ensamblador (en

inglés Assembler) cuya principal característica es su altísima complejidad.
Los lenguajes de programación se clasifican según el “Nivel” de programación en:
• Lenguaje de “Alto Nivel”: permite que los algoritmos se expresen en un nivel y estilo de
escritura fácilmente legible y comprensible por el hombre. En la actualidad se trata de
lenguajes de tipo visual.
• Lenguaje de “Bajo Nivel”: el usuario se acerca un poco más al lenguaje de máquina.

Permiten un acceso más amplio al control físico de la maquina (hardware).
• Lenguaje Ensamblador: Podríamos considerarlo el lenguaje de más bajo nivel. El usuario

escribe código en el mismo “idioma” del procesador. Se tiene control total del sistema. Es
necesario un conocimiento de la arquitectura mecánica del procesador para realizar una
programación efectiva. El lenguaje de programación es muy especifico para cada modelo
de procesador, incluso puede variar de un modelo a otro de procesador dentro de un
mismo fabricante.
Podemos decir que los lenguajes de alto Nivel se asemejan más al lenguaje humano y que los
lenguajes de bajo Nivel se asemejan más al lenguaje de máquina y en el lenguaje ensamblador el
usuario debe programar en el propio “idioma del procesador”.
16
El microcontrolador sólo entiende de números, es decir que, el código Assembler (texto) no puede
ser procesado directamente por el microcontrolador. Para poder grabar el programa en el micro,
primero debemos convertir el texto del código Assembler a números, en general, en formato
hexadecimal. A este proceso se le llama “Compilación”.
Una vez desarrollado el código Assembler, el mismo debe ser “compilado”. Esto se realiza con un
“software compilador” el cual se puede obtener de manera gratuita desde la página Web del
fabricante del microcontrolador.
El archivo compilado tiene una extensión .hex.
Por último, después de compilado, el programa está listo para ser grabado al microcontrolador.
Esto realiza mediante una “placa programadora”. A ésta placa programadora, comúnmente se la
llama “programador”. Existen distintos tipos de programadores los cuales pueden ser para
conectar a la PC mediante el puerto Serie (COM) o Paralelo (LPT).
Cada programador trabaja en conjunto con un software, mediante el cual se realiza el proceso de
lectura y escritura de los microcontroladores.
A continuación se presenta un resumen del proceso de desarrollo del código y grabación de un

microcontrolador:
1. Escribir el código Assembler. Se genera un archivo con extensión ASM.

2. Compilar el código Assembler. Se genera un archivo con extensión HEX.
3. Grabar (transferir) el programa desde la PC al microcontrolador mediante un
programador.
17
De estos 3 pasos, el primero insume el 98 % de tiempo y esfuerzo y es aquí donde Niple le ofrece
sus ventajas.
Niple: Programación Visual de microcontroladores PIC
Como mencionamos en los párrafos anteriores, la programación de los microcontroladores resulta

una tarea muy compleja dado que el usuario debe conocer la arquitectura del procesador y
además debe dominar el lenguaje de programación “Ensamblador”. Si bien existen distintas
versiones del lenguaje C o Basic adaptadas a la programación de microcontroladores, todavía la
programación resulta muy compleja por el alto grado de abstracción que implica.
Niple es un entorno de desarrollo visual para programación de microcontroladores PIC. Con Niple,
el usuario sólo diseña un diagrama de flujo de manera totalmente visual y en alto nivel de
programación, en lenguaje humano, y el software genera el código Assembler de manera
automática.
Además, el software controla y supervisa todo el proceso de diseño, advirtiendo al usuario sobre
posibles errores en la lógica del programa que se está diseñando. Esta ventaja no la tiene ningún
otro lenguaje de programación.
De ésta manera Niple ofrece la posibilidad de realizar desarrollos con microcontroladores con un
mínimo de esfuerzo.
18
El principal objetivo de Niple es facilitar al máximo la programación de los microcontroladores.

Para esto, el software ofrece un entorno totalmente visual, donde todo el sistema se adapta a las
características del modelo de microcontrolador seleccionado; es decir que; carga el mapa de
memoria con sus respectivos nombres de registros y bits, asigna las funciones correspondientes a
cada Registro y Bit dentro del sistema, ajusta el tamaño de la memoria EEPROM, activa los
módulos correspondientes, etc. Es decir que, Ud. tendrá disponible sólo las características que
corresponden al modelo de micro en uso.
El concepto de la programación es que el usuario se concentre en “qué es lo que quiere hacer”, y

Niple “sabe cómo hacerlo”. Es decir que el usuario sólo se dedica a diseñar la estructura lógica del
proceso que desea realizar y el software se encarga de resolver todo el desarrollo del código
assembler, controlando hasta el más mínimo detalle.
19
INTRODUCCIÓN A NIPLE
Entorno Visual de desarrollo para programación de microcontroladores

PIC
Con Niple podrá programar los PIC a través del diseño de un diagrama de flujo de manera gráfica y
de alto nivel de programación, sin necesidad de escribir código Assembler, o escribiendo la menor
cantidad de código, convirtiéndose en la forma más rápida, sencilla y productiva de desarrollar
proyectos con microcontroladores PIC.
La metodología de programación cons

consiste
iste en diseñar un diagrama de flujo de manera gráfica y en
“lenguaje humano” mientras Niple realiza el trabajo pesado por Ud., controlando errores lógicos o
de configuración, realizando cálculos, coordinando la interacción entre las distintas partes del
proyecto
royecto y generando de manera automática el código Assembler.
Estas características, hacen de Niple la herramienta ideal tanto para quienes se inician en el
mundo de los microcontroladores como para aquellos usuarios más experimentados que quieran
aumentar su productividad.
Entre las principales prestaciones que Niple ofrece podemos destacar:
Entono Visual de Alto Nivel de programación:
• Niple ofrece una metodología de programación totalmente visual y en lenguaje humano.

• Bloques estandarizados, lo cual facilita
facilita la interpretación del proyecto.
• Usted se concentra en “Que Hacer“ y Niple se encarga de “Como Hacerlo”.
• Control automático de errores lógicos.
• Supervisa el ingreso de datos.
Control automático de registros y bits:
• Controla la existencia de todos los registros

registros y bits necesarios para el correcto
funcionamiento del proyecto en el momento de generar el código Assembler.
20
• Controla que no existan nombres de registros y bits duplicados.

• Valida los nombres de los registros y los bits en el momento de ser declarados.
Corrección automática de errores lógicos:
• Controla la correcta configuración de los puertos.

• Controla la configuración y activación de las interrupciones.
• Supervisa la creación de vínculos entre bloques.
Generación del Código Assembler:
• Control automático de la sintaxis del código generado.

• Control automático del cambio de página.
• Generación automática de etiquetas.
Funciones disponible
Las funciones disponibles dependen del modelo de microcontrolador utilizado pero en general
podemos mencionar:
• Selección del cristal utilizado

• Asignación de valores a registros y bits
• Configuración y manejo de interrupciones
• Manejo de rutinas de usuario
• Configuración, Lectura y Escritura de puertos
• Lectura / Escritura de EEPROM interna del PIC
• Lectura / Escritura de EEPROM/RAM/FRAM Externa por I2C
• Lectura / Escritura de EEPROM Paralela
• Funciones de comparación de registros y bits (condiciones =, >, <, >=, <=, <>)
• Manejo automático de tablas
• Temporizadores por bucle (de tiempo fijo o variable)
• Ingreso de datos por teclado matricial (3×3 y 3×4)
• Visualización de datos en dígitos 7 segmentos (Ánodo común y Cátodo común)
• Matriz de LED
• Visualización de datos en pantallas LCD (16×2, 20×2 y 20×4)
• Visualización de datos en pantallas GLCD (128×64)
• Manejo de memorias EEPROM 24Cxxx por comunicación I2C
• Manejo de reloj/calendario de tiempo real PCF8583 y ds1307, con control de alarmas por
fecha.
21
• Configuración y manejo de temporizadores internos (TMRs disponibles en el

microcontrolador elegido)
• Configuración de interrupciones por: (Puertos, Tmrs, A/D, USART, CCP, EEPROM)
• Comunicaciones RS232 por código y por USART
• Comunicaciones RS485 por código y por USART
• Comunicaciones USB
• Comunicaciones RF
• Comunicaciones Zigbee (modulo Xbee – Xbee PRO)
• Comunicaciones IR
• Comparadores analógicos
• Modulo RFID
• Conversión A/D a 8 y 10 Bits.
• Módulos CCP (Compara, Captura y PWM)
• Cálculos matemáticos: (+, – , / , *, en 8 ,16 ,24 y 32 bits), conversión a BCD
• Escalado de valores de un rango a otro (a 8 y 16 bits)
• Vector de memoria
• Encoder Incremental
• Control de potencia AC
• Motores Paso a Paso
• Servo Motores
• Impresora térmica
• Teclado A/D
• Teclado Matricial
• Teclado AT
• Sensores: temperatura, humedad, etc.
• Conversor Digital Analógico DS1803
• Manejo de registros de desplazamiento
22
Herramientas adicionales
Interfaz de comunicación RS232. Comunicaciones a 8 o 16 bits con visualización en distintos

formatos (decimal, hexadecimal, binario, texto, o modo gráfico).
23
Interfaz de comunicación USB. Con visualización en distintos formatos (decimal, hexadecimal,

binario, texto), esta herramienta también dispone de elección sobre el tipo de dato a enviar al
microcontrolador, entre los tipos de datos a enviar están:
• Datos ASCII
• Datos Decimal
• Datos Hexadecimal
• Datos Binarios
• Interfaz USB
24
METODOLOGÍA DE PROGRAMACIÓN CON NIPLE
Conceptos básicos
La metodología de programación en Niple consiste en el diseño de un diagrama de flujo de manera

totalmente visual y de alto nivel de programación.
Esto significa que Usted no escribe código Assembler adaptándose al “lenguaje” del micro, sino
que, por el contrario, realiza el diseño del programa de manera gráfica, seleccionando opciones a
través de pantallas claras e intuitivas, y donde el sistema se adapta al lenguaje humano y luego
traduce a código Assembler.
El diagrama de flujo está formado por un conjunto de bloques estandarizados. Tanto la forma,
como el color y el texto de cada bloque, le están presentando información y datos concretos
acerca de cada parte del proceso, lo cual facilita aún más la interpretación del programa. Además,
el diagrama de flujo le permite tener una visión general del proyecto.
El proceso de diseño del diagrama de flujo consiste en insertar bloques y vincularlos por medio de
flechas. Durante éste proceso, Niple controla y advierte de posibles errores, tanto de la lógica del
programa como en la configuración del sistema (configuración de puertos, interrupciones, etc.).
En el margen derecho de la pantalla se encuentra el “Árbol de Herramientas”. Este consiste en una

estructura de árbol donde se encuentran todas las funciones que pueden ser insertadas como
bloques en el diagrama de flujo y que generan un código Assembler. Los bloques se encuentran
agrupados en distintos niveles organizados por categoría para facilitar la búsqueda de un bloque
en particular.
En el primer nivel se organizan por tipo de función donde se encuentran los siguientes ítems:
Instrucciones
Esta categoría incluye todas instrucciones en Assembler. A su vez se organizan por tipo de
instrucción:
• Instrucciones orientadas a Registros

• Instrucciones orientadas a Bits
• Instrucciones orientadas a Literales
• Instrucciones orientadas a Control
25
El objetivo de Niple es utilizar lo menos posible los bloques de instrucciones ya que éstos bloques
equivalen a programar en código Assembler.
Etiquetas
En el segundo nivel se organizan las etiquetas del proyecto, es decir, permite la creación o el salto
de etiquetas dentro del diagrama de flujo.
26
Luego se encuentran las rutinas básicas, que son módulos prediseñados y se encargan de resolver
un proceso en particular (una configuración, una comparación, un cálculo, etc.). Puede formar
estructuras lógicas muy complejas de manera rápida y sencilla a partir de la combinación de
rutinas básicas. Utilice las rutinas básicas para programar dentro de cualquier “Entorno”.
Las rutinas básicas están organizadas en categorías como se muestra en la imagen a continuación:
Interrupciones
En ésta categoría se encuentran todas las funciones de configuración y manejo de las

interrupciones. Niple presenta las interrupciones disponibles de acuerdo al modelo de PIC que se
está utilizando.
27
Subrutinas de usuario
Puede diseñar sus propias funciones o procedimientos para solucionar un problema en particular
(siempre combinando distintas rutinas básicas) y luego llamarlos desde distintas partes del
programa (subrutinas). Esto le permite por un lado, la creación de funciones o procedimientos
personalizados y por otro lado, la optimización del código Assembler generado, ya que las rutinas
28
de usuario sólo se escriben una vez y luego se insertan “llamadas” a las mismas. Esta categoría
incluye las funciones de declaración e inserción de llamadas a rutinas de usuario.
La interfaz de Niple
Elementos de la pantalla:
Secciones de trabajo
Niple dispone de dos secciones de trabajo:
• Sección de dispositivos: se encuentran los dispositivos externos que serán utilizados en el

proyecto.
• Sección de diagrama de flujo: se encuentran los diagramas de flujo que conforman el
proyecto actual.
Para conmutar entre las secciones de dispositivos y diagramas de flujo utilice el botón ubicado en
la barra de herramientas que se encuentra en la parte superior derecha de la pantalla:
29
Al ingresar a la sección Dispositivos puede declarar los dispositivos externos que serán utilizados
en el proyecto.
Los dispositivos a declarar esta organizados por categorías. El tipo de dispositivo que desea
declarar seleccionando en la lista de categorías de nuevo dispositivo:
Al selecciona el tipo de dispositivo a declarar se muestran los diferentes componentes disponibles

según el modelo de microcontrolador utilizado.
Cada dispositivo es identificado con un nombre (“ID”, por Identificación). Cada dispositivo debe
tener un nombre único que lo identifique dentro del proyecto, es decir que no puede haber más
de un dispositivo con el mismo ID.
Por defecto Niple proporciona el ID de manera automática, y en algunos dispositivos es posible

cambiar el ID para identificar más fácilmente cada dispositivo dentro del diagrama de flujo.
Una categoría de dispositivos puede estar formado por varios componentes. En este caso se
muestra una lista de los componentes disponibles en la parte inferior de la pantalla.
Al seleccionar el componente deseado se muestra la pantalla de configuración y opciones

correspondiente.
En la siguiente imagen se muestra un dispositivo de tipo “Memoria”, las opciones disponibles en la

parte inferior, la pantalla de configuración al seleccionar un dispositivo y el ID asignado por
defecto.
30
Una vez seleccionadas las características del dispositivo y la conexión de lo pines al PIC se termina
el proceso de declaración de dispositivo por medio del botón “Ingresar”. Este botón estará
disponible solo cuando todas las opciones de configuración del dispositivo hayan sido
seleccionadas.
En la parte inferior de la pantalla se muestra la lista de dispositivos declarados en el proyecto

actual. Al seleccionar un dispositivo se muestran todas las características y opciones de
configuración. Los dispositivos de muestran por su ID.
En la siguiente imagen se muestran dos dispositivos de tipo Memoria identificadas como

“I2C_EEPROM_01” y “I2C_EEPROM_02”:
31
A continuación se muestra como se utiliza el ID para acceder a cada una de las memorias dentro
del diagrama de flujo:
32
Entornos
En la sección diagrama de flujo Usted programa los procesos o estructuras lógicas que desea
realizar en el proyecto. Un proyecto esta dividió en diferentes partes. A cada una es tas partes se
las llama “Entorno”.
En general, un programa para PIC es organizado en distintas secciones con el fin de facilitar la
compresión y al mismo tiempo optimizar el código por medio de la reutilización de rutinas y
procesos.
El objetivo de cada una de éstas secciones es resolver un problema en particular y reciben

distintos nombres según la función que cumplen, o el contexto en el cual se ejecutan (Programa
Principal, Subrutinas o Interrupciones).
En Niple, se llama “Entorno” a cada una de estas secciones que conforman un programa.
Cada entorno debe estar perfectamente delimitado por un bloque de “Inicio” y otro de “Fin”, con
la excepción del entorno del “Programa Principal”. Este contiene un bloque de inicio pero no tiene
un bloque de final, sino que, se realiza un bucle para ejecutar otro “ciclo” del programa.
Cada proyecto de Niple puede contener varios entornos:
• Entorno del “Programa Principal”: este entorno se crea de manera automática y es el

encargado de coordinar la ejecución de todo el programa (incluyendo el resto de los
entornos). En un proyecto sólo puede haber sólo un entorno llamado “Programa Principal”
y no puede ser borrado.
• Entornos de Subrutinas (rutinas de usuario): Son funciones o procedimientos generados

por el usuario. Debe asignarles un nombre único dentro del proyecto. No tiene un límite
máximo en la cantidad de entornos de subrutina que puede incluir en un proyecto. Las
subrutinas pueden devolver o no un resultado (funciones y procedimientos
respectivamente). Para ejecutar una subrutina debe ser llamada o invocada.
• Entornos de Interrupciones: Son funciones o procedimientos que se ejecutan al

producirse un llamado a interrupción. Cada interrupción tiene un nombre predeterminado
y el usuario no puede cambiar éste nombre. La cantidad máxima de “Interrupción”
corresponde al número de interrupciones de incluye cada modelo de microcontrolador. En
tiempo de ejecución, se accede al entorno de una interrupción de manera automática, al
generarse un llamado a interrupción. O sea que no se puede predecir el momento exacto
en que se producirá una interrupción. Esto afecta al sistema de chequeo de errores.
33
Crear un nuevo entorno
Un entorno se genera de manera automática al insertar interrupciones o rutinas de usuario en el

proyecto. Cuando inserta una interrupción en el proyecto, Niple coloca de manera automática el
bloque de inicio de entorno con el texto correspondiente.
Cuando declara una Rutina de Usuario, Niple genera un nuevo entorno con el nombre que usted
asignó a la rutina y le coloca el prefijo “usr_” (abreviación de la palabra usuario). Inserta de
manera automática el bloque de “Inicio de Entorno”.
Seleccionar el entorno actual de trabajo
Para conmutar entre los distintos entornos, sólo seleccione el nombre del entorno en la pestaña
“Rutinas”.
En la esquina superior izquierda del área de trabajo se muestra el nombre del entorno actual junto
a dos flechas para moverse por los entornos.
Borrar un entorno
Para borrar un entorno, seleccione el nombre del entorno a borrar y presione la tecla “Suprimir”.
34
Bloques
Un bloque es un símbolo que representa un proceso. Cada bloque presenta información según su
forma, su color y el texto que contiene, e identifican una función en particular.
Interpretación de los bloques:
Cada forma de bloque está directamente asociada a un tipo de función, esto le facilita la
interpretación del programa con sólo echarle un vistazo general. Tipo de función según la forma
del bloque:
Inicio – Fin. Se utiliza

Activar – Desactivar
como inicio o fin de un
interrupciones.
entorno.
Instrucción.
Cualquiera de las 35
Cálculo matemático.
instrucciones en
código Assembler.
Conversión “Decimal
Configuración de un
a BCD” o “BCD a
puerto.
Decimal”.
Ingreso de datos. Leer

el valor de un puerto
(en paralelo), modo Consultar tabla.
Captura, modo
Comparación.
Salida de datos. Comunicaciones
Escribir un valor en un seriales RS232. Envío
puerto (en paralelo, y recepción de un dato
no serial). por RS232.
Comunicaciones
seriales RS232. Envío
Asignación. Este
y recepción de un
bloque representa la
conjunto de datos por
asignación de un valor
RS232 mediante
a un registro o un bit.
protocolo de usuario
diseñado en Niple.
35
Temporización por
bucle. Calcula y
Leer un dato de la genera los bucles
memoria EEPROM. necesarios para
esperar un tiempo
determinado.
Visualizar valores en
display de 7
Almacenar un dato en
segmentos por el
la memoria EEPROM.
método del
multiplexado.
Condición. Evalúa una
condición y deriva la Registro de
ejecución del desplazamiento.
programa en función Ingresar un valor y
del resultado de la rotar.
evaluación.
Configuración. Este
bloque corresponde a
Llamada a subrutina
configuración de
(call).
Interrupción y
módulos periféricos.
Selección de bloques o vínculos
Al seleccionar un bloque se presentan una serie de 9 nodos (8 alrededor y 1 en el centro del

bloque). En el caso de los vínculos se presenta 1 nodo en la mitad de la flecha. Puede seleccionar
uno o más bloques o vínculos de varias maneras:
• Haciendo un clic sobre el bloque o sobre el vínculo.

• Manteniendo presionada la tecla “ALT” o la tecla “CRTL” puede ir incorporando más
bloques o vínculos a la selección actual.
Puede seleccionar varios bloques y vínculos de la siguiente manera:
1. Marque un punto en el área de trabajo (no sobre un bloque)

2. Presione el botón izquierdo del mouse y arrastre sin soltar el botón, se mostrará un
rectángulo en línea de trazos.
3. Al soltar el botón del mouse, se seleccionarán todos los bloques y vínculos que son
incluidos en el área seleccionada.
36
Mover un bloque
Seleccione el bloque que desea desplazar y sin soltar el botón izquierdo del mouse y arrastre hasta
ubicar el bloque en la nueva posición. Puede mover varios bloques simultáneamente.
Note que todos los bloques que dependen del bloque seleccionado se mueven en conjunto de
manera rígida. Esto se debe a que el modo “Arrastrar bloques” se encuentra activado. Si conmuta
a modo “Arrastrar bloques” desactivado sólo se desplaza el bloque seleccionado.
Para conmutar entre el modo “Arrastrar bloques” Activado y Desactivado ingrese al menú
“Opciones/Diagramas de Flujo/Activar Arrastre”.
A) Posición original.
B) Modo “Arrastrar bloques” activado.
C) Modo “Arrastrar bloques” desactivado
Utilice el comando “Edición/Deshacer” para restablecer la posición anterior del bloque.
37
Estirar un bloque
Al seleccionar un bloque se muestran 9 nodos (8 alrededor y 1 en el centro del símbolo

seleccionado). Para modificar el tamaño del bloque, haga un clic en uno de los 8 nodos periféricos
y, sin soltar el botón izquierdo del mouse, arrastre hasta alcanzar el tamaño deseado.
A) Tamaño del bloque original
B) Bloque estirado
Utilice el comando “Edición/Deshacer” para restablecer el tamaño anterior del bloque.
Borrar bloques
Tiene 2 formas de eliminar un o varios bloques:
1. Seleccione el bloque que desea eliminar y presione la tecla “Suprimir”.

2. Seleccione el bloque que desea eliminar y presione el botón derecho del mouse. Se
desplegara un menú contextual y presione la opción “Borrar Símbolo” (o la opción
“Borrar” si ha seleccionado varios bloques o vínculos).
Utilice el comando “Edición/Deshacer” para recuperar los bloques borrados.
38
Editar bloques
Muchas veces es necesario cambiar el valor de algún parámetro u opción a un bloque ya insertado
dentro del diagrama de flujo. Para esto tiene 2 opciones:
1. Puede borrar el bloque e insertarlo nuevamente seleccionado los parámetros deseados. Si

elige ésta opción deberá realizar los vínculos de manera manual.
2. Puede editar el bloque y asignarle nuevos valores a los parámetros solicitados. Para esto
no necesita borrar el bloque ni realizar los vínculos nuevamente.
Para editar un bloque, selecciónelo y luego haga un clic con el botón derecho del mouse para que
se presente el menú contextual, y elija la opción “Editar”, o bien realice doble clic sobre el símbolo
a editar y automáticamente entrara al menú de edición del símbolo.
Para que el menú contextual presente la opción “Editar”, sólo debe estar seleccionado el bloque a
ser editado. Si selecciona más de 1 elemento, ya sean bloques o vínculos, el menú no presentará la
opción “Editar” ya que el sistema no puede determinar cual es el bloque que desea editar.
Se presentará la pantalla correspondiente al el bloque seleccionado. La pantalla será cargada con

todos los parámetros seleccionados. Proceda a cambiar los valores o las opciones y presione el
botón “Ingresar”.
Con respecto al chequeo de errores, es importante tener en cuenta que rige el mismo criterio que
para la inserción de bloques. O sea que, si el bloque a editar está vinculado a otro bloque, se
realizará el chequeo de errores “en línea”. Mientras que si el bloque no se encuentra vinculado, el
chequeo no se realizará.
Duplicar bloques
Al duplicar un bloque se realiza una copia exacta del bloque seleccionado.
Muchas veces, la opción “Duplicar” un bloque en combinación con la “Edición” de bloques puede
ayudarle a ahorrar tiempo de diseño, ya que es común realizar operaciones similares en distintas
partes de proyecto, donde sólo cambian algunos parámetros.
Usted puede realizar una copia de la “estructura lógica” del programa y luego editar los bloques
necesarios. Esto le resultara más cómodo que insertar todos los bloques nuevamente.
Para duplicar un bloque, selecciónelo y luego haga un clic con el botón derecho del mouse para
que se presente el menú contextual, y elija la opción “Duplicar”.
39
Además, puede duplicar uno o más bloques a la vez:
Habilitar e inhabilitar bloques
Durante la fase de diseño del proyecto, es habitual que durante las pruebas, Usted necesite anular
una parte del proceso par que no sea ejecutada. Por medio de las opciones “Habilitar Bloque” e
“Inhabilitar Bloque” puede anular la ejecución uno o más bloques sin necesidad de borrarlos o de
alterar la lógica del programa.
40
Para inhabilitar un bloque, selecciónelo y luego haga un clic con el botón derecho del mouse para
que se presente el menú contextual, y elija la opción “Inhabilitar”.
Un bloque deshabilitado no es considerado en el momento del chequeo de errores “en línea” y

tampoco genera el código Assembler.
No puede inhabilitar bloque correspondiente a una “Decisión” (símbolo “Rombo”) dado que estos
bloques tienen 2 salidas.
Para habilitar un bloque, selecciónelo y luego haga un clic con el botón derecho del mouse para
que se presente el menú contextual, y elija la opción “Habilitar”.
Vínculos entre bloques (Flechas)
Un vínculo está representado por una flecha que une a dos o más bloques y determina el flujo del
proceso.
41
Los vínculos determinan la secuencia y el orden de ejecución del programa. Esto significa en que
es muy importante tener en cuenta el sentido en que se genera el vínculo (bloques de origen y de
destino).
El bloque desde donde parte el vínculo de denomina “Bloque de origen” y el bloque al cual llega
“Bloque de destino” y puede identificarlos visualmente porque el vínculo presenta una “Punta de
flecha” en extremo correspondiente al bloque de destino.
La secuencia de ejecución del programa es; primero se ejecuta el “Bloque de origen” y a

continuación el “Bloque de destino”. Existe un criterio a tener en cuenta a la hora de realizar
vínculos entre bloques y Niple lo supervisa de manera automática:
• Cada bloque debe tener solo un vínculo de salida. A excepción de los bloques de decisión
(rombo) que necesariamente deben tener dos salidas (si la condición se cumple y si la
condición no se cumple).
• Los bloques “Inicio de entorno” (elipses amarillas) no pueden utilizarse como “Bloques de
destino”. Es decir que no pueden tener flechas que ingresen a estos bloques.
• Los bloques “Fin de entorno” (elipses amarillas) no pueden utilizarse como “Bloques de
origen”. Es decir que no pueden tener flechas que salgan desde estos bloques.
Antes de codificar un programa a código Assembler, Niple supervisa que todos los bloques se
encuentren correctamente vinculados. En el caso de existir un error de vínculos, Niple lo informa y
suspende la codificación del Assembler.
42
Crear un vínculo
Para crear un vínculo entre 2 bloques siga los siguientes pasos:
1. Seleccione el “Bloque de origen”.

2. Haga un clic en el nodo (punto negro) que se encuentra en el centro del bloque.
3. Sin soltar el botón del mouse, arrastre hasta el “Bloque de destino” y luego suelte el botón
del mouse.
Un vínculo puede adoptar distintas formas de acuerdo a la disposición de los bloques de origen y
destino. A éstas formas se les llama “Estilo” del vínculo.
Cambiar el estilo de un vínculo
Para cambiar el estilo de un vínculo:
1. Seleccione el vínculo y presione el botón derecho del mouse.

2. Se mostrará un menú contextual con los distintos estilos que puede adoptar un vínculo.
3. Seleccione el estilo deseado.
43
Borrar vínculos
Para eliminar un vínculo:
1. Seleccione el vínculo y presione el botón derecho del mouse.

2. Se mostrará un menú contextual.
3. Seleccione la opción “Borrar Flecha”.
También puede borrar un vínculo seleccionándolo y presionando la tecla “Suprimir”.
Ingreso de datos
Niple controla de manera automática cada dato ingresado al sistema, ya sean nombres de registro,
valores literales u opciones (generalmente numéricas). De esta manera se controlan los errores de
tipeo.
44
Control de ingreso de nombres de registros
Cuando necesite ingresar el nombre de un registro como parámetro para una función, Niple le
presenta una lista con todos los registros declarados, donde Usted debe seleccionar el nombre del
registro deseado.
Esto garantiza que el registro a utilizar ha sido previamente declarado

declarado y demás previene los
posibles errores de tipeo por parte del usuario al ingresar el nombre del registro.
Si necesita seleccionar como parámetro, el nombre de un registro predefinido y no aparece en lista,

consulte el tema “Conceptos Básicos / Nivel de Usuario”.
En general, junto a la lista de registros, Niple presenta el botón “Nuevo”. Este botón le carga la
pantalla de declaración de registros.
De ésta manera, si necesita ingresar como parámetro el nombre de un registro que aún no ha sido
declarado,, tiene la posibilidad de declararlo y seleccionarlo sin necesidad de cancelar la pantalla
actual.
Al cargar la pantalla “Declaración de Registros” puede declarar más de un registro nuevo antes de
volver a la función actual.
45
Control de ingreso de valores literales
Niple le ofrece distintos formatos de ingreso de valores literales, éstos son; formato decimal,
hexadecimal o binario.
En general, cuando necesite ingresar un literal, primero debe seleccionar el formato en el cual
desea ingresar el valor. De ésta manera, Niple supervisa de manera automática el ingreso de
datos, y admite sólo los valores permitidos para el formato seleccionado. Si ingresa un valor no
permitido, Niple lo muestra de color rojo y no permite continuar con el proceso actual hasta no
corregir el valor ingresado.
Cuando ingresa un número en formato binario, Niple lo acepta como válido sólo cuando se han
ingresado los 8 dígitos que conforman el número. Esto garantiza la correcta interpretación del
valor ingresado.
Modos de trabajo: Nivel de Usuario
Dado que Niple está especialmente diseñado para quienes se inician en la programación de
microcontroladores PIC, el sistema ofrece dos modos de trabajo según el nivel de experiencia o
conocimiento técnico del usuario:
• Modo de Usuario Inicial: Sólo se permite el acceso y visualización de los registros y bits
declarados por el usuario, y no se tiene acceso a los registros predefinidos. Los únicos bits
predefinidos a los que se tiene acceso son los correspondientes a los puertos, y los bits C y
Z, dado que estos son de uso frecuente. De esta manera, Niple pretende evitar errores al
modificar registros de configuración y control del sistema (ya sea por desconocimiento o
de manera accidental).
• Modo de Usuario Experto: Se permite el acceso a todos los registros y bits del sistema sin
ninguna restricción. Niple supone que el usuario tiene pleno conocimiento de las acciones
que se está realizando, y no advierte sobre de los riesgos de modificar el valor de los
registros de configuración o control.
Por defecto Niple inicia la sesión de trabajo en modo “Usuario Inicial”.
Para conmutar entre modo de “Usuario Inicial” y “Experto” ingrese al menú “Opciones/Nivel de
Usuario”.
46
Rutinas de usuario
Usted puede diseñar sus propias funciones o procedimientos para solucionar un problema en
particular (siempre combinando distintas rutinas básicas) y luego llamarlos desde distintas partes
del programa (subrutinas).
Esto le permite por un lado, la creación de funciones o procedimientos personalizados y por otro
lado, la optimización del código Assembler generado, ya que las rutinas de usuario sólo se escriben
una vez y luego se insertan “llamadas” a las mismas. Esta categoría incluye las funciones de
declaración e inserción de llamadas a rutinas de usuario.
Exportar una rutina de usuario
Una vez creada una rutina de usuario, Niple le ofrece la posibilidad de guardarla en un archivo con
extensión .RUT, para luego poder ser utilizada en otros proyectos. De esta manera puede crear
una librería de rutinas de usuario. Se genera un archivo para cada rutina.
Para exportar una rutina de usuario realice los siguientes pasos:
1. Seleccione el entorno de la rutina de desea.

2. Seleccione el bloque de inicio del entorno (el bloque con forma de elipse de color
amarillo). Presione el botón derecho del mouse para mostrar el menú contextual y
seleccione la opción “Exportar Rutina”.
3. Niple solicita el nombre del archivo donde guardar la rutina de usuario. Por defecto,
sugiere el nombre de la rutina de usuario.
47
48
Importar una rutina de usuario
Para importar una rutina de usuario que se encuentra guardada en un archivo, ingrese al menú
“Archivo/Rutina de Usuario” y seleccione el archivo de rutina (*.RUT). Niple ingresará la rutina al
proyecto actual.
Si el modelo de microcontrolador con el cual fue creada la rutina no es el mismo que el modelo
actualmente utilizado, Niple muestra un mensaje de advertencia, ya que, al generar el código
Assembler, pueden ocurrir errores si la rutina utiliza algún módulo que no existe en el modelo de
PIC actualmente utilizado.
Por ejemplo, si la rutina fue generada con una versión de Niple para PIC16F87x y realiza una
lectura de un canal A/D y luego la importa a un proyecto de Niple para PIC16F6xx, Niple advierte
del posible error.
Exportar imagen
Puede generar un archivo de imagen del diagrama de flujo para realizar la documentación del
proyecto. La imagen es generada en formato .WMF y corresponde un archivo de tipo vectorial.
Este formato es estándar de Microsoft Windows, o sea que, no requiere de programas especiales
para poder visualizarlos o editarlos y ocupa muy poco espacio de disco.
El archivo de imagen puede ser insertado en un editor de textos para complementar la

documentación técnica.
Al ingresar al menú “Archivo/Exportar Imagen”, tiene dos opciones para generar imágenes:
1. Generar una imagen de todo el proyecto: se generan un archivo de imagen por cada
entorno.
2. Generar una imagen solo del entorno actual: se genera un archivo con el entorno actual.
Los archivos de imagen se nombran según el siguiente formato:
“NombreProyecto_NombreEntorno.WMF”
Por esto, Niple solicita el nombre del proyecto y sugiere el nombre actual del proyecto.
Si Usted aún no ha ingresado un nombre al proyecto, Niple sugiere “NombreProyecto”. En el caso

de generar archivos de imagen de todo el proyecto, Niple genera un archivo para cada entorno.
Por ejemplo, en el siguiente proyecto serán generados los archivos:
49
• Ejemplo7_Programa Principal.wmf
• Ejemplo7_Interrupción por TMR0.wmf
• Ejemplo7_usr_rutina_rtc.wmf
• Ejemplo7_usr_sensor_temperatura.wmf
• Ejemplo7_usr_eeprom.wmf
Donde cada archivo contiene la imagen del entorno correspondiente.
Programando con Niple
Crear un nuevo proyecto
Para crear un proyecto nuevo en Niple seleccione la opción “Nuevo Proyecto” del menú “Archivo”:
50
Se carga la ventana de creación de nuevo proyecto. Seleccione el modelo de microcontrolador

utilizar mediante el “Asistente de selección”:
51
Seleccione la ubicación donde será guardado el proyecto, al igual que los comentarios sobre el
mismo.
Por último, presione el botón “OK” y se abre el nuevo proyecto.
52
Declaración de registros
Para declarar un registro ingrese al menú “Declaración” y seleccione la opción “Registros”:
Se muestra la pantalla de “Memoria” del microcontrolador:
Al hacerr clic en una posición de memoria libre (en nuestro caso 01h) se carga la ventada de
“Declaración de nuevo registro”:
53
Seleccione el tipo de registro el cual puede ser:
• 8, 16, 24, ó 32 bits.
• BCD 8 bits: genera 3 bytes con el mismo nombre ingresado agregando los sufijos “_uni”,
“_dec”, y “_cen” para poder guardar valores en BCD de registros de 8 bits (entre 0 y 255).
“_dec”, “_cen”, y “_u_mil” para poder guardar valores en BCD de registros de 10 bits
(entre 0 y 1024).
“_dec”, “_cen”, “_u_mil” y “_d_mil” para poder guardar valores een
n BCD de registros de 16
bits.
• Fecha: genera 2 bytes con el mismo nombre ingresado agregando los sufijos “_d”, “_m”
para poder guardar valores de fechas.
54
• Hora: genera 3 bytes con el mismo nombre ingresado agregando los sufijos “_h”, “_m” y
“_s” para poder guardar valores de horas.
• Serie: permite declarar de manera automática una serie de registros con un prefijo
incremental determinado por un intervalo.
Ingrese el nombre del nuevo registro y el valor inicial.
La opción “Crear BCD” genera de manera automática los registros correspondientes a la

conversión BCD.
Borrar un registro
Seleccione el registro a borrar y presione la tecla “Suprimir”. Sólo puede borrar los registros de
usuario.
Dado que puede declarar bits dentro de un registro de usuario, Niple chequea si el registro de
usuario que se intenta borrar contiene bits declarados. Si detecta que el registro a borrar contiene
bits declarados, Niple le advierte que junto con el registro serán borrados todos los bits éste
contenga y le pregunta si desea continuar con la operación de borrado del registro. Tiene la
posibilidad de cancelar la operación de borrado respondiendo NO a la pregunta. Y si responde
afirmativamente se borrará el registro junto con la totalidad de los bits asociados.
Declaración de bits
Ingrese al menú “Declaración” y seleccione la opción “Bits”.
55
Una vez dentro de la declaración de bits se muestra de manera gráfica la posición y los nombres
de los bits declarados, coloreando los bits del microcontrolador, los bits inhabilitados y las
posiciones libres de creación para bits.
Borrar un bit de usuario
Seleccione el BIT a borrar y presione la tecla “Suprimir”. Sólo puede borrar los BIT de usuario.
Cambiar el nombre a un bit de usuario
Niple brinda la posibilidad de renombrar un BIT o de modificar la descripción del mismo. Para esto
seleccione el BIT que desea renombrar y presione la tecla “Enter”.
56
Niple preguntara si desea cambiar el nombre del BIT actualmente seleccionado. Si responde
afirmativamente se muestra la pantalla “Renombrar un Bit” donde se presentan el nombre y la
descripción del BIT actualmente seleccionado. Ingrese el nuevo nombre del bit y la nueva
descripción y a continuación presione el botón “Renombrar”.
Al cambiar el nombre de un Bit, todos los bloques de los diagramas de flujo que hacen referencia a
al Bit anteriormente renombrado quedan desactualizados, o sea, hacen referencia a un BIT que ya
no existe. Para solucionar esto, Niple le brinda la posibilidad de actualizar de manera automática
todos los bloques que hacen referencia al BIT renombrado.
57
Niple le pregunta si desea que actualice de manera automática los diagramas de flujo con el nuevo
nombre de Bit. Si responde afirmativamente Niple actualiza todos los bloques de todo el proyecto
de manera automática.
Además de renombrar los bits de usuario, Niple le ofrece la posibilidad de cambiar el nombre de
los bits correspondientes a los puertos. De ésta manera puede identificar más fácilmente los pines
del microcontrolador indicando directamente el nuevo nombre asignado. Por ejemplo: puede
renombrar el bit RA0 por Rele1 y a partir de entonces sólo se refiere al mismo como Rele1.
Insertar bloques
Tenga en cuenta que cada bloque debe estar unido a otro bloque por medio de un vínculo (flecha).
Esta flecha indica el sentido de ejecución del programa. De ésta manera se establece la secuencia
y el orden en que va a ser ejecutado el programa.
El vínculo lo puede realizar de forma manual o de forma automática. Para que el vínculo se realice
de forma automática debe seleccionar el bloque previo antes de insertar el nuevo bloque. Niple
supervisa de manera automática los errores lógicos solo cuando los vínculos se realizan de manera
automática, o sea, cuando se inserta un nuevo bloque habiendo seleccionado previamente el
bloque precedente.
Cuando el vínculo se realiza de manera manual, no se realiza el chequeo automático de errores. En

este caso, Niple lo advierte a través del siguiente mensaje.
58
Si elige la opción “NO” se cancela la operación de inserción de bloque. Si elige la opción “SI”, Niple
le permitirá insertar un bloque, pero no se realizará el chequeo de errores en línea dado que no es
posible determinar el contexto en el cual será insertado el nuevo bloque. Además, el nuevo bloque
será insertado en la esquina superior derecha del diagrama de flujo y el vínculo deberá realizarlo
manualmente.
Para insertar un bloque siga los siguientes pasos:
1. Seleccione el bloque al cual vincular el nuevo bloque a ser insertado (para generar el
vínculo de manera automática y chequear errores).
2. Haga doble clic para desplegar el “Árbol de herramientas” y localice la función de que
necesite, desplegando y recorriendo el árbol de herramientas.
59
3. Una vez localizada la función que quiere insertar, haga doble clic en el nombre de la
misma para cargar la pantalla con las opciones y parámetros de la función. Una vez
seleccionadas las opciones e ingresados los parámetros, presione el botón “Ingresar”.
60
De ésta manera se insertará el bloque y será vinculado de manera automática.
61
Descripción de las funciones
Los bloques se encuentran agrupados en distintos niveles organizados por categoría para facilitar
la búsqueda de un bloque en particular. En el primer nivel se organizan por tipo de función donde
se encuentran los siguientes ítems:
1. Instrucciones
2. Etiquetas
3. Rutinas básicas
4. Interrupciones
5. Subrutinas de usuario
Instrucciones
Esta categoría incluye todas instrucciones en Assembler. A su vez se organizan por tipo de
instrucción:
El objetivo de Niple es utilizar lo menos posible los bloques de instrucciones ya que éstos bloques
equivalen a programar en código Assembler.
Instrucciones orientadas a registros
Instrucción: Instrucción a ejecutar.
Registro: Nombre del registro a procesar.
62
Destino: Indica en donde será guardado el resultado de la operación.
Instrucciones orientadas a bits
Bit: Indica el nombre del bit a modificar.
Instrucciones orientadas a literales
63
Literal: Indica el valor literal a procesar.
Instrucciones orientadas a control
Algunas de las instrucciones orientadas a control son las siguientes:
Repetir: Se refiere al número de NOP que serán insertados en el código ASM.
Rutinas básicas
Las rutinas básicas son módulos prediseñados y se encargan de resolver un proceso en particular
(una configuración, una comparación, un cálculo, etc.).
Puede formar estructuras lógicas muy complejas de manera rápida y sencilla a partir de la
combinación de rutinas básicas. Utilice las rutinas básicas para programar dentro de cualquier
“Entorno”.
Las rutinas básicas están organizadas por tipo de rutina:
• Iniciar Programa: inserta el bloque de inicio del diagrama de flujo.

• Puertos: configurar, lectura y escritura de puertos.
• Asignar Valor: establecer valores a registros y bits.
• Modulo CCP: configurar el módulo e implementar módulos CCP.
• Comparadores Analógicos: implementar comparadores analógicos.
64
• EEPROM: leer y escribir la EEPROM interna del micro.

• Condición: evaluar el valor de un registro o bit.
• Matemáticas: cálculos matemáticos de 8, 16, 24 y 32 bits, conversiones a BCD y cálculos
de escalado de valores.
• Comunicaciones: RS232, RS485, USB, ZIGBEE, RF, IR, DMX512, SIM908, SIM800L, SIM808,
MODBUS, NRF24L01.
• Consultar Tablas: consultar valores por medio de tablas.
• Temporizadores: Temporizadores por ciclos y por módulos TMR internos.
• Dispositivos: En esta pestaña se encuentran la totalidad de dispositivos externos

declarados en la sección “Dispositivos”.
• Procesos: generación y medición de pulsos, cálculo de velocidad, RPM.
• Vector de memoria: seleccionar y utilizar vectores de memoria RAM.
65
Iniciar programa
Este bloque corresponde al inicio del programa en Assembler, debe estar presente en el entorno
del “Programa Principal” y debe ser ingresado obligatoriamente. Por esto Niple lo inserta de
manera automática.
Al bloque de “Iniciar” no puede ingresa

ingresarr ningún vínculo. Solo acepta un vínculo de salida.
Asignar valor a un Bit
Esta función permite asignarle un valor a un bit. Dado que un bit representa un valor binario, sólo
se le puede asignar un valor de “0” ó “1”. Es posible asignarle el valor de o
otro
tro bit también.
En el campo “Bit” se selecciona el nombre del bit al cual se asignará el valor.
66
Una vez seleccionado el bit, se muestra una lista de valores de asignación: 0, 1 y “Otro bit”.
Seleccione el valor deseado. Por último, puede ingresar un comentario
comentario adicionando a la función.
Asignar valor a un registro
Esta función permite asignarle un valor constante o variable a un registro de 8, 16, 24 y 32 bits de
tamaño. En el campo “Registro” seleccione el registro al cual le asignará un valor, en la sintaxis
corresponde al “Destino”.
Si desea asignarle un valor a un registro que aún no ha sido declarado, mediante el botón
“Registros” puede declarar el registro sin necesidad de cancelar la operación actual.
Una vez especificado el registro al cual as

asignar
ignar el valor, debe seleccionar que tipo de valor desea
asignar. Las opciones disponibles son:
• Un valor literal. Esto es, un valor constante. Niple controla de manera automática el
ingreso de literales, para obtener mayor información consulte el tema “Co
“Conceptos básicos
/ Ingreso de datos”.
67
• El valor de otro registro. Esta opción es equivalente a copiar el contenido de otro registro.
Si en tiempo de ejecución se modifica el contenido del registro, estamos frente a una
asignación de tipo variable.
Al igual que
ue con el campo registro, el botón “Registros”, le permite declarar un nuevo registro sin
necesidad de cancelar la operación.
Configurar puerto
En Niple, la configuración de los puertos se realiza de manera totalmente visual.
En la pantalla de “Configuración
ción del Puerto”, se presenta una imagen del PIC con las descripciones
de todos los pines. En cada pin correspondiente se muestra una lista desplegable, a través de la
cual el pin es configurado como entrada, entrada analógica, comparador o salida, las
características
acterísticas de cada pin corresponde al modelo de PIC utilizado.
68
Leer puerto
Permite obtener el valor actual de un puerto y guardar el resultado en un registro. Es significa que,
se obtiene el estado de cada pin correspondiente al puerto seleccionado.
En el campo “Puerto” seleccione el puerto que desea leer. Niple supervisa la configuración del
puerto seleccionado de manera automática y advierte si el puerto no está completamente como
entrada.
Si bien el hecho de leer el estado de un pin configurado como salida no es considerado un error,
igualmente Niple le advierte para asegurarse que tiene pleno conocimiento de la actual
configuración
Escribir puerto
Permite escribir un valor en un puerto. Este valor puede ser un valor literal (constante) o el valor
de un registro (variable).
Seleccione el tipo de dato desea escribir en el puerto.
69
Niple supervisa la configuración del puerto seleccionado de manera automática y advierte si el

puerto no está completamente como salida.
Si bien el hecho de escribir un pin configurado como entrada no es considerado un error,

igualmente Niple le advierte para asegurarse que tiene pleno conocimiento de la actual
configuración. Una vez ingresado los datos solicitados presione el botón “Ingresar”.
Conversión Analógica/Digital
igital
Configuración de los canales A/D
Cuando el microcontrolador utilizado dispone de conversores analógico/digital puede

configurarlos desde la configuración del puerto.
70
Seleccione el valor de “VRef” (voltaje de referencia) la cual puede ser interna (VDD y VSS) o
externa por medio de determinados pines según el modelo de microcontrolador a utilizar.
Si elige algún voltaje de referencia externo, el pin correspondiente es inhabilitado en la pantalla

para que no pueda ser utilizado como entrada o como salida. Una vez seleccionada la
configuración deseada, presione el botón “Ingresar”.
Antes de insertar el bloque, Niple chequea que la configuración seleccionada corresponda a una
de las combinaciones válidas, ya que en algunos modelo de de microcontrolador debe utilizar las
entradas AD con determinada configuración.
Conversión A/D
Una vez configurado el módulo A/D, está en condiciones de realizar una conversión A/D. Ingrese al
árbol de herramientas y seleccione la opción “Rutinas Básicas / Conversión A/D”:
Se presenta la pantalla “Conversión Analógica / Digital”. En esta pantalla se muestra toda la

información relacionada con el estado actual del módulo de conversión A/D. Esto es:
• Configuración actual del puerto

• Cantidad de canales A/D disponibles
71
Seleccione
leccione el canal A/D que desea utilizar. La lista desplegable llamada “Canal a leer” contiene
todos los canales A/D que se encuentra disponibles. En esta lista se muestra el número de canal
junto al correspondiente nombre de bit. De esta manera, Niple le facilita la identificación del pin
adecuado.
Para eliminar completamente la posibilidad de seleccionar un pin del puerto que no hubiera sido
configurado como “Entrada A/D”, Niple muestra en la lista, sólo los canales que actualmente están
disponibles de acuerdo
uerdo a la configuración actual del puerto.
A continuación seleccione los registros donde guardar el resultado de la conversión A/D. Puede
realizar conversiones A/D a 8 ó 10 bits de resolución.
Niple le permite realizar varias lecturas y promediarlas con lo cual se obtienen mediciones más
estables.
Para esto, active la opción “Promedio”. Seleccione la cantidad de mediciones que desea realizar.
Niple realiza todas las lecturas y realiza el promedio de manera automática. Niple le da la opción
de esperar un tiempo entre las mediciones seleccionadas.
72
Condición
Las funciones lógicas permiten realizar evaluaciones (comparaciones) de registros y bits con
valores literales (constantes) o con los valores contenidos en otros registros y bits (variables).
Comparar bit
Este bloque evalúa si el valor del bit seleccionado es 0 ó 1 y deriva el flujo del proceso en función
del resultado de la evaluación.
En el campo “Bit”, seleccione el nombre bit del que desea comparar el valor y a continuación
seleccione el valor con
on el cual comparar el bit. Un bit solo puede contener los valores 0 y 1. Por
último, puede ingresar un comentario al bloque. Una vez seleccionados todos los datos, presione
el botón “Ingresar”.
73
Este bloque debe ser vinculado a dos bloques de salida:
• El primer bloque de salida insertado corresponde a la salida “SI”, es decir que, en tiempo
de ejecución el proceso tomará este camino si el resultado de la evaluación es verdadero.
• El segundo bloque de salida insertado corresponde a la salida “NO”, es decir que, en

tiempo de ejecución, el proceso tomara este camino si el resultado de la evaluación es
falso.
74
Comparar registro
Evalúa el valor de un registro, utilizando como valor de comparación un literal o el valor de otro
registro.
En la lista “Registro”, seleccione el registro que desea comparar. A continuación seleccione el

operador de comparación.
Un registro puede ser comparado con un valor literal (constante) o con el valor de otro registro
(variable). Seleccione el tipo de valor de comparación marcando en la casilla de opción
correspondiente.
Si selecciona la opción “Registro”, seleccione de la lista el registro que contiene el valor de

comparación, de lo contrario, ingrese el valor literal de comparación.
Por último puede ingresar un comentario al bloque. Un a vez ingresados todos los datos
solicitados, presiones el botón “Ingresar”.
75
Los operadores de comparación posibles pueden ser =, <, >, <=, >= ó <>.
Cada vez que debe seleccionar el nombre de un registro y ha olvidado declararlo previamente,
Niple
ple le ofrece la posibilidad de declararlo sin necesidad de cancelar la pantalla actual. Para esto
presione el botón “Registros” que se encuentra a la derecha de la lista de registros
correspondiente.
Este bloque debe ser vinculado a dos bloques de salida:
• El primer bloque de salida insertado corresponde a la salida “SI”, es decir que, en tiempo
de ejecución el proceso tomará este camino si el resultado de la evaluación es verdadero.
• El segundo bloque de salida insertado corresponde a la salida “NO”, es decir

de que, en
tiempo de ejecución, el proceso tomara este camino si el resultado de la evaluación es
falso.
76
Cálculos matemáticos
Puede realizar cálculos de suma, resta, multiplicación y división a 8, 16, 24 y 32 bits (o

combinaciones). La metodología es la misma para los diferentes tamaños de registro.
Suma
Realiza una operación matemática de suma, utilizando como sumandos un valor literal o un
registro. El resultado es guardado en otro registro. En “Sumando 1” seleccione entre las opciones
un literal o el valor de un registro.
Si seleccionó la opción el valor de un registro, seleccione de la lista el registro a utilizar como

primer sumando. Repita la operación anterior en “Sumando 2”. En Resultado, seleccione el
registro donde desea guardar el resultado de la operación.
77
Resta
Realiza una operación matemática de sustracción, utilizando como minuendo y sustraendo un

valor literal o un registro. El resultado es guardado en otro registro.
En “Minuendo” seleccione entre las opciones un literal o el val valor

or de un registro. Si seleccionó la
opción el valor de un registro, seleccione de la lista el registro a utilizar como minuendo. Repita la
operación anterior en “Sustraendo”. En “Resultado”, seleccione el registro donde guardar el
resultado de la sustracción.
ón. Haga clic en “OK”.
78
Multiplicación
Realiza una operación matemática de multiplicación con registros o valores, utilizando como
multiplicador valores de un literal o un registro. El resultado es guardado en un registro.
En “Multiplicando” seleccione entre las opciones un literal o el valor de un registro. Si seleccionó la

opción el valor de un registro, seleccione de la lista el registro a utilizar como multiplicando. Repita
la operación anterior en “Multiplicador”. En “Resultado”, seleccione el registro
regis donde guardar el
resultado de la multiplicación.
79
División
Realiza una operación matemática de división, utilizando como divisor valores de un literal o un
registro. El resultado es guardado en otro registro.
En “Dividendo” seleccione entre las opci

opciones
ones un literal o el valor de un registro. Si seleccionó la
opción el valor de un registro, seleccione de la lista el registro a utilizar como dividendo. Repita la
operación anterior en “Divisor”. En “Resultado”, seleccione el registro donde guardar el res resultado
de la división.
80
Incrementar uno
Puede realizar incrementos de registros de manera automática. Niple incrementa el valor del
registro y controla el acarreo en caso de tratarse de registros mayores a 8 bits.
81
Esta opción se trata de un cálculo muy rápido y además ofrece diferentes opciones para control de
contadores totalmente automatizado.
La opción “Controlar valor máximo” le permite automatizar la cuenta hasta un máximo ingresado
por el usuario. Una vez alcanzado el valor máximo, ya no sigue incrementando el valor de la
cuenta.
La opción “Reiniciar cuenta” le permite volver a inicializar el estado de la cuenta a un valor

ingresado por el usuario una vez que se alcanzo el máximo permitido.
Laa opción “Activar Bit al llegar la máximo” inserta un bloque de comparación donde se evalúa un
bit seleccionado por el usuario el cual se pone en “1” cuando la cuenta llego a la máximo. De esta
manera se puede controla el flujo del programa según el contador haya llegado al límite máximo o
no.
Estas opciones, trabajando en conjunto le permiten realizar estructuras lógicas muy complejas en
pocos pasos.
82
Decrementar uno
Puede realzar decrementos de registros de manera automática. Niple decrementa el valor del
registro y controla el acarreo en caso de tratarse de
de registros mayores a 8 bits.
Si el valor es igual a “0”, la operación no se realiza.
Es posible insertar un bloque de condición para evaluar esta situación de manera automática.
83
En caso afirmativo:
Dec a BCD
Realiza el cálculo de conversión de un número a BCD, es decir, descomponer el valor contenido en

un registro a unidad, decena y centena.
Seleccione el registro que contiene el valor a descomponer. Seleccione los registros donde desea
almacenar el resultado de la descomposición a U, D y C.
84
En caso de no encontrar registros BCD, Niple puede crearlos de manera automática:
Convertir valor BCD a registro
La operación inversa a la anterior. Convierte varios registros BCD en un registro de 16 bits.
85
Escalado proporcional
La función “Escalar” permite, a partir de un valor dentro de un rango “origen”, calcular el valor
proporcional correspondiente a un rango “destino”.
Por ejemplo: Los registros “dato1” y “dato2” contienen el resultado de una conversión A/D, es
decir, un valor a 10 bitss entre 0 y 1023. Ahora suponga que desea controlar el ancho de pulso del
PWM a 5000 Hz. El ancho de pulso es controlado por medio de un valor a 10 bits contenido en los
registros “AnchoPulso1” y “AnchoPulso2”. A 5000 Hz el rango válido para el control del ancho de
pulso esta comprendido entre 0 y 200.
Partiendo de esto, necesita escalar el valor contenido en los registros “dato1” y “dato2” de un
rango de 0…1023, a un rango 0…200 y asignarlo a los registros “AnchoPulso1” y “AnchoPulso2”.
De esta manera se obtiene

btiene un valor proporcional, es decir, el mismo porcentaje o relación entre el
rango de destino con respecto al rango de origen.
86
Tablas
Una tabla consiste en una metodología de programación a través de la cual se pueden realizar
consultas obteniendo un valor de resultado en función de un valor de entrada (índice).
Por ejemplo: la siguiente tabla devuelve el código ASCII correspondiente al valor ingresado como
índice.
Índice Valor Resultado

0 D’48’
1 D’49’
2 D’50’
3 D’51’
4 D’52’
5 D’53’
6 D’54’
7 D’55’
87
8 D’56’
9 D’57’
El procedimiento consiste en sumar al registro contador de programa (registro PCL) el valor

correspondiente al índice, esto produce que la ejecución del programa salte la cantidad de
posiciones correspondiente al valor del índice. Para que la tabla devuelva un valor para cada ítem,
la tabla debe estar formada por instrucciones “RETLW” (retorno de subrutina con un valor en W) y
debe ser llamada mediante una instrucción “CALL”.
En el siguiente ejemplo en código Assembler se describe el principio de funcionamiento de una

consulta por tabla:
Crear una nueva tabla
Niple incluye un generador de tablas en el cual Usted declara la tabla y luego la graba como un
archivo con extensión TBL. De esta manera puede crear su propia librería de tablas.
Para crear una tabla ingrese al menú Declaración / Generador de tablas / Tabla estándar. Niple le
muestra la pantalla de “Declaración de tablas” y solicita que ingrese el nombre de la tabla. Cada
tabla debe tener su correspondiente nombre.
Una vez ingresado el nombre debe proceder a ingresar los valores de los distintos elementos que
componen la tabla. Los valores de los índices se incrementan de manera automática ya que no
debe saltearse ninguno de ellos. Para ingresar nuevos elementos a la tabla presione el botón
“Agregar un valor”.
88
Si detecta de ha cometido un error al ingresar alguno de los valores de la tabla, puede editarlo
haciendo doble clic sobre el elemento a corregir.
Una vez ingresados todos lo valores que conforman la tabla presione el botón “Ingresar”. Al
presionar dicho botón Niple guarda la tabla actual en un archivo con extensión .TBL. A
continuación le solicita que ingrese el nombre del archivo de tabla.
89
De esta manera podrá utilizar la tabla recién creada en distintos proyectos

proyectos sin necesidad de volver
a declararla cada vez que la necesite.
Consultar tabla
Carga una tabla, la cual debe haber sido previamente definida.
Haga clic en “Cargar Tabla”. Seleccione el archivo de tabla que desea consultar, haga clic en
“Abrir”. Aparecerá
cerá una pantalla con el detalle de los datos de la tabla.
90
En “Índice (Puntero)” seleccione el registro que contiene el valor del puntero de la tabla. En
“Resultado”, elija el registro en donde desea guardar el dato devuelto por la tabla. Haga clic en
“Ingresar”.
Tiempos por bucles
Niple le permite realizar temporizaciones tanto “fijas” o “variables”. Con la temporización fija
puede genera temporizaciones entre 10 microsegundos y 255 segundos con una precisión de 1 uS.
En tiempo de espera, escriba el valor

valor de tiempo que desea. Seleccione la unidad de tiempo que
desee de la lista. Haga clic en “Ingresar”.
91
Memoria EEPROM interna
Declaración de Registros EEPROM
Puede declarar registros en la memoria EEPROM del PIC para poder acceder a las diferentes
dicciones a través de un nombre de registro.
Se muestra la pantalla de declaración de registros EEPROM.
92
La metodología de declaración de registros es la misma que para la declaración de registros RAM.
Leer EEPROM
Lee un dato de la memoria EEPROM del microcontrolador y lo guarda en un registro. Seleccione

entre las opciones de dirección “Fija”, “Variable” y “+1”.
Si elige la opción Fija, seleccione de la lista el registro en donde está contenida la dirección. En la
lista “Registro donde guardar el dato
dato”, seleccione el registro destino.
93
Presione el botón “Ingresar”. Si el registro en el que desea guardar los datos no existe, haga clic en
“Nuevo”.
Grabar EEPROM
Graba un literal o un registro en la memoria EEPROM del microcontrolador.
En posición de memoria a escribir, seleccione entre las opciones de dirección “Fija”, “Variable” y
“+1”.
Si elige la opción variable, seleccione de la lista el registro en donde está contenida la dirección. En
“Valor a grabar”, seleccione entre las opciones un literal o un registro. Si selecciona la opción un
registro, seleccione de la lista el registro que desea guardar en la EEPROM.
Presione le botón “Ingresar”. Si el registro en el que desea guardar los datos no existe, haga clic en
“Nuevo”.
94
DECLARACIÓN DE DISPOSITIVOS
Display de siete segmentos sin codificador
Este módulo permite visualizar valores en displays de siete segmentos mediante conexión a 7 bits,
es decir, sin la utilización de un codificador para generar la combinación binaria correspondiente a
cada valor. Niple le permite utilizar hasta 16 displays conectados en paralelo.
Primero seleccione el tipo de display a utilizar, esto es: ánodo común o cátodo común.
Luego le solicita que seleccione la cantidad de displays a utilizar esto es, entre 2 y 16.
Una vez configurado los pines de datos, cantidad de dígitos y los pines de display, oprimimos el
botón Ingresar.
95
Display de 7 segmentos con codificador
Puede implementar la utilización de displays de 7 segmentos por medio de un codificador

CD4511B para displays cátodo común y el codificador 74LS47 para displays ánodo común.
De esta manera puede ahorrar tres pines en el microcontrolador para poder utilizarlos para otras
funciones. Seleccione el tipo de display a utilizar, los pines correspondientes al bus y luego
selecciona la cantidad de displays a utilizar y sus respectivos pines.
Una vez seleccionados todos los parámetros de configuración presione el botón Aceptar.
Implementación en el diagrama de flujo
Tanto para displays de 7 segmentos con o sin codificador la metodología de implementación en el

diagrama de flujo es la misma:
96
Ingrese al árbol de herramientas: Rutinas/Dispositivos/Visualización/Display de 7 segmentos.
Se muestra la pantalla de visualización en Displays de 7 segmentos.
97
En cada display se puede visualizar el valor de un registro o un valor literal. Para seleccionar el
valor a visualizar en cada dígito debe hacer un doble clic en cada imagen de display. Al hacer doble
clic en la imagen de un display se presenta la pantalla de “Mostrar un valor en un Display”.
En un display puede visualizar dos tipos de valores:
1. Puede visualizar el valor que contiene un registro: se trata de un valor que puede ser
variable. Al seleccionar este tipo de dato a visualizar, Niple le ofrece la posibilidad de
codificar el valor mediante una tabla. Si el dato a visualizar requiere codificación
mediante tabla, seleccione la tabla.
2. O puede visualizar un valor constante (un valor literal): en este caso se muestra
siempre el mismo valor. Al seleccionar la opción “un valor constante”, Niple presenta
una imagen del display en el cual debe hacer un clic en cada barra que quiere
visualizar iluminada. De esta forma puede generar el número o símbolo que desea
visualizar. Niple genera el código binario correspondiente de manera automática. Este
código binario varía si se trata de un display tipo Ánodo común o Cátodo común, Niple
controla el código generado según el tipo de Display.
98
Una vez seleccionados los datos a mostrar en los displays debe seleccionar le tipo de multiplexado
que desea realizar. Tiene dos opciones: “por Bucles” o “por Paso”.
La opción “por Bucles” hace que el microcontrolador se detenga en esta parte del programa y
realice todo el proceso de multiplexado completo mostrando los valores de cada displays y no
continua con la ejecución del resto del programa hasta que no haya terminado de realizar este
proceso.
Las opciones de este tipo de multiplexado son:
• Repeticiones: corresponde a la cantidad de veces que realiza el ciclo de visualización de

todos los Displays.
• Tiempo: tiempo en uS que demora cada Diplays encendido en el proceso de multiplexado.
El tipo de multiplexado “por Paso” muestra el valor correspondiente a uno de los displays (por
ejemplo el display 1) y continua con el resto del programa. Cuando vuelve a pasar por este en el
siguiente ciclo del programa activa el siguiente displays y continúa con la ejecución del resto del
programa.
99
Esta opción es ideal para realizar un multiplexado por medio de un temporizador interno (TMR)
donde cada vez que se produce la interrupción por TMR se ejecuta el bloque y va activando un
display en cada interrupción. Así puede realizar un multiplexado mientras realiza otros procesos
de manera simultánea.
Esta metodología de implementación del multiplexado “por paso” y por temporizando por medio
de una interrupción TMR es la opción recomendada para realizar visualizaciones de manera
profesional.
Opcionalmente Niple le permite “Ocultar” o “Encender” los dígitos con “0” a la izquierda.
Niple controla automáticamente cuando debe mostrar u ocultar un dígito en función del valor
total a mostrar.
Pantalla LCD
Niple le permite controlar más de una pantalla LCD de manera simultánea en el mismo proyecto.
Esto es se logra conectando las pantallas LCD en paralelo y los pines de control de cada pantalla se
asignas a distintos pines del microcontrolador. Niple administra las rutinas de control de manera
automática. Usted, solo indica que mensaje desea visualizar en cada una de las pantallas LCD.
Como siempre, en Niple, tanto las configuraciones de las pantallas LCD, las configuraciones y
diseños de los de los mensajes y los comandos se realiza de manera visual y en alto nivel de
programación. Niple genera todo el código Assembler necesario de manera automática.
100
Principales características:
• Configuración visual de mensajes

• Bus de datos a 4 y 8 bits configurable por el usuario
• Mensajes con valores variables
• Conversión automática de formato numérico a código ASCII para valores variables
• Edición y ajuste de mensajes y comandos de manera visual
• Envío de comandos al LCD:
o Apagar la pantalla
o Encender la pantalla
o Limpiar la pantalla
o Ubicación del cursor a inicio
o Ubicación del cursor
101
o Configuración del cursor

o Desplazamiento del cursor
o Desplazamiento de la pantalla
• Envío de caracteres al LCD de manera independiente de un mensaje (para ingreso de
datos)
• Código Assembler optimizado: cuando actualiza un mensaje en un LCD, si el mensaje
contiene valores variables, Niple solo actualiza las variables en lugar de volver a cargar
todo el mensaje nuevamente. De esta manera Niple le ahorra tiempo durante la ejecución
del programa.
Para utilizar un LCD debe realizar los siguientes pasos:
1. Configurar el Puerto donde conectar el LCD

2. Configurar el LCD
3. Generar el mensaje
4. Visualizar el mensaje
5. Opcionalmente se pueden enviar comandos o caracteres independientemente de un
mensaje
Configurar LCD
Una vez configurado el puerto donde conectar el LCD debe proceder a configurar el LCD de la
siguiente manera: seleccione el bloque al cual vincular el nuevo bloque de configuración de LCD,
luego ingrese a la pestaña dispositivos: “Nuevo dispositivo/LCD”.
En Niple, la configuración de un LCD consiste en seleccionar de qué manera será conectado el LCD
al microcontrolador. La configuración de un LCD se realiza sólo una vez. Dado que Niple puede
controlar más de una pantalla LCD de manera simultanea, en esta pantalla se presenta el número
de LCD que está siendo configurado.
102
Primero debe seleccionar el tipo de display LCD: 16×2, 20×2 o 20×4. Luego debe seleccionar el
tamaño del bus de datos, el cual puede ser de 4 u 8 bits.
Se recomienda utilizar el bus de datos de 4 bits dado que la diferencia con el bus de 8 bits es
insignificante tanto en el código generado como en el tiempo de ejecución del programa y, por el
contrario, los cuatro pines que se ahorra pueden ser de gran importancia.
Una vez seleccionado el tamaño del bus de datos, debe seleccionar los pines a los cuales conectar
el LCD. Si selecciona el bus de datos de 4 bits, Niple le ofrece la posibilidad de utilizar los cuatro
pines de mayor o menor peso de un mismo puerto. Esto simplifica el código Assembler generado.
Además, indica en la imagen del LCD los pines que deben ser conectados.
103
Si selecciona el bus de datos de 8 bits, Niple utiliza un puerto completo.
Si ha seleccionado el bus de datos de 4 bits, Niple le solicitará que seleccione los pines
correspondientes. Si ha seleccionado el bus de datos de 8 bits, Niple asignará al bus de datos,
todos los pines del puerto seleccionado. Por último debe seleccionar los pines del control del LCD.
Para esto haga un clic en la casilla de verificación correspondiente a cada pin de control (RS, RW,
E).
Una vez ingresados todos los datos solicitados, presione el botón “Ingresar”. Luego diríjase a la
sección diagrama y vaya al árbol de herramientas “Rutinas
básicas/Dispositivos/Visualización/Pantalla LCD”. La configuración de la pantalla LCD se realiza solo
una vez en un proyecto.
104
Utilizando más de una pantalla LCD
Niple le permite controlar más de una pantalla LCD. Para esto, los pines correspondientes al bus
de datos y los pines de control RS y RW de las pantallas a utilizar deben estar conectados en
paralelo.
Solo debe conectar de manera independiente los pines correspondientes al control “E” de las
pantallas.
El pin “E” de un LCD es el encargado de habilitar e inhabilitar una pantalla LCD. De esta manera
Niple habilita e inhabilita las distintas pantallas LCD de manera automática de acuerdo al
programa que Usted está desarrollando.
Si desea utilizar más de un LCD, el mismo debe ser creado y configurado desde la pestaña
“Dispositivos/LCD”. Recuerde de conectar el display LCD en paralelo con los demás LCD y sólo
deberá cambiar el pin correspondiente al control “E” para el nuevo LCD.
105
Seleccione el BIT correspondiente al pin de control E del LCD. Por último presione la el botón
“Ingresar”. Cuando termine de configurar la cantidad de dispositivos LCD que desee utilizar, debe
ingrese al diagrama principal y luego debe ir a el árbol de herramientas para inicializar las pantallas
LCD.
Al inicializar las pantallas se le crearan los siguientes iconos en el programa principal:
106
Generar un nuevo mensaje
La metodología de visualización de mensajes en Niple consiste en generar un mensaje. Esto

implica configurar la pantalla, el cursor y diseñar el mensaje propiamente dicho. Una vez diseñado
el mensaje, puede ser aplicado a cualquier LCD mediante el módulo de visualización de mensajes.
Para generar un nuevo mensaje ingrese al árbol de herramientas a la sección:
Insertar/Rutinas Básicas/Dispositivos/Visualización/Pantalla LCD/Nuevo Mensaje
En Niple cada mensaje es identificado con un nombre único. Por ejemplo “Bienvenida”. Al cargar
la pantalla de nuevo mensaje, lo primero que debe ingresar es el nombre del mensaje. Además
muestra el número de mensaje correspondiente. Una vez ingresado el nombre, Niple nuestra las
opciones de configuración de pantalla.
Por defecto la opción “Visualización de Caracteres” se presenta como “Caracteres Visibles”. Niple
supone que Usted quiere que el mensaje sea visible al momento de llamar al mensaje.
107
Si por algún motivo desea que el mensaje se cargue en el LCD pero que permanezca invisible para
luego mostrarlo con el comando “Encender Pantalla” (ver envío de comandos más adelante),
seleccione la opción “Caracteres Invisibles”.
Además la opción “Limpiar pantalla” se presenta como activada. Esta opción realiza una limpieza
de la pantalla antes de visualizar el mensaje. Esto significa que será borrado completamente
cualquier mensaje que haya sido visualizado antes de mostrar el actual mensaje. Si esta opción se
inhabilita, Niple no realiza la limpieza de la pantalla y existe la posibilidad de superposición de
mensajes.
Al inhabilitar la opción “Limpiar Pantalla” Niple advierte lo anteriormente mencionado mediante el

siguiente mensaje.
108
Dado que el objetivo de Niple es minimizar al máximo la posibilidad de error, ofrece esta opción
como habilitada para que realice la limpieza de la pantalla antes de visualizar el mensaje actual. La
limpieza de la pantalla incluye la ubicación del cursor al inicio del LCD, esto es, en la línea 1,
carácter 1. Por esto, si la opción “Limpiar Pantalla” se encuentra activada, entonces, la opción
“Ubicar el cursor en el Inicio” se encuentra inhabilitada dado que la limpieza de pantalla incluye
esta función.
Por esto, si la opción “Limpiar Pantalla” se desmarca, se activa la opción “Ubicar el cursor”.
A continuación debe seleccionar la configuración del cursor. Si seleccione la opción “Cursor

Invisible”. La opción “Visualización de parpadeo” se configura de manera automática como “Sin
parpadeo”. Seleccione la configuración del cursor el parpadeo y la ubicación del mismo.
Una vez seleccionadas todas las opciones de la configuración del mensaje, se activa la “Solapa
Mensaje”.
109
A continuación debe ingresar el mensaje propiamente dicho.
Se presenta una imagen de la pantalla LCD representada por una grilla de 2 filas y en la cual se
enumeran las columnas las cuales representan a los caracteres.
110
En la grilla ingrese el mensaje que desea visualizar:
Como lo indican las referencias, el texto del mensaje se muestra en color rojo. A la izquierda y a la
derecha de la grilla del mensaje se encuentran botones para desplazamiento del texto ingresado.
De esta manera puede ajustar la visualización del texto. En la siguiente imagen, el texto ha sido
desplazado hacia la derecha para ajustarlo al centro de la pantalla.
El botón “Limpiar Todo” le permite limpiar la grilla del texto cuando Ud. desea corregir el mensaje.
Visualizando valores variables en un mensaje
Para ingresar un valor variable en un mensaje haga doble clic en la celda donde desea visualizar la
variable. Se presentará la pantalla de selección de variables:
111
Esta pantalla le solicita que seleccione el registro donde tiene almacenado el valor variable a
visualizar. Si el valor variable corresponde a un número, antes de ser enviado al LCD debemos
convertirlo a su correspondiente código ASCII ya que el LCD solo puede mostrar caracteres ASCII.
Además si el número es mayor a nueve debemos enviar realizar la conversión a BCD y enviar los
valores correspondientes a las unidades, las decenas, las centenas, etc., por separado.
Niple le ofrece la posibilidad de convertir en número a código ASCII de manera automática. Para
esto debe seleccionar la opción “Convertir valor numérico a código ASCII”. La cual se encuentra
seleccionada de manera predeterminada.
Si lo que desea enviar no corresponde a un valor numérico sino a un código ASCII que Ud. ya tiene
definido en el programa, debe marcar la opción “No convertir valor numérico a código ASCII”.
Al ingresar la variable, la misma se presenta en la grilla de mensaje como un símbolo de

interrogación y de color celeste. Se muestra como un símbolo de interrogación dado que Niple no
puede “predecir” que valor será mostrado en la correspondiente variable.
Si desea consultar a qué valor corresponde a una variable. Haga un clic sobre la celda donde se
encuentra la variable y Niple le mostrará a que valor corresponde la misma como lo muestra la
imagen anterior.
112
El formato del texto puede ser uno de los 2 siguientes:
1. ? = ASCII(Nombre_Registro): Esto significa que la variable corresponde al carácter ASCII

del valor que contiene el registro “Nombre_Registro”.
2. ? = Nombre_Registro: Esto significa que la variable corresponde al valor que contiene un
registro sin convertirlo a código ASCII.
Por último presione el Botón “OK”.
Al insertar un nuevo Mensaje de LCD, Niple genera un nuevo entorno para el mensaje. De esta
manera el mensaje puede ser tratado como una rutina de usuario. Al insertarse el mensaje como
una rutina de usuario, el mismo puede ser llamado desde cualquier parte del programa y puede
ser visualizado en cualquier LCD en caso de estar utilizando más de un LCD.
Además, para minimizar al máximo las posibilidades de error de visualización, Niple incluye la
configuración de la pantalla junto con el mensaje a visualizar. De esta manera se garantiza que la
pantalla se va a encontrar configurada de acuerdo a las necesidades del mensaje a visualizar. De
esta manera no debe preocuparse por la configuración de la pantalla, o la configuración y
ubicación del cursor cada vez que desea visualizar el mensaje. Simplemente indica el mensaje
desea visualizar.
113
Mostrar Mensaje
Una vez definido el mensaje, puede visualizarlo en cualquier parte del programa ingresando al
árbol de herramientas a:
Rutinas Básicas/dispositivos/visualizacion/Pantalla LCD/Nuevo Mensaje
Se presentará la pantalla “Mostrar un mensaje en LCD”.
Primero debe seleccionar el LCD en el cual debe desea visualizar el mensaje y a continuación
indica el nombre del mensaje a visualizar. De esta manera un mismo mensaje puede ser
visualizado en cualquier LCD. Al presionar el botón “OK”, Niple ingresa el bloque del LCD.
114
Optimización del código Assembler
Niple incluye un algoritmo de optimización de para ahorrar recursos en tiempo de ejecución (del
PIC). Niple administra los mensajes que están siendo visualizados en cada LCD y sabe en todo
momento que mensaje se está visualizando en cada LCD. Incluso si un proyecto incluye solo un
LCD, Niple sabe qué menaje está siendo visualizando en el LCD.
Cuando desea visualizar un mensaje en un LCD que ya esta mostrando en dicho mensaje, Niple
solo actualiza los valores variables (en caso de que el mensaje incluye variables). Es decir que no
vuelve a cargar todo el mensaje en el LCD. De esta manera se ahorra tiempo de ejecución.
Lo mismo ocurre con la configuración de la pantalla y la configuración y ubicación del cursor. Solo
se ejecutan éstas configuraciones cuando el mensaje no esta siendo visualizado en el LCD actual.
Enviar comandos
Niple le permite enviar una serie de comandos al LCD solo indicando el nombre del comando
deseado. Para facilitarle aún más el manejo de las pantallas LCD, algunos comandos le permite
realizar reconfiguraciones de pantalla o cursor.
Los comandos disponibles son los siguientes:
• Apagar la pantalla: Este comando apaga los caracteres. No incluye opciones.

• Encender la pantalla: Visualiza los caracteres. Opcionalmente puede ubicar y reconfigurar
el cursor.
115
• Limpiar la pantalla: Limpiar todos caracteres de la pantalla. No incluye opciones.

• Cursor a Inicio: Ubica el cursor al inicio de la pantalla LCD, esto es, al renglón 1, carácter 1.
Este comando no incluye opciones.
• Ubicar el cursor: Ubica el cursor en la posición que indique el usuario. Opcionalmente
puede reconfigurar la visualización del cursor.
• Configurar el cursor: Permite reconfigurar el cursor. Este comando requiere que

necesariamente configure la visualización de los caracteres.
• Desplazar el cursor: Permite realizar un desplazamiento del cursor hacia la izquierda o

hacia la derecha. Opcionalmente puede ingresar un retardo entre cada desplazamiento.
116
• Desplazar la pantalla: Permite realizar un desplazamiento de la pantalla hacia la izquierda

o hacia la derecha. Opcionalmente puede ingresar un retardo entre cada desplazamiento.
Este comando produce un efecto visual de desplazamiento del mensaje.
Enviar caracteres
Además de configurar la visualización de mensajes, Niple le permite enviar caracteres

independientemente de un mensaje. Esto es muy común cuando se realizan proyectos con ingreso
de datos, los cuales son mostrados en la pantalla LCD. Por ejemplo; Usted diseña el mensaje de
solicitud de ingreso de datos. En general, en estos casos, configura el cursor como visible e
intermitente y lo ubica en la posición donde el usuario debe ingresar el mensaje y luego espera el
ingreso de los datos. Cada vez que el usuario ingresa un dato, el microcontrolador lo captura, por
interrupción por ejemplo, y lo envía a la pantalla LCD donde el usuario puede visualizar los datos
que está ingresando. Este envío de datos al LCD, corresponde a la función de Niple de envío de
carácter.
117
Niple le permite enviar un carácter o un texto.
Además le permite enviar los caracteres a la actual posición del cursor o definir una posición de
visualización determinada. Si necesita enviar un valor numérico guardado en un registro, Niple le
ofrece la posibilidad de convertirlo a código ASCII de manera automática.
Teclado Matricial
El módulo de teclado matricial permite capturar el valor de la tecla presionada en un teclado

matricial de 3×4 o de 4×4 y lo guarda en un registro. Para ello utiliza interrupciones por cambio de
estado en RB4 a RB7.
Niple verifica que la interrupción por RB4-7 se encuentre activada. Si la interrupción no se

encuentra activada no permite en ingreso del módulo.
Dado que se utiliza la interrupción por RB4-7, Niple requiere que los pines correspondientes a las
columnas del teclado matricial sean conectados a los pines RB4-7, mientras que le permite
seleccionar libremente los la conexión de los pines correspondientes a las filas. Al ingresar a la
pantalla de teclado matricial, Niple le solicita que seleccione el registro donde guardar el valor de
la tecla presionada. Luego le solicita que seleccione el tipo de teclado matricial que desea
conectar.
118
Y por último que seleccione los pines correspondientes a las filas del teclado matricial.
Memorias EEPROM I2C
Ingrese la sección “Dispositivos” y seleccione “Nuevo dispositivo” tipo “Memoria”. Seleccione el

modelo de la memoria a utilizar y elija los pines donde conectar la memoria al PIC.
Ingrese el número de dispositivo y por ultimo presione el botón “Ingresar” en el panel de la

derecha.
119
Recuerde que puede conectar varios dispositivos en paralelo formando una red, en la cual, a cada
dispositivo se le asigna un numero. Este número de dispositivo se configura conectado los pines
correspondientes de cada dispositivo. La cantidad de dispositivos que puede incluir en una red
depende del modelo de memoria que esta utilizando. Niple controla de manera automática la
cantidad de dispositivos que puede conectar en función del modelo seleccionado.
Leer memoria EEPROM I2C
Ingrese al árbol de herramientas: “Rutinas Basicas/Dispositivos/Memoria EEPROM”. Se presenta la

pantalla “Memorias EEPROM” y selecciona la acción “Lectura”.
120
Luego debe seleccionar la dirección de memoria que desea leer desde la memoria EEPROM.
Primero debe selecciona el tipo de dirección, la cual puede ser “Fija” o “Variable”.
Si selecciona el tipo de dirección “Fija” debe ingresar la posición de memoria

memoria a leer en formato
decimal. Niple controla que la dirección ingresada no supere el límite máximo de cantidad de
registros que contiene le modelo seleccionado. Mediante este tipo de acceso (por dirección fija) el
microcontrolador accederá a la dirección ingresada cada vez que se ejecute el bloque actual.
Si selecciona el tipo de dirección “Variable” debe seleccionar el registro que contiene el valor
correspondiente a la posición de memoria que desea leer.
121
En este caso, Niple no controla que la dirección ingresada no supere el límite máximo de cantidad
de registros que contiene el modelo seleccionado dado que no se puede predeterminar que valor
tendrá el registro seleccionado al ejecutarse el programa. Mediante este tipo de acceso (por
dirección variable) el microcontrolador accederá a la dirección correspondiente al valor que
contiene el registro cada vez que se ejecute el bloque actual.
Una vez seleccionada la dirección a leer, debe seleccionar el registro donde guardar el dato
obtenido desde la memoria. Por último, puede ingresar un comentario.
Escribir memoria EEPROM I2C
Para guardar datos de memorias EEPROM de la familia 24Cxxx ingrese al árbol de herramientas
como se muestra en la imagen de abajo:
Al ingresar en Memoria EEPROM se presenta la pantalla donde debe seleccionar que tipo de
acceso desea y los parámetros del mismo, ya sea escritura o lectura.
122
Seleccione el modelo de memoria que desea utilizar. Seleccione el tipo de acceso que desea tener
a la memoria EEPROM (ya sea escritura o lect
lectura).
Luego debe seleccionar la dirección de memoria que desea escribir en la memoria EEPROM.
Primero debe seleccionar el tipo de dirección, la cual puede ser “Fija” o “Variable”. Si selecciona el
tipo de dirección “Fija” debe ingresar la posición de memoria
memoria a escribir en formato decimal.
correspondiente a la posición de memoria que desea escribir. Mediante este tipo de acceso (por
dirección variable) el microc
microcontrolador
ontrolador accederá a la dirección correspondiente al valor que
Una vez seleccionada la dirección a escribir, debe indicar el dato que desea grabar en la memoria.
Puede ingresar un valor literal
literal o seleccionar un registro el cual contiene le valor que desea grabar.
Si selecciona la opción “Literal”, debe seleccionar el tipo de dato a grabar y luego debe ingresar el
valor que desea grabar en la memoria. Si selecciona la opción “Registro”, debe seleccionar
sel el
registro que contiene el valor a grabar en la memoria.
Por último, puede ingresar un comentario.
Memorias RAM
Ingrese al a sección “Dispositivos”, y seleccione el tipo de dispositivo “Memoria Ram I2C”.

Seleccione le modelo de la memoria a uti
utilizar y los pines correspondientes.
123
Presione el botón “Ingresar” para terminar de crear el dispositivo. Recuerde que puede conectar
varios dispositivos en paralelo formando una red, en la cual, a cada dispositivo se le asigna un
número. Este número de dispositivo se configura conectado los pines correspondientes de cada
dispositivo. La cantidad de dispositivos que puede incluir en una red depende del modelo de
memoria que está utilizando. Niple controla de manera automática la cantidad de dispositivos que
puede conectar en función del modelo seleccionado.
Leer memoria RAM I2C
Para leer datos de la memoria RAM ingrese al árbol de herramientas como se muestra en la
imagen de abajo:
124
Seleccione la memoria que desea utilizar. Al seleccionar el tipo de dispositivo

dispositivo a utilizar, Niple le
muestra la cantidad de registros de 8 bits que contiene el modelo seleccionado.
Seleccione el tipo de acceso a la memoria en este caso Lectura. Actualmente, Niple soporta la
memoria RAM PCF8570 pero en futuras versiones se irán agregando más modelos.
125
Luego debe seleccionar la dirección de memoria que desea leer desde la memoria RAM. Primero
debe selecciona el tipo de dirección, la cual puede ser “Fija” o “Variable”.
Si selecciona el tipo de dirección “Fija” debe ingresar la posición de memoria a leer en formato
correspondiente a la posición de memoria que desea leer.
En este caso, Niple no controla que la dirección ingresada no supere el límite máximo de cantidad
de registros que contiene el modelo seleccionado dado que no se puede predeterminar que valor
tendrá el registro seleccionado al ejecutarse el programa. Mediante este tipo de acceso (por
dirección variable) el microcontrolador accederá a la dirección correspondiente al valor que
Una seleccionada la dirección a leer, debe seleccionar el registro donde guardar el dato obtenido
desde la memoria. Por último, puede ingresar un comentario.
Escribir memoria RAM I2C
Ingrese al árbol de herramientas en la sección “Dispositivos / Memoria RAM I2C”:
126
Se presenta la pantalla “Memoria RAM por I2C”. Seleccione el nombre del dispositivo que desea
de
acceder.
127
Luego debe seleccionar la dirección de memoria que desea escribir en la memoria RAM. Primero
debe selecciona el tipo de dirección, la cual puede ser “Fija” o “Variable”.
Si selecciona el tipo de dirección “Fija” debe ingresar la posición de memoria a leer en formato
correspondiente a la posición de memoria que desea escribir. En este caso, Niple no controla que
la dirección ingresada no supere el límite máximo de cantidad de registros que contiene el modelo
seleccionado dado que no se puede predeterminar que valor tendrá el registro seleccionado al
ejecutarse el programa.
Mediante este tipo de acceso (por dirección variable) el microcontrolador accederá a la dirección
correspondiente al valor que contiene el registro cada vez que se ejecute el bloque actual.
Una vez seleccionada la dirección a escribir, debe indicar el dato que desea grabar en la memoria.
Puede ingresar un valor literal o seleccionar un registro el cual contiene le valor que desea grabar.
Si selecciona la opción “Literal”, debe seleccionar el tipo de dato a grabar y luego debe ingresar el
valor que desea grabar en la memoria.
Si selecciona la opción “Registro”, debe seleccionar el registro que contiene el valor a grabar en la
memoria. Por último, puede ingresar un comentario.
Reloj de tiempo real PCF8583
Declaración del dispositivo
Ingrese a la sección de Dispositivos y seleccione la opción “Reloj Tiempo Real” en la lista de nuevo
dispositivo. Se carga la pantalla de Declaración y Configuración del RTC.
Niple incluye tres modelos diferentes de RTC, los cuales se incluyen en la lista de dispositivos en la
parte superior izquierda de la pantalla. Seleccione el RTC PCF8583.
128
El PCF8583 funciona por comunicación I2C. Seleccione los pines correspondientes a las señales
SDA y SCL en las listas correspondientes. Por último presione el botón “Ingresar” que se encuentra
en la parte derecha de la pantalla.
Implementación
Ingrese a la sección de “Rutinas Básicas/Dispositivos/Reloj Tiempo Real” en el árbol de

herramientas. Al cargarse la pantalla, seleccione el dispositivo por su nombre (ID).
Las acciones que puede realizar sobre un PCF8583 son:
• Inicialización
• Escritura
• Lectura
129
Inicialización
El PCF8583 debe ser inicializado, esta acción asigna un valor inicial de fecha y hora, y pone en
marcha el reloj/calendario. Por defecto Niple asigna la fecha y hora actual del proyecto.
Una vez configurado el reloj de tiempo real (RTC) se pone en marcha activando un bit interno del
reloj. Este bit mantiene el reloj en funcionamiento
funcionamiento y Niple programa la inicialización del reloj para
ver este bit y determinar si el reloj ya está funcionando, en cuyo caso no se asigna la hora al iniciar
el sistema.
130
Escritura
Puede escribir datos al RTC y asignar los valores de fecha y hora del reloj. Para configurar la fecha
actual, ingrese a la solapa con el nombre “Fecha”.
Seleccione los parámetros que desea configurar (día, mes, año, día de la semana) marcado las
opciones correspondientes. Cada uno de estos datos puede ser de tipo “Fijo” o “Variable”.
Los valores a ingresar pueden ser los siguientes según el tipo de dato solicitado:
• Día:
o Fijo: entre 1 y 31 inclusive.
o Variable: un registro que contiene el valor del día.
• Mes:
o Variable: un registro que contiene el
e valor del mes.
• Año:
o Variable: un registro que contiene el valor del año.
• Día Semana:
131
o Fijo: entre Domingo y Sábado.

o Variable: un registro que contiene el valor del día de la semana.
La siguiente imagen muestra una configura

configuración de fecha “Fija”:
La siguiente imagen muestra una configuración de fecha “Variable”:
132
Para configurar la hora actual, ingrese a la solapa con el nombre “Hora”. Seleccione los parámetros
que desea configurar (Formato de Horas, Hora, Minutos, Segundos) Segundos) marcado las opciones
correspondientes. Cada uno de estos datos puede ser de tipo “Fijo” o “Variable”.
Los valores a ingresar pueden ser los siguientes según el tipo de dato solicitado:
• Formato de Hora:
o Fijo: puede seleccionar el formato de 12 o 24 horas.
• Horas:
o Fijo: depende del formato de hora seleccionado. Para el formato de 12 horas,
puede seleccionar entre las 00AM a 11AM y 00PM a 11PM. Para el formato de 24
horas puede seleccionar entre 0 y 23 inclusive.
o Variable: un registro que contiene el valor de las horas.
• Minutos:
o Variable: un registro que contiene el valor de los minutos.
• Segundos:
o Variable: un registro que contiene el valor de los segundos.
La siguiente imagen muestra una configurac

configuración de hora en formato “Fijo”:
133
La siguiente imagen muestra una configuración de hora en formato “Variable”:
134
Configuración de alarmas
El PCF8583 incluye un “Pin de Alarma” que el cual se pone en estado bajo cada vez que se produce
una alarma. Mientras una alarma no se produce el pin queda en estado alto.
Al producirse una alarma en el PCF8583, internamente se activa una bandera (bit) de alarma y el
pin de alarma se pone en estado bajo y se mantiene así mientras la bandera de alarma permanece
activada. La bandera de alarma debe ser limpiada por software. El PCF8583 incluye alarmas por
fecha, hora o por temporización.
La configuración de alarma por fecha y hora permite generar distintos tipos de alarmas:
• Alarma diaria: esta alarma se activa cada vez que coinciden la hora (horas, minutos y
segundos) configurada como alarma con la hora actual del reloj (horas, minutos y
segundos actuales).
• Alarma semanal: la alarma semanal se activa cuando coincide el día de la semana con el
alguno de los dos días de semana que puede configurar como alarmas.
• Alarma fechada: se activa cada vez que coinciden los datos de fecha y hora configurados
como alarma con los valores de fecha y hora actuales.
Cada una de estas alarmas puede ser configurada con valores fijos o variables. Los valores a
ingresar pueden ser los siguientes según el tipo de dato solicitado:
ALARMA DIARIA:
• Horas:
horas puede seleccionar entre 0 y 23 inclusive.
• Minutos:
o Variable: un registro que contiene el valor de los minutos.
135
ALARMAR POR FECHA:
• Día:
o Variable: un registro que contiene el valor del día seleccionado.
• Mes:
o Variable: un registro que contiene el valor del mes seleccionado.
• Horas:
horas puede seleccionar entre 0 y 23 iinclusive.
• Minutos:
o Variable: un registro que contiene el valor del día seleccionado. Debe generar el
código correspondiente al día.
136
Lectura
Para leer la fecha o la hora actual seleccione los datos que desea consultar (Día, Mes, Año, Día de
la Semana, Horas, Minutos, Segundos) y luego seleccione el registro donde desea almacenar cada
uno de los datos obtenidos. No es necesario que obtenga todos los datos correspondientes
correspondie a la
hora, sino que, puede obtener sólo los datos que necesita.
137
Comunicación RS232
El protocolo RS232 es utilizado para comunicación con el puerto serial de las computadoras
(puertos COM). Este módulo le permite enviar datos mediante el protocolo de comunicación
RS232 ya sea a otros microcontroladores o a una PC.
Para configurar y activar una comunicac comunicaciónión RS232, ingrese a la sección

“Dispositivos/Comunicaciones”. Seleccione de la lista de tipos de protocolos la opción “RS232”.
138
Seleccione el tipo de comunicación a realizar la cual puede ser mediante módulo USART. La USART
es un módulo de comunicaciones que algunos modelos de microcontroladores incluyen. Por
medio del módulo USART, todo el procedimiento de envío de los datos se realiza de manera
automática.
Mediante el modo de envío “por código”, se genera el código Assembler necesario para realizar el
envío de los datos.
La diferencia radica en que el módulo USART prepara el dato e inicia el envío y luego vuelve a
seguir ejecutando el resto del código del programa sin necesidad de realizar todo el proceso de
envío del dato ya que este se realiza de manera automática y en forma paralela a la ejecución del
resto del programa. Mientras que si se realiza “por Código”, la ejecución del programa realiza todo
el proceso de envío del dato.
Si selecciona el modo de envío “por USART”, el sistema selecciona de manera automática el pin de
transmisión correspondiente. Este pin no puede ser modificado dado que el módulo USART utiliza
un determinado pin para el envío de datos.
139
Si selecciona el modo de envío “por Código”, el sistema le solicita que seleccione el pin de
transmisión por el cual quiere realizar la comunicación.
A continuación debe seleccionar la velocidad de comunicación. Por último seleccione el botón

“Ingresar” y ya habrá creado el bus de comunicación RS232.
Para llamar en el programa principal a la rutina enviar datos por RS232, debe ingrese al árbol de
herramientas y al apartado comunicaciones dentro de rutinas básicas:
Luego debe seleccionar el nombre del bus que creo en la pantalla dispositivos y configurar la
acción.
En el caso de seleccionar la acción “Enviar”, Niple le mostrará la siguiente ventana donde debe
especificar, si desea la identificación del equipo del destino, la cantidad de bytes a enviar y de que
tipo es el dato a enviar, ya sea un literal o un registro.
140
Por último presione el botón “Ingresar”.
En el caso de configurar la comunicación en modo de recepción de datos, debe especificarse

parámetros similares al envío de datos y debe seleccionarse el registro donde guardar los datos
recibidos.
141
Comunicación RS485
La comunicación RS485 le permite conectar varios microcontroladores en red. Generalmente una

red de microcontroladores está formada por un micro llamado maestro, el cual cu se encarga de
organizar el funcionamiento de la red, enviando comandos y solicitando información al resto de
los de micros denominados esclavos. En general, los dispositivos esclavos responden enviando los
datos solicitados por el maestro o ejecutan comandos
comandos enviados por el maestro.
142
Una red 485 puede estar formada por hasta 256 dispositivos esclavos a una distancia máxima
aproximada de 1200 metros y cada dispositivo esclavo debe estar identificado por un número de
dispositivo.
En general, el microcontrolador maestro se encarga de realizar los procesos principales (ingreso de

datos al sistema, interfaz con el usuario, LCD, display de 7 segmentos, conexión a PC, etc.)
mientras que los dispositivos esclavos, generalmente realizan los procesos distribuidos, es decir,
los procesos locales propios de cada punto de control y pueden contar con un alto grado de
autonomía.
Niple soporta la interfaz DS75176B para realizar las comunicaciones RS485.
La comunicación RS485 requiere de 3 pines:
• Transmisión (TX), configurado como salida

• Recepción (RX), configurado como entrada
• Control de TX/RX de la interfaz DS75176 configurado como salida
Cuando un microcontrolador en modo maestro solicita datos a otro microcontrolador en modo

esclavo, las interfaces DS75176 de ambos micros deben conmutar a modo transmisión y recepción
respectivamente y si el esclavo debe responder con algún dato al maestro, ambos micros deben
cambiar el estado de sus interfaces (maestro en modo recepción y esclavo en modo transmisión)
mediante el pin de control del la interfaz. Cuando termine el envío de datos al maestro, deben
volver a conmutar el modo de sus interfaces al estado inicial. Niple coordina de manera
automática el cambio de modo de trabajo (TX/RX) de las interfaces.
A continuación se muestra un esquema de la estructura de un proyecto típico de implementación

de una red RS485.
143
Modo maestro
Para ingresar a los módulos de RS485 ingrese a la pestaña Dispositivos/Comunicaciones. Luego

seleccione RS485:
144
Seleccione el modo de comunicación,

comunicación, por módulo USART o por código. No todos los modelos de
microcontroladores disponen de un modulo USART.
Si selecciona el modo de comunicación por USART, Niple selecciona de manera automática los
pines correspondientes a TX y RX e inhabilita los mismos, dado que los mismos ya vienen
preestablecidos para ser utilizados por el módulo USART.
Luego seleccione la velocidad de comunicación:
Una vez creado el módulo de comunicación RS485, ingrese al Árbol de herramientas y seleccione
comunicaciones, una vez seleccionado pedirá que seleccionemos el tipo de comunicación creado.
Inicialice el modulo RS485:
145
Una vez inicializado el bus, tendremos que configurar en el caso de elegir la acción enviar las
opciones como:
• Identificación del destino

• Cantidad de bytes a enviar
• Datos a enviar
Opcionalmente puede seleccionar un ID de destino. Esto es ideal para trabajar en una red RS-485
RS
donde cada dispositivo esclavo es identificado por medio de un código ID.
Para interpretar mejor cada una de las funciones disponibles, aclaramos los significados que
damos a las siguientes palabras:
146
• Enviar: enviar una orden a un esclavo a partir de la cual el esclavo realiza una determinada
acción pero esta acción no incluye el envío de una respuesta desde el esclavo hacia el
maestro.
• Interrogar: solicitar un dato a un esclavo, en general el esclavo responde inmediatamente

sin realizar ningún proceso antes de enviar los datos solicitados.
• Recibir datos: recibe datos desde un esclavo.
Seleccione el registro donde guardaremos

guardaremos los datos y la cantidad de bytes que tiene ese dato.
147
Interrogar
Como detallamos anteriormente la función interrogar solicita un dato a un esclavo, en general el

esclavo responde inmediatamente sin realizar ningún proceso antes de enviar los datos
solicitados.
itados. Para eso seleccionamos la acción Interrogar.
148
Procedimiento para programación de los PIC12F6xx
Los micros de las familia de PIC 12F6xx requieren un procedimiento especial para ser
programados. Estos micros requieren de un valor de calibración ubicado en final de la memoria de
programa que permite garantizar la correcta calibración del oscilador interno.
Este procedimiento es necesario realizarlo para todos los tipos de programadores de PIC.
Por esto: es necesario recuperar este valor antes de utilizar por utilizar por primera el micro. A
continuación, vamos a utilizar el PIC12F675 y el software de programación IC-Prog.
Seleccione el modelo correcto de PIC. En este caso el PIC12F675.
El valor de calibración puede variar de un chip a otro. Por esto, debe comenzar realizando una
lectura de la memoria flash del micro. Para ello, presione el botón para realizar el proceso de
lectura:
Al finalizar la lectura del micro, se obtiene el contenido de la memoria flash (memoria de

programa). Dado que aún el micro no ha sido utilizado, todas las posiciones de memoria deben
contener el valor 3FFF a excepción de la última dirección (0x03FF). Esta última dirección de
memoria flash contiene el valor de calibración del microcontrolador (en formato hexadecimal).
En nuestro ejemplo el valor de calibración del PIC actualmente utilizado es 0x3428.
Es aconsejable tomar nota del valor de calibración. Y mejor aún, puede grabar el este valor
pegando un papel en la parte inferior del PIC. Este procedimiento es recomendable cuando trabaja
con varios PIC. Recuerde que el código de calibración puede variar de un PIC a otro.
Cargue el archivo .HEX que desea programar en IC-Prog. Al realizar esto, el valor de calibración del
PIC16F675 fue sustituido por el valor hexadecimal por defecto $3FFF.
149
Haga doble clic sobre esta última posición de memoria con el fin de asignar el valor de calibración
correspondiente.
En la zona de valor hexadecimal 3FFF, ingrese el valor de calibración anteriormente obtenido. Para
nuestro ejemplo, el valor corresponde a 3428.
Presione el botón “OK”. Ahora el programa esta listo para grabar el PIC. En la fase de
programación, IC-Prog comienza leyendo la memoria del PIC con el fin de comparar el contenido
de la última dirección con el valor de calibración ingresado manualmente.
Si el código de calibración que contiene el PIC es el mismo que el que se encuentra en la última
posición de memoria del archivo a grabar, continúa la grabación y por último muestra el mensaje
que el PIC ha sido grabado correctamente y con esto queda finalizada la grabación del PIC.
150
Si el código de calibración que contiene el PIC no es el mismo que se encuentra la última posición
de memoria del programa a grabar, se muestra un mensaje indicado este problema y pregunta si
desea sobrescribir el valor que actualmente se encuentra en el PIC con el valor contenido en la
última posición del archivo a grabar.
Si responde “SI”, se graba el valor de calibración contenido en la ultima posición del archivo. Si
responde “NO”, se graba el programa pero no se cambia el valor de configuración del PIC.
Si Usted no está completamente seguro que el valor contenido en la última posición del archivo
corresponde al valor de calibración del PIC, seleccione la opción “Cancelar” vuelva a realizar la
lectura de la memoria del micro para obtener el valor de calibración.
Para grabar el mismo programa en distintos microcontroladores, debe actualizar el valor de

calibración de cada PIC en la última posición de memoria del archivo a grabar.
151

Niple - Manual de Usuario PDF

Cargado por

Copyright:

Formatos disponibles

Niple - Manual de Usuario PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Niple - Manual de Usuario PDF

Cargado por

Copyright:

Formatos disponibles

PROGRAMACIÓN VISUAL DE MICROCONTROLADORES

INTRODUCCIÓN A LOS MICROCONTROLADORES ..................................................................................... 6

Estirar un bloque ..................................................................................................................................... 38

Asignar valor a un registro ....................................................................................................................... 67

Utilizando más de una pantalla LCD ...................................................................................................... 105

INTRODUCCIÓN A LOS MICROCONTROLADORES

Los microcontroladores hicieron su aparición a principio de los ’80 y se trata de un circuito

• CPU (Unidad Central de Proceso)

Todo esto lo podemos encontrar dentro del mismo circuito integrado.

Los microcontroladores “PIC”

Los microcontroladores denominados “PIC” corresponden exclusivamente a la marca Microchip.

Existe una gran cantidad de modelos de microcontroladores cuyas características y prestaciones

Este programa se escribe en un lenguaje llamado “Assembler” (ensamblador) cuya principal

Básicamente, un microcontrolador está compuesto por los siguientes componentes:

Es el elemento más importante del microcontrolador y determina sus principales características,

Actualmente, existen 3 tipos de arquitectura de procesadores:

• CISC (Computadores de Juego de Instrucciones Complejo): disponen de más de 80

• RISC (Computadores de Juego de Instrucciones Reducido): En estos procesadores el

• SISC (Computadores de Juego de Instrucciones Específico): En los microcontroladores

• OTP: El microcontrolador contiene una memoria no volátil de sólo lectura “programable

• EPROM: Los microcontroladores que disponen de memoria EPROM (Erasable

Dentro de la memoria, cada registro se identifica mediante un número, el cual se denomina

La palabra BIT proviene de la contracción de las palabras “Binary Digit”

1 = Encendido = Verdadero = “SI” = +5V

0 = Apagado = Falso = “NO” = 0V

Esta característica de procesar números (“Dígitos”) es lo que da el nombre a la “Electrónica

El siguiente ejemplo muestra el desarrollo de un cálculo de conversión de base de sistema binario

El sistema hexadecimal se usa como forma simplificada de representación de números binarios y

En la programación de microcontroladores, es habitual utilizar los 3 sistemas de numeración

Líneas de entrada y salida

Como mencionamos anteriormente, todo el funcionamiento del microcontrolador está controlado

Un microcontrolador puede contener varios p

Temporizadores internos (TMRs)

Un temporizador interno (TMR) es un módulo de hardware incluido en el mismo microcontrolador

Donde “Frecuencia de Oscilación” es la frecuencia del oscilador utilizado.

Dado que la velocidad de ejecución del microcontrolador corresponde a ¼ de la velocidad del

En este caso, se utiliza un TMR para realizar la temporización mientras el microcontrolador se

Así podemos realizar interrupciones con periodos de tiempo mayores.

Como mencionamos anteriormente, el microcontrolador tiene una memoria de programa, donde

Los microcontroladores se programan en un lenguaje de programación llamado Ensamblador (en

Los lenguajes de programación se clasifican según el “Nivel” de programación en:

• Lenguaje de “Bajo Nivel”: el usuario se acerca un poco más al lenguaje de máquina.

• Lenguaje Ensamblador: Podríamos considerarlo el lenguaje de más bajo nivel. El usuario

El archivo compilado tiene una extensión .hex.

A continuación se presenta un resumen del proceso de desarrollo del código y grabación de un

1. Escribir el código Assembler. Se genera un archivo con extensión ASM.

Niple: Programación Visual de microcontroladores PIC

Como mencionamos en los párrafos anteriores, la programación de los microcontroladores resulta

El principal objetivo de Niple es facilitar al máximo la programación de los microcontroladores.

El concepto de la programación es que el usuario se concentre en “qué es lo que quiere hacer”, y

Entorno Visual de desarrollo para programación de microcontroladores

La metodología de programación cons

Entre las principales prestaciones que Niple ofrece podemos destacar:

Entono Visual de Alto Nivel de programación:

• Niple ofrece una metodología de programación totalmente visual y en lenguaje humano.

Control automático de registros y bits:

• Controla la existencia de todos los registros

• Controla que no existan nombres de registros y bits duplicados.

Corrección automática de errores lógicos: