Envío Gratis en compras mínimas de $1200 mxn Enviamos a toda la Republica Mexicana
Buscar

1. Puertos GPIO

Bienvenidos, el objetivo de este primer tutorial será mostrar cómo se configuran los pines de entradas y salidas de la tarjeta de desarrollo Ophya, por lo que realizaremos un pequeño ejemplo utilizando los recursos propios de Ophyra para mostrarles cómo se configuran.

Proyecto a realizar: Al presionar un botón, el color azul en el LED RGB de Ophyra se encenderá por un segundo.

Configurando el hardware

Una vez ya creado nuestro proyecto (véase el tutorial preliminar de Crear un Proyecto para Ophyra), el siguiente paso es activar los recursos a utilizar.

Paso 1. Para conocer los pines que corresponden al LED RGB y a los Push Button, nos dirijimos al Manual de Ophyra En las secciones “13. Pulsadores” y “14. LED-RGB” encontraremos las tablas que nos indican los pines correspondientes. De igual manera, las tablas son las que se muestran a continuación.

Imagen 1. Pines de los Push Button
Imagen 2. Pines del LED RGB

En este tutorial vamos a utilizar el botón SW0 y el color azul del LED RGB, por los que los pines que configuraremos son:

  • SW0 → PC2
  • LED Azul → PE2

Paso 2. Ahora buscaremos el pin correspondiente al PC2 en el diagrama del microcontrolador. Hacemos clic sobre el pin y seleccionamos la opción GPIO Input (Imagen 3) debido a que este pin es el correspondiente a nuestro botón, siendo éste una entrada.

Imagen 3. Configuración del pin PC2 para SW0

Posteriormente, para poder ubicarlo con facilidad, le colocaremos la etiqueta “Boton_SW0”. Para ello, le haremos clic derecho sobre el pin y seleccionamos la opción Enter User Label (Imagen 4). Se desplegará un espacio en el que podremos colocar el nombre “Boton_SW0” (Imagen 5) y damos clic a la tecla Enter y se habrá colocado el nombre en nuestro pin, tal como se muestra en la Imagen 6.

Imagen 4. Etiquetando el pin PC2
Imagen 5. Se escribe el nombre de la etiqueta.
Imagen 6. Pin etiquetado y configurado como entrada.

Paso 3. Ahora es momento de pasar a elegir nuestro pin digital de salida: el color azul del LED RGB integrado en la tarjeta Ophyra.

Siguiendo las mismas instrucciones como en el paso anterior, ahora buscaremos el pin PE2, se le eligirá la opción GPIO Output, y finalmente se le agrega la etiqueta “Led_Azul”, tal y como se muestra en la siguiente imagen.

Imagen 7. Pin PE2 configurado y etiquetado.

Paso 4. Una vez elegidos los pines correspondientes como entradas y salidas, en las categorías del lado izquierdo de la interfaz, se abre System Core → GPIO (Imagen 8).

Imagen 8. Acceso a configurar los GPIO.

Ahora se configurarán los pines de la siguiente manera:

Pin PC2 (pin correspondiente al Botón SW0):

  • En GPIO Mode ya estará seleccionada la opción de Input Mode, ya que se le había indicado previamente que funcionaría como entrada.
  • En GPIO Pull-up/Pull-down, se seleccionará la opción Pull-up, tal y como se recomendaba en las notas de la tabla del Manual de Ophyra (ver Imagen 1).
  • En cuanto al User Label, éste ya está escrito con la etiqueta “Boton_SW0” debido al Paso 2.
Imagen 9. Configuración del pin PC2

Pin PE2 (pin correspondiente al Led Azul):

  • En GPIO output level seleccionamos High, debido a que el color del LED RGB se encuentra conectado como ánodo común, por lo tanto en estado High lo estaríamos apagando, mientras que en Low estaría encendido. Así entonces, se está configurando el LED para que esté apagado al arrancar el programa.
  • En GPIO mode seleccionamos Output Open Drain, tal como se recomienda en las notas de la tabla del Manual de Ophyra (ver Imagen 2).
  • En GPIO Pull-up/Pull-down dejamos la opción predeterminada de No Pull-up and no pull-down, debido a que no es necesario habilitar ninguna de estas resistencias del microcontrolador, pues el pin solo se utilizará como salida.
  • El apartado de User Label ya también tendrá escrita la etiqueta de “Led_Azul” por haberlo escrito en el Paso 3.
