domingo, 28 de julio de 2019

Lectura de un sensor DS18S20 con visualizacion en un LCD con Microcontrolador PIC

Muy facil de hacer, no necesitas un arduino para hacer esto, de hecho con un diminuto chip de la marca PIC de microchip puedes hacerlo y a un costo mucho menor, diseña el circuito a tu gusto y ponlo junto a otros componentes:




sbit LCD_RS at RB2_bit;
sbit LCD_EN at RB3_bit;
sbit LCD_D7 at RB7_bit;
sbit LCD_D6 at RB6_bit;
sbit LCD_D5 at RB5_bit;
sbit LCD_D4 at RB4_bit;

// Pin direction
sbit LCD_RS_Direction at TRISB2_bit;
sbit LCD_EN_Direction at TRISB3_bit;
sbit LCD_D7_Direction at TRISB7_bit;
sbit LCD_D6_Direction at TRISB6_bit;
sbit LCD_D5_Direction at TRISB5_bit;
sbit LCD_D4_Direction at TRISB4_bit;
#include <built_in.h>
const char ASCCI[] = "0123456789ABCDEF";

void main() {
unsigned Temp;
char string[8];
adcon1 = 6;
       Lcd_Init();
       Lcd_Cmd(_LCD_CLEAR);
       Lcd_Cmd(_LCD_CURSOR_OFF);
       while(1){
           temp=ReadDs(0);
           DS18S20ToStr(temp,string);
           lcd_out(1,1,String);
           delay_ms(200);
   
       }
}

sábado, 5 de enero de 2019

50 Ejercicios en ensamblador MPLABC y CCS para el PIC16F1827 #9 transmision de datos con paridad

Como transmitir y generar el bit de paridad en ASM usando MPLABX

 1 ;*******************************************************************************
  2 ;                                                                              *
  3 ;    Filename:  Proyecto USART                                                 *
  4 ;    Date:      29/07/2017                                                     *
  5 ;    File Version:   0.01                                                      *
  6 ;    Author:    Mariano Rocha                                                  *
  7 ;    Company:   Electronicos embebidos                                         *
  8 ;    Description: TX USART                                                     *
  9 ;                                                                              *
 10 ;*******************************************************************************
 11 LIST P=16f1827
 12 RADIX HEX
 13 include  P16f1827.inc
 14 __CONFIG _CONFIG1, _FOSC_XT & _WDTE_OFF & _PWRTE_ON & _MCLRE_OFF & _CP_OFF & _CPD_OFF & _BOREN_ON & _CLKOUTEN_OFF & _IESO_ON & _FCMEN_ON    
 15 __CONFIG _CONFIG2, _WRT_OFF & _PLLEN_OFF & _STVREN_ON & _BORV_LO & _LVP_ON
 16     
 17     
 18 CBLOCK 0X20
 19 Text,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15
 20 jt, regpar, uartreg
 21 ENDC    
 22 ; proteus even txsta.0 = 1  odd txsta.0 =0
 23 
 24     ORG        0
 25     goto       INICIO
 26 
 27 ;********************************************************************
 28 Paridad_Bit:    
 29     movwf      regpar 
 30     BANKSEL    TXSTA
 31     bsf        TXSTA,0
 32     BANKSEL    0
 33     movlw      .8
 34     movwf      jt     
 35 Paridad_Bit1:    
 36     btfsc      regpar,7
 37     goto       Paridad_Bit2
 38     goto       Paridad_Bit3
 39 Paridad_Bit2:    
 40     movlw      b'00000001'
 41     BANKSEL    TXSTA 
 42     xorwf      TXSTA,f      
 43     BANKSEL    0    
 44 Paridad_Bit3:      
 45     decfsz     jt,f
 46     goto       $+2
 47     return    
 48     rlf        regpar,f
 49     goto       Paridad_Bit1
 50 ;********************************************************************     
 51     
 52 CONFIG_USART_9600:
 53     BANKSEL    TXSTA
 54     movlw      B'11100101' 
 55     movwf      TXSTA
 56     movlw      .25
 57     movwf      SPBRGL
 58     clrf       SPBRGH
 59     BANKSEL    RCSTA
 60     movlw      B'10000000'     
 61     movwf      RCSTA
 62     BANKSEL    TXSTA
 63     bsf        TXSTA,TXEN
 64     BANKSEL    RCSTA
 65     bsf        RCSTA,CREN
 66     BANKSEL    PIR1
 67     bsf        PIR1,TXIF
 68     BANKSEL    TRISB
 69     bcf        TRISB,2
 70     BANKSEL    BAUDCON
 71     movlw      B'00000000' 
 72     movwf      BAUDCON
 73     BANKSEL    0
 74     return
 75 
 76 UART_WRITE:
 77     banksel   0
 78     movwf     uartreg
 79     call      Paridad_Bit
 80     banksel   0
 81     movf      uartreg,w
 82     BANKSEL   TXREG
 83     movwf     TXREG
 84     BANKSEL   PIR1
 85     nop
 86     btfss     PIR1,TXIF
 87     goto      $-2
 88     return
 89 
 90 UART_WRITE_STRING:    
 91      movwf     FSR0
 92 UART_1:
 93      movf      INDF0,w
 94      btfsc     STATUS,Z
 95      return
 96      call      UART_WRITE
 97      incf      FSR0,f
 98      BANKSEL   0
 99      goto      UART_1     
