Universidad Tecnológica de Querétaro
Tarea 3
LAB3
Asignatura:
DDP
Nombre del profesor:
José Felipe Aguilar Pereyra
Grupo: ITA58
Presenta:
Campos Ramírez Juan Carlos – 2019348182
Santiago de Querétaro, Qro. Septiembre 2022
Contenido
Objetivo de la práctica: ...................................................................................................... 3
Fundamento Teórico: ......................................................................................................... 4
Planteamiento del problema ............................................................................................ 12
Materiales ........................................................................................................................ 13
Requisitos del Cliente: ..................................................................................................... 14
Diagrama de bloques ....................................................................................................... 15
Asignación de terminales ................................................................................................. 16
Diagrama electrónico ....................................................................................................... 17
Diagrama de flujo............................................................................................................. 18
Código desarrollado ......................................................................................................... 19
Pruebas ........................................................................................................................... 22
Resultados....................................................................................................................... 24
Bibliografía ....................................................................................................................... 26
Objetivo de la práctica:
En esta práctica de laboratorio, aprenderemos cómo inicializar el sistema de reloj y el
periférico GPIO mediante TivaWare.
archivos de cabecera.
Luego usaremos la salida GPIO para hacer parpadear un LED y leer la entrada GPIO para
SW1 y SW2 en la placa de evaluación.
Fundamento Teórico:
Estándares de programación ISO/IEC 9899:1999 (o C99) C
El estándar internacional ISO 9899, fue creado por ISO (Organización Internacional de
Normalización) con el objetivo de promover la portabilidad de los programas en C en varios
sistemas de procesamiento de datos. Está direccionado a la utilización de los ejecutores y los
programadores.
Este estándar determina la forma en la cual se interpreta los programas en el lenguaje de
programación C en los siguientes apartados:
La representación de programas escritos en C.
La sintaxis y restricciones de C.
Las reglas semánticas para interpretar programas en C.
La representación de los datos de salida resultantes de programas de C.
Las restricciones y limitaciones impuestas de acuerdo a la implementación de C.
Este estándar Internacional no determina:
El mecanismo mediante los programas de C son transformados por un sistema de
procesamiento de datos.
El mecanismo mediante los programas de C son invocados por un sistema de
procesamiento de datos.
El mecanismo por el cual los datos son transformados para su uso en programas de
C.
El mecanismo por el cual los datos son transformados tras haber sido producidos
por un programa de C.
El tamaño o la complejidad de un programa y sus datos que excederán la capacidad
de cualquier sistema de procesamiento de datos específico o la capacidad de un
procesador particular.
Todos los requisitos mínimos de un sistema de procesamiento de datos que sea
capaz de soportar implementación conforme.
Una implementación traduce los archivos fuente C y ejecuta programas en C en dos
entornos del sistema de procesamiento de datos, que se denominarán entorno de
traducción y ejecución en este estándar internacional.
Sus características definen y restringen los resultados de ejecutar programas escritos en C
de acuerdo con las reglas sintácticas y semánticas para implementaciones.
Modelos conceptuales
Entorno de traducción
Estructura del programa
No es necesario que todos los programas C se traduzcan al mismo tiempo. Se guarda el
texto del programa en unidades llamadas archivos de origen o archivos de
preprocesamiento.
Se conoce como unidad de traducción de preprocesamiento al archivo fuente que contiene
los encabezados y los archivos fuentes incluidos mediante la directiva de
preprocesamiento #include .
La unidad de traducción de preprocesamiento se denomina unidad de traducción.
Las unidades de traducción que han sido traducidas previamente se pueden conservar de
forma individual o en bibliotecas.
Las unidades de traducción separadas de un programa se comunican entre sí mediante las
llamadas a funciones cuyos identificadores tienen enlace externo, manipulación de objetos
cuyo identificadores tienen enlaces enlaces externos o archivos de datos.
Las unidades de traducción se pueden traducir por separado y luego vincularse para dar
lugar a un programa ejecutable.
Fases de traducción
1. Los caracteres multibyte del archivo de origen físico se asignan al conjunto de caracteres
de origen si es necesario.
2. Cada instancia de un carácter de barra diagonal inversa (\) seguido inmediatamente por
una nueva línea de carácter se elimina, uniendo las líneas de origen físico para formar
líneas de origen lógico.
3. El archivo fuente se descompone en tokens de preprocesamiento y secuencias de
caracteres de espacio en blanco. Un archivo fuente no debe terminar en un token de
preprocesamiento parcial o en un comentario parcial. Cada comentario será reemplazado
por un carácter espacial.
4. Las directivas de preprocesamiento se ejecutan, las macroinvocaciones se expanden y
las expresiones del operador _Pragma se ejecutan. Si coincide una secuencia de
caracteres con la sintaxis de un nombre de carácter universal producido por un token de
concatenación, el comportamiento es indefinido.
Una directiva de procesamiento de #include hace que el encabezado o el archivo fuente
se procesen desde la fase 1 mediante la 4 recursivamente, las directivas de
preprocesamiento se eliminan.
5. Cada miembro del conjunto de caracteres de origen y secuencia de escape en constantes
de caracteres y las cadenas se convierten en el miembro del conjunto de caracteres de
ejecución correspondiente. Si no hay un miembro correspondiente, se convierte en uno
definido por la implementación que no sea nulo.
6. Los tokens literales de cadena adyacentes se concatenan.
7. Los caracteres de espacios en blanco que separan los tokens ya no son significativos.
Todo token de preprocesamiento es un token, y estos token resultantes son analizados
sintácticamente y semánticamente y traducido como unidad de traducción.
8. Se resuelven todas las referencias externas de objetos y funciones. Los componentes de
la biblioteca son vinculados para satisfacer las referencias externas a funciones y objetos
no definidos en la traducción actual. Todos los resultados de la traducción se recopilan en
una imagen del programa que contiene la información necesaria para la ejecución en su
entorno de ejecución.
Diagnósticos
Cada implementación producirá al menos un mensaje de diagnóstico, si una unidad de
traducción o de traducción de preprocesamiento contiene una violación de cualquier regla
o restricción de sintaxis o incluso de comportamiento será especificado como indefinido o
como implementación definida. Los mensajes de diagnóstico no necesitan ser producidas
en ninguna otra circunstancia.
Entorno de ejecución
Hay dos tipos: Independientes y Alojados. En ambos casos, se da el inicio del programa
cuando la ejecución llama a una función C designada al entorno de ejecución. Todo objeto
con almacenamiento estático se inicializará antes del inicio del programa. La terminación
del programa devuelve el control al entorno de ejecución.
Entorno Independiente
El nombre y tipo de función llamada en el inicio del programa son definidas por la
implementación. Cualquier biblioteca disponible para un programa independiente son
definidas por la implementación, al igual que los efectos de la finalización del programa en
un entorno independiente.
Entorno Alojado
No es necesario pero tienen que cumplir con lo siguiente:
Inicio del programa en Entorno Alojado
La función llamada al inicio del programa se llama main , se declara con un tipo int y sin
parámetros o con dos parámetros ( argc y argv ).
Ejecución del programa en Entorno Alojado
Un programa puede usar todas las macros, funciones,definiciones de tipo y objetos
descritos en la cláusula de la biblioteca.
Terminación del programa en Entorno Alojado
Si el tipo de retorno de la función main es un tipo compatible con int , un retorno de la
llamada inicial a la función main es equivalente a llamar a la función de salida con el valor
devuelto por la función main como argumento, devuelve 0. Si no es compatible el estado
de terminación devuelto al entorno no está especificado.
Ejecución del Programa
Las descripciones semánticas en esta Norma Internacional describen el comportamiento
de una máquina abstracta en la que los problemas de optimización son irrelevantes.
Acceder a un objeto volátil, modificar un objeto, modificar un archivo o llamar a una función
que realice cualquiera de esas operaciones son todos efectos secundarios, que son
cambios en el estado del entorno de ejecución. La evaluación de una expresión puede
producir efectos secundarios. En ciertos puntos especificados en la secuencia de ejecución
llamados puntos de secuencia, todos los efectos secundarios de las evaluaciones
anteriores deberán estar completos y no se habrá producido ningún efecto secundario de
las evaluaciones posteriores.
En la máquina abstracta, todas las expresiones se evalúan según lo especificado por la
semántica. Una implementación real no necesita evaluar parte de una expresión si puede
deducir que su valor no se usa y que no se producen los efectos secundarios necesarios
(incluidos los causados por llamar a una función o acceder a un objeto volátil).
Cuando el procesamiento de la máquina abstracta se interrumpe al recibir una señal, solo
se puede confiar en los valores de los objetos a partir del punto de secuencia anterior. Los
objetos que pueden modificarse entre el punto de secuencia anterior y el siguiente punto
de secuencia aún han podido no recibir sus valores correctos.
Los requisitos mínimos en una implementación conforme son:
En los puntos de secuencia, los objetos volátiles son estables en el sentido de que los
accesos anteriores están completos y los accesos posteriores aún no se han producido.
Al finalizar el programa, todos los datos escritos en los archivos serán idénticos al resultado
que habría producido la ejecución del programa de acuerdo con la semántica abstracta.
La intención de estos requisitos es que la salida sin búfer o con búfer de línea aparezca lo
antes posible, para garantizar que los mensajes de solicitud realmente aparezcan antes de
que un programa espere entrada.
Lo que constituye un dispositivo interactivo está definido por la implementación.
Cada implementación puede definir correspondencias más estrictas entre la semántica
abstracta y la real.
Consideraciones
Conjunto de caracteres
Se definirán dos conjuntos de caracteres y sus secuencias de clasificación asociadas, cada
conjunto se divide además en un conjunto de caracteres básicos, cuyo contenido viene
dado por esta subcláusula, y un conjunto de cero o más caracteres específicos de la
localidad (que no son miembros del conjunto de caracteres básico) llamados caracteres
extendidos El conjunto combinado también se denomina conjunto de caracteres extendido.
Los valores de los miembros del juego de caracteres de ejecución están definidos por la
implementación En una constante de caracteres o cadena, los miembros del conjunto de
caracteres de ejecución serán representado por los miembros correspondientes del
conjunto de caracteres de origen o por un escape secuencias que consisten en la barra
invertida seguida de uno o más caracteres. Un byte con todos los bits establecidos en 0,
llamados caracteres nulos, existirán en el conjunto de caracteres de ejecución básica; eso
se usa para terminar una cadena de caracteres.
Semántica de visualización de caracteres
La posición activa es esa localización en un dispositivo de visualización donde aparecerá
el carácter de salida colocado por la función fputc .
El hecho de imprimir un carácter en un dispositivo de visualización es mostrar una
representación gráfica de dicho carácter en la posición activa y luego avanzar a la siguiente
posición de la línea.
Si la posición activa se encuentra al final, el comportamiento del dispositivo no se especifica.
Las secuencias de escape alfabéticas que representan caracteres no gráficos en el
conjunto de caracteres de ejecución están destinadas a producir acciones en dispositivos
de visualización de la siguiente manera:
Tipo de variable para estándares de programación C
El primer objetivo de un programa informático es el manejo de datos. Un dato es toda
aquella información que se puede tratar en un programa informático.
Un dato dentro de un programa se caracteriza por llevar asociado un identificador, un tipo
y un valor.
Identificador: Nombre para referenciar al dato dentro del programa
Tipo: el tipo de un dato determina el rango de valores que puede tomar el dato y su
ocupación en memoria durante la ejecución del programa
Valor: Sera un elemento determinado dentro del rango de valores permitidos por el
tipo de dato definido.
Algunos ejemplos de datos son: la edad, el saldo de una cuenta bancaria, el nombre de una
persona, la letra del piso de una dirección, etc.
A continuación, vamos a describir los distintos tipos de datos que existen.
TIPOS DE DATOS
Hay dos clases de tipos de datos: tipos fundamentales y tipos derivados.
Únicamente vamos a ver los tipos de datos fundamentales.
Tipo entero: representa números enteros con o sin signo, que estarán compuestos por los
dígitos del 0 al 9, pudiendo ser precedidos por los signos + o -.
Algunos ejemplos de datos enteros son: 0, 23, -176, -1, etc.
Para definir variables en C se antepone la palabra reservada del tipo al identificador de la
variable. El tipo de datos entero se define en el lenguaje de programación C por la palabra
reservada int.
Para definir un tipo de dato en C se escribe lo siguiente:
int nombre_variable = valor;
No es necesario que la variable tenga un valor predeterminado. Se puede definir sin
asignarle ningún valor.
Procedimiento de configuración del reloj del sistema.
1.- se declara la librería quenos ayudara a dar la configuración del reloj del microcontrolador
2.- dentro del void main configuraremos nuestro reloj de la siguiente manera
SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN)
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
Configuración GPIO.
Se declarara el puerto F como GENERALPROPUSE INPUT OUTPUT con el siguiente
segmento de código
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
Configuración de salida.
Se declararan los pines 1,2,3 del puerto F como output el cual declararemos como
GENERALPROPUSE INPUT OUTPUT con el siguiente segmento de código
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
Configuración de entrada.
Se declaran los pines 4 y 0 como entradas con el siguiente segmento de código
GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_DIR_MODE_IN);
Planteamiento del problema
1. Lectura del Workbook sección Code Composer Studio
2. Creación de un nuevo proyecto CCS Laboratory3
3. Configurar el reloj del sistema de control
4. Configurar las E/S a utilizar
5. Construir, cargar y ejecutar el programa.
6. Incluir las funciones de configuración de periféricos y activar led RGB
7. Construir, cargar y ejecutar el programa.
Materiales
Tiva C Series TM4C123G Evaluation Kit
PC con Code Composer Studio y Tivaware
Requisitos del Cliente:
A partir del código del Lab2,
Crear la variable uiCounter,
Leer las entradas correspondientes a los interruptores SW1 y SW2,
Controlar en incremento y decremento del valor de la variable uiCounter dentro del intervalo
establecido a partir del accionamiento
de los interruptores SW1 y SW2.
Diagrama de bloques
Asignación de terminales
Diagrama electrónico
Diagrama de flujo
Para este planteamiento del problema primero fue necesario generar el algoritmo que
queríamos expresar en el code composer studio, a lo que la mejor forma de comenzar a
generar el pseudo código fue con un diagrama de flujo
Código desarrollado
Finalmente el código que se realizo fue el siguiente
/* Documentación del Proyecto
@Compañía
Universidad Tecnológica de Querétaro
@Nombre del proyecto
Laboratorio3
@Nombre del archivo
C Principal
@Autor Campos Ramírez Juan Carlos
@Resumen
Este es el main.c generado usando TM4C123G MCU.
@Descripción
Este archivo fuente inicializa el sistema de reloj y el periférico GPIO usando
TivaWare. Luego usaremos la salida GPIO para hacer parpadear un LED en la placa
de evaluación.
Información de generación:
Revisión del producto: TM4C123GXL - 1.168.0
Dispositivo: TM4C123GH6PM7
Los controladores generados se prueban con lo siguiente:
Idioma: Modo C ANSI C 89
Compilador: TIv16.9.6LTS
CCS: CCS v7.4.0.00015
*/
/*
(c) 2020 Campos Ramírez Juan Carlos. Puedes usar esto software y cualquier derivado
exclusivamente con productos de Texas Instruments.
ESTE SOFTWARE ES SUMINISTRADO POR Campos Ramirez Juan Carlos "TAL CUAL". SIN
GARANTÍAS, YA SEAEXPRESA, IMPLÍCITA O LEGAL, SE APLICAN A ESTE SOFTWARE, INCLUYENDO
CUALQUIER GARANTÍAS DE NO VIOLACIÓN, COMERCIABILIDAD E IDONEIDAD PARA UN PROPÓSITO
PARTICULAR, O SU INTERACCIÓN CON PRODUCTOS DE TEXAS INSTRUMENTS, COMBINACIÓN CON
CUALQUIER OTRO PRODUCTO O USO EN CUALQUIER APLICACIÓN Campos Ramirez Juan Carlos
PROPORCIONA ESTE SOFTWARE CONDICIONALMENTE A SU ACEPTACIÓN DE ESTOSTÉRMINOS.
#include <stdint.h> // Variable definitions for the C99 standard
#include <stdbool.h> // Booleans definitions for the C99 standard
#include "inc/hw_types.h" // Define common types and macros
#include "inc/hw_memmap.h" // Macros define the memory map of tiva
#include "driverlib/sysctl.h" // Defines and macros for System Control API of
Driverlib
#include "driverlib/gpio.h" // Define and macros for GPIO API of Driverlib.
//new
#include "driverlib/pin_map.h" //Definitions Pin Maps
#include "inc/hw_gpio.h" //Hardware GPIO
int main(void)
{
//Declaration of variables
uint8_t ui8LED = 2; // Declaration uint8_t as Unsigned 8 bits variable
int8_t ui8Counter = 0;
//configuration of clock
SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN)
; // Configure the system clock to run usinga 16MHz Crystal
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
// Enable the F port
GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
// Configure PF1,PF2,PF3 as GPIO Outputs
//unlock PF4
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; //Unlock The GPIO
Comit Register, PF4
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01; //Unlock The GPIO
Comit Register, PF4
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0; //Unlock The GPIO
Comit Register, PF4
GPIODirModeSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_DIR_MODE_IN);
//Configure PF1 & PF4 as input
GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4|GPIO_PIN_0, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU); //Configure PF0 &PF4, intensity 2mA, Enable Pull Up
Resistor
//while
start///////////////////////////////////////////////////////////////////////////
////////////////////////
while(1)
{
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, ui8LED);
/// we define the pins that we are going to use and we asigned a ui8LED value
SysCtlDelay(2000000);
/// Delay
if (ui8LED==8){ui8LED=2;} else {ui8LED=ui8LED*2;}
if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4)==0x00)//si (el valor de
la lectura de pf4 es igual a cero) SW1 esta habilitado
{
ui8Counter--; //Decremente counter
if (ui8Counter < 0) //If the variable is lost
that cero
{
ui8Counter = 0; //asing the valor of the
variable in cero
}
}
if(GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0x00)
{
ui8Counter++;
if (ui8Counter > 10)
{
ui8Counter = 10;
}
}
}
Pruebas
Las pruebas implementadas constaron de ser meramente visuales ya que en una ventana
de nuestro software pudimos ver como el contador del espacio de los leds realizaba una
cuenta para poder restablecer los colores de los leds mientras que el contador solo
cambiaba cundo este era presionado de manera incremental siempre y cuando este fuera
menor a 8 y de manera decremento cuando este fuera mayor a 0
Resultados
Los resultados en la placa tiva fueron los mismos que en las practicas anteriores ya que no
hubo ningún cambio en el aspecto visual o algún tipo de combinación con el led rgb
Bibliografía
Texas Instruments. (2013). Getting Started with the Tiva™
