#include "srv_cpu.h"
#include "srv_timer.h"
#include "srv_debug.h"
#include "conf_build.h"

void sistema_iniciar(void)
{
  cpu_iniciar();
  timer_iniciar();
  debug_iniciar();
  DEBUG("Hello, %s!\n", "HDL");

}

void sistema_controle(void)
{
  cpu_controle();
  timer_controle();
}

int main(void)
{
  sistema_iniciar();
  while(1){
    sistema_controle();
  }
  return 0;
}







main.c

diagram.json

#include "srv_cpu.h"
#include "drv_cpu.h"
#include <stdint.h>

int8_t cpu_status;
int16_t cpu_tempo;


void cpu_iniciar(void)
{
  drv_cpu_iniciar();
}


void cpu_controle(void)
{
  drv_cpu_controle();

}

srv_cpu.c

#ifndef SRV_CPU_H
#define SRV_CPU_H
#include "conf_build.h"



void cpu_iniciar(void);
void cpu_controle(void);


#endif

srv_cpu.h

#include "drv_cpu.h"
#include "drv_gpio.h"
#include <stm32c0xx_hal.h>


void SystemClock_Config(void);

void drv_cpu_iniciar(void)
{
  HAL_Init();
  SystemClock_Config();
  drv_gpio_iniciar();
}

void drv_cpu_controle(void)
{
  // 1 Hz blinking:
  if ((HAL_GetTick() % 2000) < 1800){
    drv_cpu_liga_led();
  }
  else{
    drv_cpu_desliga_led();
  }
}

void drv_cpu_liga_led(void)
{
  HAL_GPIO_WritePin(LED_PORT, LED_PIN,1);
}

void drv_cpu_desliga_led(void)
{
  HAL_GPIO_WritePin(LED_PORT, LED_PIN,0);
}

/**
    @brief System Clock Configuration
    @retval None
*/
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
    in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  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_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV1;

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



drv_cpu.c

#ifndef DRV_CPU_H
#define DRV_CPU_H
#include "conf_build.h"


void drv_cpu_iniciar(void);
void drv_cpu_controle(void);
void drv_cpu_liga_led(void);
void drv_cpu_desliga_led(void);

#endif

drv_cpu.h

#include "drv_gpio.h"
#include <stm32c0xx_hal.h>



void drv_gpio_iniciar()
{
  GPIO_InitTypeDef GPIO_Config;

  GPIO_Config.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_Config.Pull = GPIO_NOPULL;
  GPIO_Config.Speed = GPIO_SPEED_FREQ_HIGH;

  GPIO_Config.Pin = LED_PIN;

  LED_PORT_CLK_ENABLE();
  HAL_GPIO_Init(LED_PORT, &GPIO_Config);

  __HAL_RCC_GPIOA_CLK_ENABLE();
}


//Configura pino como entrada ou saida
void drv_gpio_configura(unsigned char ucTipo, unsigned char pino)
{
    GPIO_InitTypeDef gsGPIO_InitStructure;

    gsGPIO_InitStructure.Speed = GPIO_SPEED_FREQ_HIGH;
    gsGPIO_InitStructure.Pull = GPIO_NOPULL;
    switch (ucTipo)
    {
    case PINO_ENTRADA_AD:
        gsGPIO_InitStructure.Mode = GPIO_MODE_ANALOG;
        break;
    case PINO_ENTRADA_FLOATING:
        gsGPIO_InitStructure.Mode = GPIO_MODE_INPUT;
        break;
    case PINO_SAIDA_OPEN_DRAIN:
        gsGPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_OD;
        break;
    case PINO_SAIDA_PUSH_PULL:
        gsGPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
        break;
    case PINO_SAIDA_PULL_UP:
        gsGPIO_InitStructure.Pull = GPIO_PULLUP;
        gsGPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
        break;
    case PINO_SAIDA_PULL_DOWN:
        gsGPIO_InitStructure.Pull = GPIO_PULLDOWN;
        gsGPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
        break;
    case PINO_ENTRADA_PULL_UP:
        gsGPIO_InitStructure.Pull = GPIO_PULLUP;
        gsGPIO_InitStructure.Mode = GPIO_MODE_INPUT;
        break;
    }
    switch (pino)
    {
    case 2:
        gsGPIO_InitStructure.Pin = GPIO_PIN_13;
        HAL_GPIO_Init(GPIOC, &gsGPIO_InitStructure);
        break;
    case 3:
        gsGPIO_InitStructure.Pin = GPIO_PIN_14;
        HAL_GPIO_Init(GPIOC, &gsGPIO_InitStructure);
        break;
    }
}