100 ;********************************************************************
101    
102 INICIO:
103     BANKSEL   ANSELB
104     clrf      ANSELB    
105     BANKSEL   0
106     call      CONFIG_USART_9600
107     
108 MAIN:  
109      movlw     'P'
110      movwf     Text
111      movlw     'R'
112      movwf     t1
113      movlw     'O'
114      movwf     t2
115      movlw     'G'
116      movwf     t3
117      movlw     'R'
118      movwf     t4 
119      movlw     'A'
120      movwf     t5
121      movlw     'M'
122      movwf     t6
123      movlw     'A'
124      movwf     t7
125      movlw     'N'
126      movwf     t8
127      movlw     'D'
128      movwf     t9
129      movlw     'O'
130      movwf     t10
131      movlw     'P'
132      movwf     t11
133      movlw     'I'
134      movwf     t12
135      movlw     'C'
136      movwf     t13
137      movlw     's'
138      movwf     t14  
139      movlw     0
140      movwf     t15
141      
142      movlw     Text
143      call      UART_WRITE_STRING
144      goto      $
145 
146 
147     
148  
149     goto      $
150 
151      
152 end;      


Codigo CCS donde se explica como transmitir con paridad y hacer las pruebas en proteus.

El bit de paridad es un bit que se añade a la información transmitida de tal forma que el número de "1" sea par o impar.
Por ejemplo si transmito el byte 01101101 si quiero un bit de paridad par este valdra "1" (ya que el número de unos que tenemos es impar, al añadir este se vuelve par) quedando: 011011011. Por el contrario si es paridad impar añadiremos un "0" (por ser el números de unos impar) quedando: 011011010.

La forma de consigurarlo es mediante el FUSE: PARITY que puede valer:

N => No se utiliza paridad,
E => Paridad Par,
O => Paridad Impar.

CCS hace el calculo automaticamente y lo añade al registro TXSTA bit 1 para que cuando se transmita este incluido, lo unico que tenemos que configurar es la linea de USART

#use rs232(baud=9600,parity=O,UART1,bits=8)

Luego en el simulador configuramos




Y asi queda el codigo en CCS


Ahora podemos ver como queda la simulacion



Codigo CCS  Codigo ASM




miércoles, 2 de enero de 2019

50 ejercicios ensamblador MPLABx y CCS con el PIC16F1827 EUSART Ej #8

Con este ejercicio vamos a implementar un ejemplo conocido como ECO, lo que sucede es que lo que escribimos en una terminal es enviado al microcontrolador por el puerto serie y este lo va devolviendo por su pin TX de esta manera podemos ver lo que vamos enviando desde el terminal como un ECO de lo enviado.

