Carte d'interface universelle intégrée - Contrôle USB/Bluetooth/WIFI : 6 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Je trouve souvent que je crée des bibliothèques pour de nouveaux modules intégrés à partir de zéro en fonction de la fiche technique de l'appareil. En générant la bibliothèque, je trouve que je suis coincé dans un cycle de code, de compilation, de programmation et de test pour m'assurer que les choses fonctionnent et sont exemptes de bogues. Souvent, les temps de compilation et de programme peuvent être beaucoup plus longs que le temps qu'il faut pour éditer le code et donc un moyen de couper ces étapes lors du développement serait très pratique.

Je trouve aussi souvent que je veux interfacer un module embarqué avec un PC. Si le module n'a pas spécifiquement de connexion USB, ce qui est souvent le cas, vous devez généralement acheter un convertisseur USB hors de prix qui fera un seul travail tel que SPI ou I2C.

C'est pour ces raisons que j'ai décidé de créer la carte d'interface universelle. Il est conçu pour permettre des communications faciles sur PC avec des modules intégrés.

Les fonctionnalités de l'interface intégrée de la carte sur laquelle j'ai choisi incluent.

• E/S numériques
• I2C
• SPI
• UART
• PWM
• Servomoteur
• Entrée CAN
• Sortie DAC

Tout cela peut être utilisé de manière totalement indépendante.

La carte d'interface peut être contrôlée via une connexion USB au PC, mais dispose également de connexions de module WIFI ou Bluetooth en option pour permettre à la carte d'être utilisée à distance ou dans un scénario de type IoT.

En utilisant des embases SIL standard au pas de 2,54 mm, il est possible de connecter directement des câbles dupont femelles entre la carte et le module intégré, ce qui permet des connexions rapides, fiables et sans soudure.

J'ai également pensé à ajouter des éléments comme CAN, LIN, H-bridge, etc., mais ceux-ci pourraient peut-être venir plus tard avec une révision v2.

Étape 1: Conception du PCB

Lors de la conception du PCB, j'aime essayer de garder les choses aussi simples que possible. Lorsque vous allez construire des cartes à la main, il est important d'ajouter des composants uniquement lorsqu'ils ont un objectif spécifique et d'utiliser autant de fonctionnalités internes du microcontrôleur que possible.

En regardant mon fournisseur d'électronique préféré, j'ai trouvé une puce avec laquelle j'étais à l'aise, qui avait les caractéristiques que je recherchais et qui était d'un coût raisonnable. La puce sur laquelle j'ai atterri était la PIC18F24K50.

Avec les 23 broches d'E/S disponibles, cela m'a permis ces fonctionnalités

• E/S numérique
• I2C
• SPI
• UART
• PWM x 2
• Servomoteur x 6
• Entrée CAN x 3
• Sortie DAC x 1
• E/S pilotées à partir de 5V ou 3V3
• LED d'état

Un inconvénient de l'IC que j'ai choisi est qu'il n'a qu'un seul périphérique UART et donc l'utilisation de la méthode de contrôle Bluetooth ou Wifi vous empêchera d'utiliser la connexion UART.

Les images ci-dessus montrent le schéma et le PCB finis.

Étape 2: Conception du protocole

La première étape de la conception du protocole consiste à décider de ce que vous aurez besoin de la carte pour être capable de faire. La séparation des éléments ajoute un meilleur niveau de contrôle, tandis que le fait de combiner les éléments simplifie l'interface et réduit le trafic de communication entre la carte et le PC. C'est un jeu d'équilibre et difficile à perfectionner.

Pour chaque fonction de la carte, vous devez indiquer les paramètres et les retours. Par exemple, une fonction pour lire une entrée ADC peut avoir un paramètre pour spécifier quelle entrée échantillonner et une valeur de retour contenant le résultat.

Dans ma conception, voici la liste des fonctions que je voulais inclure:

• E/S numériques

  • SetPin (PinNumber, État)
  • État = GetPin (PinNumber)

• SPI

  • Initialiser (Mode SPI)
  • DataIn = Transfert (DataOut)
  • ControlChipSelect (canal, état)
  • SetPrescaler (Taux)

• I2C

  • Initialiser ()
  • Début ()
  • Redémarrage ()
  • Arrêter ()
  • SlaveAck = Envoyer (DataOut)
  • DataIn = Recevoir (Dernier)

• UART

  • Initialiser()
  • Octet TX (DataOut)
  • BytesAvailable = RX Count ()
  • DataIn = RX Octet ()
  • SetBaud (Baud)

• PWM

  • Activer (canal)
  • Désactiver (Canal)
  • SetFrequency (canal, fréquence)
  • GetMaxDuty (Devoir)
  • SetDuty (Devoir)

• Servomoteur

  • Activer (canal)
  • Désactiver (Canal)
  • SetPosition (Canal, Position)

• CAN

  ADCsample = échantillon (canal)

• CAD

  • Permettre
  • Désactiver
  • SetOutput (Tension)

• WIFI

  • Définir le SSID (SSID)
  • Définir le mot de passe (mot de passe)
  • Statut = CheckConnectionStatus ()
  • IP = Obtenir l'adresseIP ()

Les paramètres sont indiqués entre parenthèses et les retours sont affichés avant le symbole égal.

Avant de commencer à coder, j'affecte à chaque fonction un code de commande à partir de 128 (binaire 0b10000000) et en remontant. Je documente entièrement le protocole pour m'assurer qu'une fois que ma tête est dans le code, j'ai un bon document auquel me référer. Le document de protocole complet pour ce projet est joint et comprend les codes de commande entrants et les largeurs de bits.

Étape 3: Conception du micrologiciel

