microcontrôleurs avr et comment commencer à coder init ou boucle principale ou minuteries ou interruptions

Je modifie le code du microcontrôleur AVR et PIC depuis quelques années maintenant pour le travail, mais je n'ai jamais rien écrit à partir de zéro, je le comprends assez bien.

Je commence à écrire mon propre code maintenant et j'ai du mal à démarrer. Je me demandais comment d'autres personnes commençaient à écrire du code et s'il y avait un livre ou un tutoriel que les gens recommanderaient à ce sujet.

Commencez-vous par coder votre fonction d'initialisation, puis interrompez puis les minuteries puis la boucle principale while (1) ... Je me demande quelle est la meilleure façon de commencer.

Je vous remercie

1. La première chose que l'on fait dans tout projet de microcontrôleur est de faire clignoter une LED; faites-le clignoter et donnez-lui un nom ("Blinky") aussi. C'est le rythme cardiaque de votre widget et fonctionnera toujours tant que votre programme ne sera pas bloqué.
2. Validez le référentiel de contrôle de version local.
3. La prochaine étape consiste à parcourir l'intégralité du programme en pseudo / crapcode, en fonction des organigrammes de votre programme ou des méthodes de planification auxquelles vous êtes abonné. Si quelque chose ne fonctionne pas ou si vous ne l'aimez tout simplement pas, commentez-le mais conservez-le afin que vous sachiez le réparer plus tard. Si vous ne savez pas comment faire quelque chose, notez ce qu'elle est censée faire dans les commentaires.
4. Validez le référentiel de contrôle de version local.
5. Il est temps de remplir les blancs! Implémentez une fonction à la fois, par exemple la minuterie, et testez-la . Votre programme doit toujours compiler et fonctionner comme prévu. J'aime implémenter toutes les connexions d'interface utilisateur à ce stade, comme UART -> RS232 -> Liens PC ou écrans LCD. N'oubliez pas Blinky .
6. Validez le référentiel de contrôle de version local.
7. Essayez de casser votre code avec des routines de test rigoureuses; déboguer. Demandez à d'autres de réviser votre code ; déboguer. Exécutez régulièrement votre widget à travers ses paramètres de conception, comme les variations de température; déboguer.
8. Validez le référentiel de contrôle de version local.
9. Déconnectez Blinky si vous êtes un idiot sans cœur et expédiez.

AVRFreaks a un excellent tutoriel écrit par Dean Camera (alias. Abcminuser ) appelé Modularizing C Code: Managing large projects . Vous pouvez également être intéressé par la lecture de State Machines for Microprocessors par James Wagner.

Mon tutoriel AVR-from-scratch-in-C préféré est https://www.mainframe.cx/~ckuethe/avr-c-tutorial/

Chacun a son propre style pour les petits systèmes embarqués. Voici la mienne:

J'aime utiliser beaucoup de fichiers C, le nom de chacun constituant un préfixe pour les fonctions. Par exemple, led_init()et led_tick()sont tous les deux dans led.c. Cela maintient les choses modulaires et contribue à la portabilité.

J'utilise un common.hfichier d'en-tête pour définir les types, mais des inclus individuels pour chaque module.

J'ai tendance à utiliser une seule minuterie système freerunning (en a systime.c) puis à demander aux modules d'appeler une systime_get()fonction pour récupérer l'heure actuelle en ticks système ou en millisecondes. Chaque module peut ensuite planifier des événements via des minuteries logicielles à l'aide des X_tick()fonctions.

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
}

principal 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;
}

Voici deux projets "du monde réel" utilisant ce style pour AVR et MSP430 .