Codigo fuente en ASM
Codigo prinsipal.


 1 ;*******************************************************************************
  2 ;                                                                              *
  3 ;    Filename:  Proyecto USART                                                 *
  4 ;    Date:      29/07/2017                                                     *
  5 ;    File Version:   0.01                                                      *
  6 ;    Author:    Mariano Rocha                                                  *
  7 ;    Company:   Electronicos embebidos                                         *
  8 ;    Description: RX-TX USART                                                     *
  9 ;                                                                              *
 10 ;*******************************************************************************
 11 LIST P=16f1827
 12 RADIX HEX
 13 include  P16f1827.inc
 14 __CONFIG _CONFIG1, _FOSC_XT & _WDTE_OFF & _PWRTE_ON & _MCLRE_OFF & _CP_OFF & _CPD_OFF & _BOREN_ON & _CLKOUTEN_OFF & _IESO_ON & _FCMEN_ON    
 15 __CONFIG _CONFIG2, _WRT_OFF & _PLLEN_OFF & _STVREN_ON & _BORV_LO & _LVP_ON
 16     
 17     
 18 CBLOCK 0X20
 19 Text,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15
 20 ENDC    
 21          
 22 
 23     ORG        0
 24     goto       INICIO
 25     
 26 CONFIG_USART_9600:
 27     BANKSEL    TXSTA
 28     movlw      B'10100100' 
 29     movwf      TXSTA
 30     movlw      .25
 31     movwf      SPBRGL
 32     clrf       SPBRGH
 33     BANKSEL    RCSTA
 34     movlw      B'10000000'     
 35     movwf      RCSTA
 36     BANKSEL    TXSTA
 37     bsf        TXSTA,TXEN
 38     BANKSEL    RCSTA
 39     bsf        RCSTA,CREN
 40     BANKSEL    PIR1
 41     bsf        PIR1,TXIF
 42     BANKSEL    TRISB
 43     bcf        TRISB,2
 44     BANKSEL    BAUDCON
 45     movlw      B'00000000' 
 46     movwf      BAUDCON
 47     BANKSEL    0
 48     return
 49 
 50 UART_WRITE:
 51     BANKSEL   TXREG
 52     movwf     TXREG
 53     BANKSEL   PIR1
 54     btfss     PIR1,TXIF
 55     goto      $-1
 56     return
 57     
 58 UART_WRITE_STRING:    
 59      movwf     FSR0
 60 UART_1:
 61      movf      INDF0,w
 62      btfsc     STATUS,Z
 63      return
 64      call      UART_WRITE
 65      incf      FSR0,f
 66      BANKSEL   0
 67      goto      UART_1 
 68 
 69 UART_READ:
 70     bsf        STATUS,Z
 71     BANKSEL    PIR1 
 72     btfss      PIR1,RCIF
 73     return
 74     BANKSEL    RCREG
 75     movf       RCREG,W
 76     return    
 77      
 78      
 79 INICIO:
 80     BANKSEL   ANSELB
 81     clrf      ANSELB    
 82     BANKSEL   0
 83     call      CONFIG_USART_9600
 84     movlw     'I'
 85     call      UART_WRITE
 86     movlw     'N'
 87     call      UART_WRITE    
 88     movlw     ':'
 89     call      UART_WRITE    
 90     
 91 MAIN:
 92     call       UART_READ
 93     btfsc      STATUS,Z
 94     goto       MAIN
 95     call       UART_WRITE
 96     goto       MAIN
 97     
 98 goto $
 99     
100 end;      

Esquematico


Version CCS del mismo proyecto


Descargar las verciones ASM y CCS de este ejercicio.


Este es un blog libre de arduino.


50 ejercicios ensamblador MPLABx y CCS con el PIC16F1827 EUSART Ej 7

