avr microcontroladores y cómo comenzar a codificar init o main loop o temporizadores o interrupciones

1. Lo primero que se hace en cualquier proyecto de microcontrolador es hacer parpadear un LED; manténgalo parpadeando y asígnele un nombre ("Blinky") . Es el heart beat de su widget, y siempre funcionará siempre que su programa no se atasque.
2. Comprometerse con el repositorio de control de versiones local.
3. Lo siguiente es volar a través de todo el programa en pseudo / crapcode, según los diagramas de flujo de su programa o cualquier método de planificación al que se haya suscrito. Si algo no funciona o simplemente no te gusta, coméntelo, pero manténgalo allí para que pueda repararlo más tarde. Si no sabe cómo hacer algo, escriba lo que se supone que debe hacer en los comentarios.
4. Comprometerse con el repositorio de control de versiones local.
5. Es hora de llenar los espacios en blanco! Implemente una función a la vez, por ejemplo, el temporizador, y pruébelo . Su programa siempre debe compilar y trabajar como se espera. Me gusta implementar cualquier conexión de interfaz de usuario en este punto, como UART - > RS232 - > Enlaces de PC o pantallas LCD. No te olvides de Blinky .
6. Comprometerse con el repositorio de control de versiones local.
7. Intenta romper tu código con rutinas de prueba rigurosas; depurar. Haga que otros revisen su código ; depurar. Ejecute su widget a través de sus parámetros de diseño regularmente, como las variaciones de temperatura; depuración.
8. Comprometerse con el repositorio de control de versiones local.
9. Desconecta Blinky si eres un tonto sin corazón, y envía.

AVRFreaks tiene un excelente tutorial escrito por Dean Camera (también conocido como abcminuser ) llamado Código C de modularización: gestión de grandes proyectos . También le puede interesar leer State Machines for Microprocessors por James Wagner.

Mi tutorial favorito de AVR-from-scratch-in-C es enlace

Cada uno tiene su propio estilo para pequeños sistemas embebidos. Aquí está la mía:

Me gusta usar muchos archivos en C, con el nombre de cada uno de ellos creando un prefijo para las funciones. Por ejemplo, led_init() y led_tick() están ambos en led.c . Esto mantiene las cosas modulares y ayuda con la portabilidad.

Utilizo un archivo de encabezado common.h para definir tipos, pero se incluyen individualmente para cada módulo.

Tiendo a usar un solo temporizador de sistema de freerunning (en systime.c ) y luego los módulos activan una función systime_get() para obtener la hora actual en tics del sistema o milisegundos. Cada módulo puede luego programar eventos a través de temporizadores de software utilizando las funciones X_tick() .

common.h:

#ifndef COMMON_H
#define COMMON_H
#include <stdio.h>  // general purpose headers
#include <stdint.h>
#include <stdbool.h>
...
#endif

uart.h:

#ifndef UART_H
#define UART_H
#include <avr/usart.h>  // microcontroller specific headers for uart
...

void uart_init(void);
void uart_putc(uint8_t ch);
...

#endif

uart.c:

#include "common.h"
#include "uart.h"

void uart_isr(void) __interrupt VECTOR
{
  // handle incoming data
}

void uart_init(void)
{
  // setup hardware
}

void uart_putc(uint8_t ch)
{
  UART_TX_FIFO_REGISTER = ch;
  while(!TX_COMPLETE_REGISTER);
}

led.h:

#ifndef LED_H
#define LED_H
#include <avr/ioports.h>  // microcontroller specific headers for port io
...

#define LED_DDR   PORTAD
#define LED_PIN   5
#define LED_MASK  (1 << LED_PIN)
#define LED_PORT  PORTA

void led_init(void);
void led_set(void);
void led_tick(void);
...

#endif

led.c:

#include "common.h"
#include "led.h"

void led_init(void)
{
  LED_DDR |= LED_MASK;
}

void led_set(void)
{
  LED_PORT |= LED_MASK;
}

void led_tick(void)
{
  // animate LEDs in an amusing fashion
}

main.c:

#include "common.h"
#include "led.h"
#include "uart.h"

int main(void)
{
  led_init();
  uart_init();
  ...

  led_set();

  while(1)
  {
    led_tick();
    uart_tick();
  }

  return 0;
}

Aquí hay dos proyectos "del mundo real" que usan este estilo para AVR y MSP430 .