//Seta pino do STM32
void drv_gpio_seta(unsigned char pino)
{
  switch (pino)
  {
  case 2:
      HAL_GPIO_SetBits(GPIOC, GPIO_PIN_13);
      break;
  case 3:
      HAL_GPIO_SetBits(GPIOC, GPIO_PIN_14);
      break;
  }
}

//Reseta pino do STM32
void drv_gpio_reseta(unsigned char pino)
{
    switch (pino)
    {
    case 2:
        HAL_GPIO_ResetBits(GPIOC, GPIO_PIN_13);
        break;
    case 3:
        HAL_GPIO_ResetBits(GPIOC, GPIO_PIN_14);
        break;
    }
}
  

unsigned char drv_gpio_le(unsigned char pino)
{
	switch (pino)
    {
    case 4:
        return (HAL_GPIO_ReadInputDataBit(GPIOC, GPIO_PIN_15));
    case 5:
        return (HAL_GPIO_ReadInputDataBit(GPIOF, GPIO_PIN_0));
    case 16:
    }
}

drv_gpio.c

#ifndef DRV_GPIO_H
#define DRV_GPIO_H
#include "conf_build.h"

// ST Nucleo Green user LED (PA5)
#define LED_PORT                GPIOA
#define LED_PIN                 GPIO_PIN_5
#define LED_PORT_CLK_ENABLE     __HAL_RCC_GPIOA_CLK_ENABLE

/// configuracoes dos pinos
#define PINO_ENTRADA_AD       0
#define PINO_ENTRADA_FLOATING 1
#define PINO_SAIDA_OPEN_DRAIN 2
#define PINO_SAIDA_PUSH_PULL  3
#define PINO_ENTRADA_PULL_UP  4
#define PINO_SAIDA_PULL_UP    5
#define PINO_SAIDA_PULL_DOWN  6


void drv_gpio_iniciar(void);

#endif

drv_gpio.h

#include "srv_timer.h"
#include "drv_timer.h"

uint16_t timer_tic = 0;
uint8_t timer_1ms = 0;

void timer_iniciar(void)
{
  drv_timer_iniciar();
  timer_tic = 0;
  timer_1ms = 0;
}


void timer_controle(void)
{
  drv_timer_controle();
}

void timer_int(void)
{
  timer_1ms++;
  if (timer_1ms >= 10){
    timer_1ms = 0;
    timer_tic++;
  }  
}

inline uint16_t timer_get_tic(void)
{
  return timer_tic;
}

void delay_us(uint16_t tempo)
{
    drv_timer_delay_us(tempo);
}

void delay_ms(uint16_t tempo)
{
    while (tempo) {
        delay_us(1000);
        tempo--;
    }
}

uint8_t timer_passou_tempo_tic(uint16_t tempo_final)
{
    if (timer_tic >= tempo_final) {   // Verifica se timer passou da contagem esperada
        if (tempo_final > 0x4000) {
            return (1);               // Se Contagem acima de 0x4000 - (Sem overflow no contagem) - Retorna "1"
        } else {                                             // Se Contagem abaixo de 0x4000 , pode haver overflow na contagem
            if (timer_tic < 0xC000) {
                return (1);           // Verifica se nao houve overflow no timer (Se valor menor que 0xC000)
            } else {
                return (0);          // Se teve retorna "1" , senao retorna "0"
            }
        }
    } else {                             // Se o contador do timer nao e maior que o da contagem
        if ((tempo_final > 0xC000) && (timer_tic < 0x4000)) {
            return (1); // Verifica se nao houver overflow no tempo (Se contagem > 0xC000 e o timer < 0x4000)
        } else {
            return (0);
        }
    }
}