Continuamos con esta serie de ejercicios básicos de programación en ensamblador usando el PIC16F1827
Ej #7
Esta ves damos uso al modulos EUSAR (Enhanced USART).
Por ahora no vamos a utilizar las caracteristicas de deteccion de velocidad que es capas de realizar estos micros, ya que es una caracteristica avanzada que nunca he utilizado, pero que mas adelante en ejercicios posteriores voy a tratar de probar.
Por ahora solo se enviara una cadena de datos, eso si al estilo strings de c, y usando rutinas tambien comunes a lenguajes de alto nivel, pero implementadas en ASM.
Tenemos rutinas como:
CONFIG_USART_9600

UART_WRITE
UART_WRITE_STRING

Luego de cargar toda la cadena de texto en el array que tenemos enviarmo con UART_WRITE_STRING.



Ahora veremos lo mismo pero usando CCS


Descargar los codigos ASM y CCS

50 ejercicios ensamblador MPLABx y CCS con el PIC16F1827 Ej #6 control del TIMER1 conteo de evento externo

Continuamos con esta serie de ejercicios básicos de programación en ensamblador y CCS usando el PIC16F1827

Ej #6

ASM
Esta ves he realizado una nueva actualización de la librería ASM para manejo del LCD ahora se puede utilizar cualquier pin del microcontrolador y cualquier puerto con el fin de hacer mas personalizable, eso no es todo, ahora vamos a ver el TIMER1 en acción, tambien he incorporado una librería que había creado hace muchos años para la conversión de datos binarios en BCD y para finalizar estamos usando el direccionamiento Indirecto con los registros INDF0 y FSR0 con el fin de enviar datos al lcd al estilo cadenas de c.




En el siguiente codigo podemos ver como se configura el timer para poder trabajar con el

Las modificaciones realizadas a la libreria LCD a fin de poder usar los pines deseados y dejar los que necesitamos para otros usos específicos como en este caso la entrada del TIMER1

La libreria hecha para trabajar la conversion de binario a decimal a fin de poder mostrar la lectura del TIMER1 en el LCD


Codigo en CCS





Descarga de todo los codigos ASM y CCS

martes, 1 de enero de 2019

50 ejercicios ensamblador MPLABx con el PIC16F1827 Ej # 5.1 Manejo de display LCD con librería LCD propia en ASM constante string en rom

50 ejercicios ensamblador MPLABx con el PIC16F1827 

Con este ejercicio aprenderemos a colocar caracteres ascci en la memoria flash del microcontrolador a manera de constantes de arrays.






Descargar todo los codigos y simulaciones aca


50 ejercicios ensamblador MPLABx y CCS con el PIC16F1827 Ej # 5 Manejo de display LCD con librería LCD propia en ASM

50 ejercicios ensamblador MPLABx con el PIC16F1827 
Continuamos con esta serie de ejercicios básicos de programación en ensamblador usando el PIC16F1827
Ej #5
Titulado: Manejo de display LCD con librería LCD propia.



Descarga aca el codigo ASM y CCS

50 ejercicios ensamblador MPLABx y CCS con el PIC16F1827 ej #4 Conteo decimal con display y tabla de datos

Continuamos con esta serie de ejercicios básicos de programación en ensamblador usando el PIC16F1827

Titulado: Contador decimal con display led con tabla de datos







Descarga el codigo ASM y CCS

50 ejercicios ensamblador MPLABx y CCS con el PIC16F1827 ej #3 Conteo decimal con display

Continuamos con esta serie de ejercicios básicos de programación en ensamblador usando el PIC16F1827

Titulado: Contador decimal con display led

Vamos avanzando en estos ejercicios prácticos y vamos aprendiendo el uso de esta nueva gama de microcontroladores PIC la cual es mucho mas potente que los PIC16  87x o los 628A
Nuevas características y posibilidades seran probadas en la medida que avancemos.





Descargar codigo ASM y codigo CCS


50 ejercicios ensamblador MPLABx y CCS con el PIC16F1827 ej #2 Led Barr