Une fois le protocole établi, il s'agit alors d'implémenter la fonctionnalité sur le matériel.

J'adopte une approche de type machine d'état simple lors du développement de systèmes esclaves pour essayer de maximiser le débit potentiel de commandes et de données tout en gardant le micrologiciel simple à comprendre et à déboguer. Un système plus avancé tel que Modbus pourrait être utilisé à la place si vous avez besoin d'une meilleure interaction avec d'autres appareils connectés, mais cela ajoute une surcharge qui ralentira les choses.

La machine d'état se compose de trois états:

1) En attente de commandes

2) Paramètres de réception

3) Répondre

Les trois états interagissent comme suit:

1) Nous parcourons les octets entrants dans le tampon jusqu'à ce que nous ayons un octet dont le bit le plus significatif est défini. Une fois que nous recevons un tel octet, nous le vérifions par rapport à une liste de commandes connues. Si nous trouvons une correspondance, nous attribuons le nombre d'octets de paramètres et renvoyons des octets pour correspondre au protocole. S'il n'y a pas d'octets de paramètres, nous pouvons exécuter la commande ici et passer à l'état 3 ou redémarrer l'état 1. S'il y a des octets de paramètres, nous passons à l'état 2.

2) Nous parcourons les octets entrants en les sauvegardant jusqu'à ce que nous ayons stocké tous les paramètres. Une fois que nous avons tous les paramètres, nous exécutons la commande. S'il y a des octets de retour, nous passons à l'étape 3. S'il n'y a pas d'octets de retour à envoyer, nous retournons à l'étape 1.

3) Nous parcourons les octets entrants et pour chaque octet, nous écrasons l'octet d'écho avec un octet de retour valide. Une fois que nous avons envoyé tous les octets de retour, nous retournons à l'étape 1.

J'ai utilisé Flowcode pour concevoir le firmware car il montre bien visuellement ce que je fais. La même chose pourrait être faite aussi bien dans Arduino ou d'autres langages de programmation embarqués.

La première étape consiste à établir des communications avec le PC. Pour ce faire, le micro doit être configuré pour fonctionner à la bonne vitesse et nous devons ajouter du code pour piloter les périphériques USB et UART. Dans Flowcode, c'est aussi simple que de faire glisser dans le projet un composant série USB et un composant UART à partir du menu des composants de communication.

Nous ajoutons une interruption RX et un tampon pour récupérer les commandes entrantes sur l'UART et nous interrogeons régulièrement l'USB. On peut alors à loisir traiter le buffer.

Le projet Flowcode et le code C généré sont joints.

Étape 4: Interfaçage via Flowcode

La simulation Flowcode est très puissante et nous permet de créer un composant pour parler à la carte. Lors de la création du composant, nous pouvons maintenant simplement faire glisser le composant dans notre projet et disposer instantanément des fonctions de la carte. En prime, tout composant existant doté d'un périphérique SPI, I2C ou UART peut être utilisé dans la simulation et les données de communication peuvent être acheminées vers la carte d'interface via un composant injecteur. Les images jointes montrent un programme simple pour imprimer un message à l'écran. Les données de communication qui sont envoyées via la carte d'interface au matériel d'affichage réel et la configuration des composants avec les composants de l'affichage I2C, de l'injecteur I2C et de la carte d'interface.

Le nouveau mode SCADA pour Flowcode 8.1 est un bonus absolu en ce sens que nous pouvons ensuite prendre un programme qui fait quelque chose dans le simulateur Flowcode et l'exporter afin qu'il s'exécute de manière autonome sur n'importe quel PC sans aucun problème de licence. Cela pourrait être idéal pour des projets tels que des bancs d'essai ou des groupes de capteurs.

J'utilise ce mode SCADA pour créer l'outil de configuration WIFI qui peut être utilisé pour configurer le SSID et le mot de passe ainsi que pour collecter l'adresse IP du module. Cela me permet de tout configurer à l'aide de la connexion USB, puis de transférer vers une connexion réseau WIFI une fois que les choses fonctionnent.

Quelques exemples de projets sont joints.

Étape 5: Autres méthodes d'interfaçage

En plus de Flowcode, vous pouvez à peu près utiliser le langage de programmation de votre choix pour communiquer avec la carte d'interface. Nous avons utilisé Flowcode car il comportait déjà une bibliothèque de pièces que nous pouvions mettre en service immédiatement, mais cela s'applique également à de nombreuses autres langues.

Voici une liste de langues et de méthodes pour communiquer avec la carte d'interface.

Python - Utilisation d'une bibliothèque série pour diffuser des données vers un port COM ou une adresse IP

Matlab - Utilisation des commandes de fichier pour diffuser des données vers un port COM ou une adresse IP

C++ / C# / VB - En utilisant soit une DLL pré-écrite, accédant directement au port COM ou à l'API Windows TCP/IP

Labview - Utilisation d'une DLL pré-écrite, du composant VISA Serial ou du composant TCP/IP

Si quelqu'un souhaite voir les langues ci-dessus implémentées, merci de me le faire savoir.

Étape 6: Produit fini

Le produit fini sera probablement une caractéristique importante de ma trousse à outils intégrée pour les années à venir. Cela m'a déjà aidé à développer des composants pour divers écrans et capteurs Grove. Je peux maintenant obtenir le code complètement cloué avant de recourir à des manigances de compilation ou de programmation.

J'ai même distribué des tableaux à des collègues afin qu'ils puissent également améliorer leur flux de travail et ceux-ci ont été très bien reçus.

Merci d'avoir lu mon Instructable, j'espère que vous l'avez trouvé utile et j'espère qu'il vous inspirera pour créer vos propres outils pour accélérer votre productivité.