srv_timer.c

#ifndef SRV_TIMER_H
#define SRV_TIMER_H
#include "conf_build.h"

#define TIC_100MS 10  //10x10ms = 100ms
#define TIC_1SEC  100 //100x10ms = 100x


void timer_iniciar(void);
void timer_controle(void);
uint16_t timer_get_tic(void);
void delay_us(uint16_t tempo);
void delay_ms(uint16_t tempo);
uint8_t timer_passou_tempo_tic(uint16_t tempo_final);


#endif

srv_timer.h

#include "drv_timer.h"
#include <stm32c0xx_hal.h>


void drv_timer_iniciar(void)
{
  //Esta simulacao so suporta Systick com 1ms
}

void drv_timer_controle(void)
{

}

//Funcao timer que dever ser implementada(no srv_timer)
void __attribute__((weak)) timer_int(void);

//Interrupcao da HAT de 1ms
void osSystickHandler(void)
{
  timer_int();
}

void drv_timer_delay_us(uint32_t volatile number_of_us)
{
    __asm volatile (
        "1:\tSUB %0, %0, #1\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "NOP\n\t"
        "BNE 1b\n\t"
        : "+r"(number_of_us)
    );
}


drv_timer.c

#ifndef DRV_TIMER_H
#define DRV_TIMER_H
#include "conf_build.h"

void drv_timer_iniciar(void);
void drv_timer_controle(void);
void drv_timer_delay_us(uint32_t volatile number_of_us);


#endif

drv_timer.h

#ifndef SRV_DEBUG_H
#define SRV_DEBUG_H
#include "conf_build.h"
#include "drv_uart.h"


#ifdef CONFIG_COM_DEBUG
#define DEBUG printf
#else
#define DEBUG 
#endif


#define debug_iniciar() drv_uart_iniciar()

#endif

srv_debug.h

#include "drv_uart.h"
#include <stm32c0xx_hal.h>

UART_HandleTypeDef huart2;

/**
    @brief USART2 Initialization Function
    @param None
    @retval None
*/
void drv_uart_iniciar(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  __HAL_RCC_GPIOA_CLK_ENABLE();
  // PA2     ------> USART2_TX
  // PA3     ------> USART2_RX
  GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  GPIO_InitStruct.Alternate = GPIO_AF1_USART2;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  
  huart2.Instance = USART2;
  huart2.Init.BaudRate = 115200;
  huart2.Init.WordLength = UART_WORDLENGTH_8B;
  huart2.Init.StopBits = UART_STOPBITS_1;
  huart2.Init.Parity = UART_PARITY_NONE;
  huart2.Init.Mode = UART_MODE_TX_RX;
  huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart2) != HAL_OK)
  {
    Error_Handler();
  }
}


void Error_Handler(void)
{
  /* User can add his own implementation to report the HAL error return state */
}


// The following makes printf() write to USART2:

#define STDOUT_FILENO   1
#define STDERR_FILENO   2

int _write(int file, uint8_t *ptr, int len)
{
  switch (file)
  {
    case STDOUT_FILENO:
      HAL_UART_Transmit(&huart2, ptr, len, HAL_MAX_DELAY);
      break;

    case STDERR_FILENO:
      HAL_UART_Transmit(&huart2, ptr, len, HAL_MAX_DELAY);
      break;

    default:
      return -1;
  }

  return len;
}

drv_uart.c

#ifndef DRV_UART_H
#define DRV_UART_H
#include "conf_build.h"

void drv_uart_iniciar(void);

#endif

drv_uart.h

#ifndef CONF_BUILD_H
#define CONF_BUILD_H
#include <stdint.h>

#define CONFIG_COM_DEBUG


#endif