Continuamos con esta serie de ejercicios básicos de programación en ensamblador y ccs usando el PIC16F1827

Titulado Barra de leds

Podemos ver algunas diferencias en los codigos ASM y CCS, en ASM tenemos una programacion mucho mas compacta por que podemos hacer uso de recursos como el registro de estados cosa que no es factible o recomendable con c ya que este compilador lo usa para su trabajo.





Descargar codigos fuentes en ASM y CCS


50 ejercicios ensamblador MPLABx con el PIC16F1827 incluye condigo en CCS ej #1 Led Blink

Iniciamos esta serie de ejercicios básicos de programación en ensamblador usando el PIC16F1827

La familia PIC16F1826/1827 de microcontroladores se basa en el núcleo de arquitectura media mejorada de Microchip con una pila de hardware de 16 niveles de profundidad y 49 instrucciones. Estas MCU proporcionan hasta 8 MIPS, hasta 7 Kbytes de memoria de programa con RAM de hasta 384 bytes y EEPROM de datos de 256 bytes. Posee un oscilador configurable con una precisión de ±1%.

Características del microcontrolador
Velocidad de CPU máx. de 32 MHz
49 instrucciones
Pila de hardware de 16 niveles
Oscilador interno de 32 MHz – Rango de frecuencia seleccionable de 32 MHz a 31 kHz
16 contactos de E/S
Tecnología nanoWatt XLP
Reset de encendido (POR)
Temporizador de arranque (PWRT)
Temporizador de arranque de oscilador (OST)
Reset de caída de tensión (BOR)
Temporizador Watchdog ampliado (WDT)
Programación de baja tensión mejorada (LVP)
Programación serie en circuito (ICSP)
Depuración en circuito (ICD)
Periféricos
Convertidor analógico a digital (ADC) de 12 canales y 10 bits
Módulo de sensor capacitivo mTouchTM de 12 canales
Dos módulos de captura/comparación/PWM (CCP) – PIC16F1827 solo
Módulos de captura/comparación/PWM mejorados (ECCP) – PIC16F1826 x 1, PIC16F1827 x 2
Dos comparadores
Temporizadores de 8 bits – PIC16F1826 x 2, PIC16F1827 x 4
Un temporizador de 16 bits
Puerto serie síncrono maestro (MSSP) con SPI e I2C – PIC16F1826 x 1, PIC16F1827 x 2
Transmisores receptores síncronos-asíncronos universales mejorados (EUSART)
Referencia de tensión fija (FVR)
Módulo de modulador de señal de datos


Datasheet:   https://goo.gl/NjKVP6

Iniciamos un led blinnk


Vista del proyecto en mplabx 5.1


Descargar el codigo fuente en ASM en el siguiente LINK


Descargar el codigo fuente en CCS

https://goo.gl/tmC6k7

Set de instrucciones basicas de estos microcontroladores

martes, 18 de diciembre de 2018

RTOS en microcontroladores PIC: ¡El diablo en el interior!


 
Un moderno circuito digital con microcontroladores en su corazón. (cortesía de wallpoper.com)

 Los microcontroladores son caballos de trabajo para la mayoría de los dispositivos electrónicos digitales. Mucha gente como yo ama el poder de procesamiento y control que ofrecen estas pequeñas computadoras. Si estás leyendo este blog, puedo asumir con seguridad que te apasionan los microcontroladores y quieres impulsar a las pequeñas bestias a su máximo potencial y diseñar sistemas electrónicos del mundo real.

Supongo que tiene un conocimiento previo de qué son los microcontroladores y ha estado trabajando con ellos durante algún tiempo. Si eres nuevo en este campo, sería una gran búsqueda y aprendizaje sobre los microcontroladores y su uso para varios problemas más simples.

Áreas de enfoque: diseño de aplicación de subproceso paralelo basado en RTOS usando microcontroladores PIC con OSA RTOS en mikroC pro para compiladores de la serie PIC.

¿Por qué necesito RTOS?

