Classes C ++ pour l'abstraction des broches d'E / S

Je recherche des abstractions C ++ pour les points d'E / S matérielles ou les broches. Des choses comme in_pin, out_pin, inout_pin, peut-être open_collector_pin, etc.

Je peux sûrement trouver un tel ensemble d'abstractions moi-même, donc je ne cherche pas des réponses de type `` hé, vous pourriez le faire de cette façon '', mais plutôt le `` regardez cette bibliothèque qui a été utilisée dans ceci et cela et ce projet'.

Google n'a rien révélé, peut-être parce que je ne sais pas comment les autres appellent cela.

Mon objectif est de créer des bibliothèques d'E / S basées sur de tels points, mais également de fournir de tels points, il serait donc facile, par exemple, de connecter un LCd HD44780 aux broches IO de la puce ou à un I2C (ou SPI) Extenseur d'E / S, ou tout autre point qui peut être contrôlé d'une manière ou d'une autre, sans aucune modification de la classe LCD.

Je sais que c'est à la pointe de l'électronique / du logiciel, désolé s'il n'appartient pas ici.

@leon: câblage C'est un gros sac de logiciels, je vais devoir regarder de plus près. Mais il semble qu'ils n'utilisent pas une abstraction de broches comme je le souhaite. Par exemple, dans la mise en œuvre du clavier, je vois

digitalWrite(columnPins[c], LOW);   // Activate the current column.

Cela implique qu'il existe une fonction (digitalWrite) qui sait écrire sur une broche d'E / S. Cela rend impossible l'ajout d'un nouveau type de broche d'E / S (par exemple, qui se trouve sur un MCP23017, il doit donc être écrit via I2C) sans réécrire la fonction digitalWrite.

@Oli: J'ai googlé un exemple Arduino IO, mais il semble utiliser à peu près la même approche que la bibliothèque de câblage:

int ledPin = 13;                 // LED connected to digital pin 13
void setup(){
    pinMode(ledPin, OUTPUT);      // sets the digital pin as output
}

Réponse courte: malheureusement, il n'y a pas de bibliothèque pour faire ce que vous voulez. Je l'ai fait moi-même de nombreuses fois mais toujours dans des projets non open-source. J'envisage de mettre quelque chose sur github mais je ne sais pas quand je peux.

Pourquoi C ++?

1. Le compilateur est libre d'utiliser une évaluation d'expression de taille de mot dynamique. C se propage à int. Votre masque d'octet / décalage peut être effectué plus rapidement / plus petit.
2. Inline.
3. Les opérations de création de modèles vous permettent de varier la taille des mots et d'autres propriétés, avec une sécurité de type.

Permettez-moi de brancher sans vergogne mon projet open source https://Kvasir.io . La partie Kvasir :: Io fournit des fonctions de manipulation des broches. Vous devez d'abord définir votre code PIN en utilisant un Kvasir :: Io :: PinLocation comme ceci:

constexpr PinLocation<0,4> led1;    //port 0 pin 4
constexpr PinLOcation<0,8> led2;

Notez que cela n'utilise pas réellement de RAM car ce sont des variables constexpr.

Tout au long de votre code, vous pouvez utiliser ces emplacements de broches dans les fonctions «usine d'action» comme makeOpenDrain, set, clear, makeOutput et ainsi de suite. Une «fabrique d'actions» n'exécute pas réellement l'action, mais renvoie plutôt une action Kvasir :: Register :: qui peut être exécutée à l'aide de Kvasir :: Register :: apply (). La raison en est que apply () fusionne les actions qui lui sont transmises lorsqu'elles agissent sur un seul et même registre, ce qui génère un gain d'efficacité.

apply(makeOutput(led1),
    makeOutput(led2),
    makeOpenDrain(led1),
    makeOpenDrain(led2));

Étant donné que la création et la fusion d'actions sont effectuées au moment de la compilation, cela devrait produire le même code assembleur que l'équivalent codé à la main typique:

PORT0DIR |= (1<<4) | (1<<8);
PORT0OD |= (1<<4) | (1<<8);

Le projet Wiring utilise une abstraction comme ça:

http://wiring.org.co/

et le compilateur est écrit en C ++. Vous devriez trouver de nombreux exemples dans le code source. Le logiciel Arduino est basé sur le câblage.

En C ++, il est possible d'écrire une classe afin que vous puissiez utiliser les ports d'E / S comme s'il s'agissait de variables, par exemple

  PORTB = 0x12; / * Écrire sur un port 8 bits * /
  si (RB3) LATB4 = 1; / * Lire un bit d'E / S et en écrire conditionnellement un autre * /

sans égard à la mise en œuvre sous-jacente. Par exemple, si l'on utilise une plate-forme matérielle qui ne prend pas en charge les opérations au niveau du bit mais prend en charge les opérations de registre au niveau des octets, on pourrait (probablement à l'aide de certaines macros) définir une classe statique IO_PORTS avec une lecture / écriture en ligne propriétés appelées bbRB3 et bbLATB4, de sorte que la dernière instruction ci-dessus se transforme en

  si (IO_PORTS.bbRB3) IO_PORTS.bbLATB4 = 1;

qui serait à son tour transformé en quelque chose comme:

  si (!! (PORTB & 8)) (1? (PORTB | = 16): (PORTB & = ~ 16));

Un compilateur doit pouvoir remarquer l'expression constante dans l'opérateur?: Et simplement inclure la partie "true". Il peut être possible de réduire le nombre de propriétés créées en élargissant les macros à quelque chose comme:

  si (IO_PORTS.ppPORTB [3]) IO_PORTS.ppPORTB [4] = 1;

ou

  si (IO_PORTS.bb (addrPORTB, 3)) IO_PORTS.bbPORTB (addrPORTB, 4) = 1;

mais je ne suis pas sûr qu'un compilateur puisse aussi bien aligner le code.

Je ne veux nullement laisser entendre que l'utilisation des ports d'E / S comme s'il s'agissait de variables est nécessairement une bonne idée, mais puisque vous mentionnez C ++, c'est une astuce utile à savoir. Ma propre préférence en C ou C ++, si la compatibilité avec le code qui utilise le style susmentionné n'était pas requise, serait probablement de définir un type de macro pour chaque bit d'E / S, puis de définir des macros pour "readBit", "writeBit", "setBit" et "clearBit" à condition que l'argument d'identification de bit transmis à ces macros soit le nom d'un port d'E / S destiné à être utilisé avec de telles macros. L'exemple ci-dessus, par exemple, serait écrit comme

  if (readBit (RB3)) setBit (LATB4);

et traduit comme

  si (!! (_ PORT_RB3 & _BITMASK_RB3)) _PORT_LATB4 | = _BITMASK_LATB4;

Ce serait un peu plus de travail pour le préprocesseur que le style C ++, mais ce serait moins de travail pour le compilateur. Il permettrait également une génération de code optimale pour de nombreuses implémentations d'E / S et une implémentation de code décente pour presque toutes.

Si vous cherchez quelque chose de vraiment génial pour abstraire le matériel et que vous avez confiance en vos compétences en C ++, alors vous devriez essayer ce modèle:

https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern

Je l'ai utilisé dans une tentative d'abstraction du matériel d'une puce Cortex-M0. Je n'ai encore rien écrit sur cette expérience (je le ferai un jour), mais croyez-moi, elle a été très utile en raison de sa nature polymorphe statique: la même méthode pour différentes puces, sans frais (par rapport au polymorphisme dynamique).