Imagen 10. Configuración del pin PE2

Paso 5. Ahora es momento de generar nuestro código.


ADVERTENCIA

Si durante la creación de tu proyecto no llegaste a configurar el reloj de la tarjeta o a configurar los detalles del proyecto respecto a la generación del código, aún estás a tiempo.

Para sabér cómo hacer esas configuraciones, dirígase al tutorial preliminar de Crear un Proyecto para Ophyra y siga los pasos en Anexo 1: Configurar el reloj de la OphyraAnexo 2: Configurar los detalles el proyecto.


Para generar el código, basta con hacer clic en el botón de Guardar que se encuentra en la barra de herramientas en la parte superior. La interfaz cambiará y comenzará a cargar el código, así como se muestra en la siguiente imagen.

Imagen 11. Generando código.

Realizando el programa

Una vez teniendo nuestro código base generado, podemos visualizar lo siguiente:

  • Primero hay una sección de Includes (que comienza en la línea 20), el cual contiene todos los archivos de cabecera con las bibliotecas para nuestro microcontrolador.
  • Luego encontramos la sección de los prototipos de funciones privadas (que comienza en la línea 48), el cual contiene las funciones ya declaradas según las configuraciones y recursos que hayamos activado para nuestro microcontrolador. En nuestro caso tenemos dos:
    • void SystemClock_Condig(void); es una función que contiene las configuraciones respectivas del reloj con el que se trabajará.
    • static void MX_GPIO_Init(void); es la función que contendrá las configuraciones realizadas anteriormente a los pines de entrada y salida de nuestro microcontrolador.
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
  • Posteriormente, podemos encontrar la sección de nuestra función principal (iniciando en la línea 64), donde comenzaremos a generar nuestro código. Dentro de la función main podemos observar que se llaman las funciones de inicialización:
    • HAL_Init(); es la función que reinicia la interfaz flash.
    • SystemClock_Config(); inicia las configuraciones del reloj.
    • MX_GPIO_Init(); configura los pines de entrada y salida.
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */

En la línea 94 encontramos un “while infinito”, que como sabemos todo lo que escribamos dentro será ejecutado todo el tiempo. El código que escribiremos estará dentro del while infinito de la siguiente manera:

Paso 1. En la línea 99 definimos una variable entera llamada m, a la cual le vamos asignar el valor del pin de entrada, es decir el valor de nuestro estado del botón, para lo cual haremos uso de la función:

HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)

Esta función se encarga de leer el estado del pin indicado, devolviendo un 1 si se encuentra en “HIGH” o “SET” y devuelve un 0 si el estado del pin es “LOW” o “RESET”.

Dentro de los parámetros que se deben indicar se encuentra el puerto en el que se encuentra el pin de entrada (GPIO_TypeDef* GPIOx) y enseguida se escribe el pin configurado como entrada (uint16_t GPIO_Pin). En nuestro caso, la función quedaría de la siguiente manera:

HAL_GPIO_ReadPin(Boton_SW0_GPIO_Port, Boton_SW0_Pin);

while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
      int m = HAL_GPIO_ReadPin(Boton_SW0_GPIO_Port, Boton_SW0_Pin);
  }

Paso 2. Escribir nuestro código dentro del while infinito significa que todo el tiempo estará leyendo el estado del pin de entrada, por lo tanto agregaremos una condicional if, en el cual si el estado del botón está en “RESET” (cuando el botón esté pulsado) el LED azul se encenderá por un segundo y posteriormente se apaga.

while (1)
{
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */
    int m = HAL_GPIO_ReadPin(Boton_SW0_GPIO_Port, Boton_SW0_Pin);
    if (m == RESET) {

    }
}

Paso 3. Para poder colocar un estado a un pin de salida, se hará uso de la función:

HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState PinState)

Es necesario indicar un estado de “SET” o “RESET” a nuestros pines de salida digitales, es decir, se le indica un estado “ALTO” o “BAJO”, “ENCENDIDO” o “APAGADO”.

Los parámetros necesarios para el uso de esta función son:

  • GPIO_TypeDef* GPIOx refiere al puerto donde se encuentra el pin declarado como salida.
  • uint16_t GPIO_Pin es el nombre del pin declarado como salida digital.
  • GPIO_PinState PinState es el estado que se requiere para ese pin.

Por lo tanto, para encender el pin definiremos nuestra función de la siguiente manera:

HAL_GPIO_WritePin(Led_Azul_GPIO_Port, Led_Azul_Pin, RESET);

Para poder indicarle el tiempo que permanecerá encendido se usa la función HAL_Delay(uint32_t Delay), la cual genera un retardo en milisegundos. Para que nuestro LED permanezca encendido por un segundo colocaremos nuestra función de retraso de la siguiente manera:

HAL_Delay(1000);

Finalmente apagaremos nuestro LED cambiando su estado. Si para encenderlo se le indicó un “RESET”, ahora es necesario colocarle un “SET”, de esta manera:

HAL_GPIO_WritePin(Led_Azul_GPIO_Port, Led_Azul_Pin, SET);

while (1)
{
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */
    int m = HAL_GPIO_ReadPin(Boton_SW0_GPIO_Port, Boton_SW0_Pin);
    if (m == RESET) {
        HAL_GPIO_WritePin(Led_Azul_GPIO_Port, Led_Azul_Pin, RESET);
        HAL_Delay(1000);
        HAL_GPIO_WritePin(Led_Azul_GPIO_Port, Led_Azul_Pin, SET);
    }
}

Paso final – Cargar el programa a la Ophyra

Ahora, falta programar nuestro código a la tarjeta Ophyra. Las instrucciones se encuentran en el tutorial del Paso final – Cargar el programa a la Ophyra.

ANEXO: Ver el código de configuración

Si seguimos bajando en el código, podremos encontrar la función que contiene la configuración del reloj, así como la configuración de nuestros pines de entrada y salida.

void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 5;
  RCC_OscInitStruct.PLL.PLLN = 210;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV4;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(Led_Azul_GPIO_Port, Led_Azul_Pin, GPIO_PIN_SET);

  /*Configure GPIO pin : Led_Azul_Pin */
  GPIO_InitStruct.Pin = Led_Azul_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(Led_Azul_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : Boton_SW0_Pin */
  GPIO_InitStruct.Pin = Boton_SW0_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(Boton_SW0_GPIO_Port, &GPIO_InitStruct);

}

En estas funciones no se debería nunca realizar algún cambio. En caso de necesitar cambiarle algo, se debe uno regresar a la interfaz de configuración del microcontrolador y realizar los cambios desde esa sección (para hacerlo basta con hacer doble clic en el archivo con extensión “.ioc” ubicado en la carpeta principal del proyecto  en el explorador de proyectos del lado izquierdo). Al volver a generar guardar el proyecto, los cambios se verán reflejados en el código.

Resultados

En el siguiente GIF, podrás observar que al presionar el primer botón de la Ophyra (el SW0), el color azul del LED RGB se enciende por un segundo y luego se vuelve a apagar.

Conclusiones

Hemos configurado y programado los recursos básicos de Ophyra: el LED RGB y un Push Button. Además, al seguir el tutorial, te podrás dar cuenta de la estrategia de diseño en Ophyra:

  1. Crear la configuración inicial de los recursos tras crear un proyecto.
  2. Guardar la configuración y generar el código base.
  3. Escribir el código para nuestra aplicación.
  4. Programar la Ophyra.
  5. Observar el resultado y regresar al paso 3 (o 1 en caso de necesitar agregar, modificar o quitar recursos al proyecto).

Te sugerimos continuar con el siguiente ejercicio: 2. Timers (Temporizadores) para seguir adquiriendo experiencia manejando los recursos básicos de la Ophyra.

rolex air king replica