La mayoría de los programadores de microcontroladores escriben códigos secuenciales para sus aplicaciones. El microcontrolador leerá cada función llamada y hará lo que se le pida. Esto está bien para aplicaciones más pequeñas donde el microcontrolador debe hacer solo una cosa en particular. Digamos que desea utilizar su microcontrolador para hacer parpadear un LED y nada más, estaría bien si lo hace sin sentir la necesidad de ejecutar un sistema operativo dentro de su microcontrolador. Pero para cualquier otra aplicación donde se supone que más de una cosa debe hacerse simultáneamente, estás atascado.

¿Alguna vez sintió que su computadora funciona a la perfección mientras escribe documentos, navega por la web y escucha música, todo al mismo tiempo? Esto es posible gracias a los sistemas operativos que comparten el tiempo de su procesador entre las tareas. Todos los dispositivos electrónicos integrados modernos que ha estado utilizando utilizan un sistema operativo de algún tipo u otro. 

Piense en un problema muy simple, suponga que ahora, en lugar de un LED parpadeando en su microcontrolador, necesita 5 leds parpadeando, todos con diferentes frecuencias. Suena como un problema estúpido sin uso real y cualquier dispositivo real sería más complicado que esto, pero todavía no puedes hacerlo con el código secuencial que has estado escribiendo. 

Los problemas prácticos generalmente requieren un mayor número de tareas que se ejecutan en paralelo. Es posible que solo haya un par de subprocesos funcionando para permitir la interacción del usuario mientras la actividad principal del dispositivo se mantiene activa en segundo plano. 

Un sistema operativo en tiempo real (RTOS, por sus siglas en inglés) le permite ejecutar un número o tareas de forma periódica o, de lo contrario, proporcionar servicios como la programación para compartir el tiempo del procesador entre diferentes tareas. Todos los procesadores ejecutan solo una línea de código a la vez.

Este tutorial lo llevará a través del desarrollo de una aplicación de subprocesos múltiples en un microcontrolador PIC18. El compilador utilizado será MikroC Pro para PIC, solo porque me encanta, no hay otra razón. El sistema operativo utilizado es OSA. Diseñaremos una aplicación que le proporcionará una plantilla básica para usar OSA en casi la mayoría de las aplicaciones que pueda encontrar.

Acerca de OSA

He trabajado con diferentes RTOS hasta ahora, y nunca encontré realmente una gran huella ultra-baja y un RTOS eficiente para ser portado en dispositivos como microcontroladores con una cantidad de memoria extremadamente limitada. Un microcontrolador PIC18f452 generalmente tendría aproximadamente 1.5 KB de RAM. Nunca querrá usar la mayor parte de su memoria para el programador.

OSA es un RTOS cooperativo no preventivo para dispositivos con poca memoria, se ha incorporado a todos los microcontroladores populares y generalmente es compatible con casi todos los compiladores famosos, incluidos MPLAB, CCS PICC, AVR studio y MikroC Pro. El núcleo del sistema operativo proporciona una gran biblioteca de funciones. La estructura del programa termina siendo muy similar a la que has estado trabajando. Mientras consume solo alrededor de 60 bytes de memoria en la RAM, OSA es una opción ideal para aplicaciones basadas en microcontroladores. Caerás en su amor, sospecho :).

Algunos términos que usaré alrededor:
Cambio de contexto: pausando la tarea donde está y atendiendo a otra tarea, la operación volverá a esta tarea más adelante.

Tarea: Un fragmento de código que ejecutará el sistema operativo. Tarea es una función que el sistema operativo llamará repetidamente.

Hilo : Esto podría usarse indistintamente con la Tarea, pero en el contexto de este tutorial es una función que nunca termina (tiene un bucle de tiempo (1) dentro) y se ejecuta en paralelo con otros subprocesos.

Limitaciones:
Ser no preventivo es una desventaja, significa que si su programa se atasca en un bucle largo dentro de una tarea de baja prioridad, el programador no se adelantará o cambiará el contexto de manera forzada. El cambio de contexto es hasta el usuario en todos los RTOS cooperativos. Sin embargo, esto no es un contratiempo importante y puede hacer frente a estos problemas con alguna programación inteligente. Esto es lo que hace a este RTOS basado en un microcontrolador diferente de los sistemas operativos complejos como Windows, por lo que es lo suficientemente bueno con una computadora pequeña como PIC. 

Haciendo su primer programa multihilo

El plan es resolver el mismo problema simple del que hablé. Haremos un programa que parpadee 4 LED con frecuencias muy diferentes, todo al mismo tiempo. Lanzaremos 4 hilos. Está acostumbrado a tener una función principal en su programa de microcontrolador donde tendría un bucle sin fin para mantener el programa en marcha. Escribiremos un código que le dará 4 funciones de este tipo que "aparentemente" operan en paralelo y le dará la sensación de que tiene 4 funciones principales en su programa. Cuando sea bueno con el parpadeo de 4 LED en paralelo, simplemente puede completar el código y hacer lo que quiera.

Descargas
Para comenzar a escribir nuestra primera aplicación, las cosas que necesita descargar son:
Sería recomendable navegar por el sitio web de OSA y estudiar su documentación. Está muy bien escrito, algo que no esperará para la mayoría de los softwares de código abierto. ¡Me encantó!.

Paso uno:

Cree una nueva carpeta y extraiga el archivo zip OSA allí. Ejecute MikroC pro y cree un proyecto. Seleccione la misma carpeta donde extrajo OSA. OSA funciona para la mayoría de los microcontroladores, pero preferiría ir con 18F452, tiene una memoria razonable para nuestro trabajo. Utilice un cristal de 8 a 12Mhz.



¿Por qué estoy seleccionando un cristal de baja frecuencia ?, después de todo, no estoy planeando ninguna misericordia con esta pequeña criatura. Tiene razón, no hay piedad hoy, usaremos un cristal de 12Mhz y permitiremos que PLL use nuestro microcontrolador a 48Mhz, ese es el otro nombre de tortura, pero nos da un contexto extremadamente pequeño para el cambio de sobrecarga y el rendimiento supremo.



Ahora necesitamos agregar los archivos del sistema operativo a nuestro proyecto. Haga clic en Agregar y seleccione los archivos osa.h y osa.c


Haga clic en siguiente e incluya todas las bibliotecas, luego seleccione la configuración abierta para el proyecto y seleccione el oscilador como oscilador HS con PLL habilitado.


Ahora, volvemos a escribir código. Guarda el proyecto. Abra el archivo OSAcfg_Tool.exe y seleccione las siguientes opciones. Establezca Tareas en 4 porque tendremos 4 subprocesos en nuestra aplicación, seleccione la configuración como se muestra cuando haya terminado, haga clic en Guardar y guarde el archivo de configuración en la carpeta con su proyecto actual.



El archivo OSAcfg.h guardado requiere que se agregue al proyecto. En MikroC, con su proyecto abierto, vaya al menú Proyecto y agregue el archivo OSAcfg.h al proyecto (si no lo hace, se producirá un error).

Configurando el temporizador:

No voy a ser muy técnico y discutiré brevemente por qué un programa RTOS requiere configurar un temporizador. Todos los RTOS necesitan mantener un sentido del tiempo físico. Entonces, en todo momento, el Kernel sabría qué hora es y, con base en esta información, generará retrasos precisos y programará llamadas a funciones. En palabras simples, no puedes seguir tu rutina diaria sin tener un sentido del tiempo. Sabes que hay temporizadores dentro de PIC que te permiten contar el tiempo. Pero el reloj de nuestro sistema operativo funciona mucho más lento que el temporizador. Por lo tanto, incrementaríamos el reloj del sistema operativo un TICK cada vez que el temporizador se desborda.

 Estoy planeando tener una garrapata cada 1 ms. Esto significa algo, mi aplicación no podrá medir en ningún momento menos de 1 ms, no podrá llamar a retrasos menores a 1 ms, esto generalmente está bien si ninguno de los hilos requiere un retraso de tiempo inferior a 1 ms. La selección de un período de tiempo más largo para marcar tiene la ventaja de que su controlador pasará menos tiempo en el servicio de la rutina del servicio de interrupción por desbordamiento del temporizador y más tiempo en hacer lo que se supone que debe hacer.

Sí, olvidaste los prescalers, los registros de configuración y esas cosas que estudiaste en clase, los odié porque hay programas hechos para recordar esas cosas. Inicie la calculadora temporizador. Sabe todo lo que olvidaste :).


La utilidad de temporizador genera ajustes precisos para su temporizador. Genera una función InitTimer0 que llamaría al inicio del programa para configurar el temporizador. Copia ambas funciones a tu proyecto.

En su función principal, inserte una llamada a InitTimer0. Al inicio del proyecto, inculque los encabezados del SO utilizando la   directiva #include <osa.h> . Para incrementar el reloj en cada desbordamiento del temporizador, inserte una llamada a OS_Timer () en la rutina de servicio de interrupción. Así que tu código debería tener un aspecto como este a estas alturas:



Ahora necesitamos agregar los subprocesos y ejecutar el planificador para completar el programa. Para definir una tarea a la que llamaría el programador, se define de la siguiente manera:



Debería poder comprender la importancia de las funciones OS_Yeild y OS_Delay (). En su programa RTOS, OS_Delay es solo una contraparte muy eficiente de Delay_ms que ha estado usando antes. Delay_ms es una forma muy ineficiente de perder el tiempo del procesador simplemente atándolo en un bucle inútil. Cuando llama a OS_Delay, en lugar de perder el tiempo en algunas instrucciones ficticias, el programa atenderá otros subprocesos. Esto debería ayudarlo a ver el beneficio de emplear un RTOS en su aplicación. Pero recuerde, un subproceso de programa RTOS que nunca cede ni retrasa las llamadas nunca permitirá otros subprocesos en el procesador. Por lo tanto, siempre debe llamar a OS_Yeild a menudo en sus hilos para que se haga justicia a todos los hilos. El programador decidirá en función de la prioridad de cada subproceso, quién obtiene qué porcentaje del tiempo total.

Los desarrolladores de RTOS generalmente alientan el uso de variables globales. Particularmente porque durante el cambio de contexto, las variables locales deben conservarse en la memoria. de modo que cuando todos los subprocesos se ejecutan en paralelo, todas las variables locales existen en la memoria al mismo tiempo. Por lo tanto, tener variables locales apenas tiene un beneficio. Pero en caso de que permita alguna optimización de memoria en su código, recuerde usar el identificador 'estático' con las declaraciones de variables locales.

Al igual que en un subproceso definido anteriormente, puede definir cualquier número de subprocesos siempre que haya informado al sistema operativo sobre ellos al crear el archivo de configuración.
El último paso es crear los hilos y llamar al programador del sistema operativo desde la función principal.


Eso es todo !!, simplemente complete las tareas respectivas con el código que le guste y tendrá OSA ejecutándose con 4 subprocesos paralelos en su programa. OSA es potente y un sistema operativo bien desarrollado, las rutinas que he discutido son las cruciales y por lo general serían suficientes para los programas estándar. Sin embargo, debe explorar todos sus servicios en su documentación.

El ejemplo completo descrito anteriormente está disponible para su descarga en el siguiente enlace, que incluye una simulación de cómo funciona en su microcontrolador. El archivo comprimido también contiene la utilidad de temporizador, la herramienta de generación de archivos de configuración OSA y la documentación de OSA.



Créditos al Dr. Jahangir Ikram y a mis compañeros miembros del equipo en LUMS por los incalculables debates y discusiones sobre temas técnicos.

Pagina original con el articulo en ingles:
http://noumanqaiser.blogspot.com/2014/03/rtos-in-pic-microcontrollers-devil.html