Révolutionner les visuels compacts : module d'affichage OLED 128×32 de 0,91 pouce avec interface I2C – Présentation

Cet article plonge dans le monde des compacts Modules d'affichage OLED, en se concentrant spécifiquement sur la 0,91 pouce 128×32 Écran OLED qui utilise le Interface I2CNous explorerons les aspects techniques aperçu de ceci monochrome afficher, ses fonctionnalités et comment il peut être intégré dans divers projets, notamment avec Arduino UnoCet article vaut la peine d'être lu car il offre une compréhension complète d'un type de afficher technologie. Que vous soyez un amateur, un ingénieur ou simplement quelqu'un de curieux de l'électronique, cet article vous fournira les connaissances nécessaires pour utiliser efficacement ces petits mais puissants affiche dans votre prochain projet. Vous trouverez OLED blanc être très utile. Nous discuterons également des bases de Écran OLED de 0,91 pouce et c'est facile à utiliser Interface I2C. Vous pouvez trouver des produits similaires module sur Waveshare site Web, mais nous utiliserons notre propre Module OLED et vous fournir des services dédiés tutoriel et soutien.

1. Présentation des modules d'affichage OLED 0,91 pouces 128×32

Écran OLED la technologie a révolutionné la façon dont nous interagissons avec les appareils électroniques, offrant des couleurs vives, contraste élevéet des angles de vision larges. Dans le domaine de Écrans OLED, le 0.91 pouce 128×32 Module d'affichage OLED se distingue comme une solution compacte mais puissante pour les projets nécessitant un document petit mais très lisible afficher. Ces les écrans sont petits, souvent utilisé dans les appareils portables, les wearables et divers systèmes embarqués où l'espace est limité. Le 0.91 pouce la taille fait référence à la diagonale mesure de la afficher zone, tandis que le 128×32 la résolution indique que la afficher est composé de 128 horizontaux pixels et 32 verticaux pixels.

Malgré leur petite taille taille, ces Modules OLED offrent des visuels nets et clairs, grâce aux avantages inhérents à OLED technologie, comme la possibilité de désactiver individuellement pixels complètement, ce qui donne de vrais noirs et contraste élevé ratios. Ceci 0.91 128×32 monochrome Module OLED est contrôlé par un contrôleur intégré, généralement le SSD1306 pilote IC, qui simplifie le processus d'interfaçage du afficher avec des microcontrôleurs. SSD1306 est un Pilote OLED qui a un intégré Puce de contrôleur. Écran OLED est un choix populaire parmi les amateurs et les professionnels.

2. Description détaillée du module OLED : principales caractéristiques et spécifications

Le 0.91 pouce 128×32 Module d'affichage OLED est un monochrome affichage graphique qui regroupe une gamme de fonctionnalités dans son format compact. Spécification peut varier selon les fabricants. L'une des principales caractéristiques de cette module est-ce que c'est OLED technologie, qui permet à chaque pixel émettre sa propre lumière. Cela élimine le besoin d'un rétroéclairage, ce qui donne un produit plus fin afficher avec supérieur contraste et une consommation d'énergie inférieure par rapport aux systèmes traditionnels Écran LCD modules. Le afficher est compatible avec de nombreux appareils.

Voici un tableau résumant les valeurs typiques caractéristiques d'un 0,91 pouce 128×32 Module d'affichage OLED:

Le Module OLED fonctionne généralement à un tension entre 3,3 V et 5V, le rendant compatible avec une large gamme de microcontrôleurs, y compris Arduino Les besoins en énergie dépendent de la façon dont une grande partie de l'affichage est allumé. Le interface est le plus souvent I2C, ce qui simplifie le câblage et réduit le nombre de saisir broches requises. Certains modules offrent également une SPI interface option. Vérifier détail concernant interface sur votre page produit. Le SSD1306 contrôleur gère le bas niveau détails de conduire le OLED panneau, y compris pixel adressage, taux de rafraîchissement et gestion de l'alimentation.

3. Comprendre l’interface I2C : comment fonctionne-t-elle avec l’écran OLED ?

Le I2C (Circuit inter-intégré) interface est un protocole de communication série qui permet à plusieurs appareils de communiquer entre eux en utilisant seulement deux fils : SDA (données série) et SCL (horloge série). C'est un choix populaire pour connecter des périphériques tels que affiche, capteurs et puces de mémoire aux microcontrôleurs en raison de sa simplicité et de son efficacité. Interface I2C est particulièrement bien adapté au 0,91 pouce 128×32 Module d'affichage OLED car il minimise le nombre de connexions requises, ce qui est crucial dans les applications à espace restreint.

Dans un I2C configuration avec le Module OLED, le microcontrôleur (par exemple, un Arduino) agit généralement en tant que maître appareil, tandis que le Écran OLED agit comme un esclave appareil. Le maître initie la communication et contrôle le signal d'horloge, tandis que l'esclave répond aux commandes du maître. appareil sur le I2C le bus a une adresse unique de 7 ou 10 bits, et le Module d'affichage OLED ne fait pas exception. SSD1306 contrôleur utilisé dans ces affiche a un spécifique I2C adresse qui permet au microcontrôleur de sélectionner pour la communication. Écran OLED de 0,91 pouce est communication via l'interface I2C. L'avantage d'utiliser le Interface I2C avec le Écran OLED c'est que cela simplifie le câblage, car il suffit de connecter deux lignes de données (SDA et SCL) en plus de l'alimentation et de la masse. Ceci est particulièrement utile lorsque vous travaillez avec des microcontrôleurs qui ont des capacités limitées saisir/sortir épingles. De plus, I2C permet à plusieurs appareils de partager le même bus, à condition que chacun appareil dispose d'une adresse unique, ce qui facilite l'extension de votre projet avec des capteurs ou des périphériques supplémentaires.

4. Présentation du matériel : examen des composants physiques du module OLED

Le matériel d'un 0,91 typique pouce 128×32 Module d'affichage OLED se compose de plusieurs composants clés intégrés sur une petite carte de circuit imprimé (PCB). Le composant le plus important est le OLED panneau lui-même, qui est mince et plat afficher qui contient le 128×32 tableau de pixels. Le OLED Le panneau est généralement recouvert d'une couche protectrice en verre ou en plastique. Vous devez vérifier contour de votre module.

Le contrôleur puce, généralement la SSD1306, est monté à l'arrière du PCB. Cette puce est responsable de la réception des commandes et des données du microcontrôleur via I2C et conduire l'individu pixels sur le OLED panneau. Le SSD1306 a intégré graphique afficher données BÉLIER (GDDRAM) qui stocke le image données à afficher. taille de ceci BÉLIER détermine le résolution de la afficher que le contrôleur peut supporter. Pour un 128×32 afficher, le contrôleur a besoin d'au moins 512 octets de RAM depuis chaque pixel est représenté par un bit (activé ou désactivé) dans un monochrome afficher, et 128 * 32 bits est égal à 512 octets de données. Les écrans sont petits et très utile dans de nombreux projets. PCB comprend également d'autres composants nécessaires tels que des résistances, des condensateurs et des régulateurs de tension. Ces composants garantissent que le OLED panneau et contrôleur recevoir la puissance correcte fournir et les conditions de fonctionnement. module comporte généralement une ligne d'en-tête épingle connexions le long d'un bord de la PCB, vous permettant de facilement connecter à une plaque d'essai ou à un microcontrôleur à l'aide de fils de liaison. Le spécifique épingle la configuration peut varier légèrement selon les différents fabricants, mais comprend généralement des broches pour l'alimentation (fournir), le sol et le I2C lignes de communication (SDA et SCL).

5. Interface avec Arduino : Guide étape par étape pour connecter et utiliser l'écran OLED avec Arduino Uno

Interfacer le 0.91 pouce 128×32 Module d'affichage OLED avec un Arduino Uno est un processus simple, grâce à la Interface I2C et la disponibilité de bibliothèques qui simplifient le code requis. Voici un guide étape par étape pour vous aider à démarrer :

1. Connecter le matériel:Tout d'abord, vous devrez physiquement connecter le Module OLED à votre Arduino Uno. Connecter le VCC épingle sur le Module OLED au 5V épingle sur le Arduino, et le GND épingle à l'une des broches GND sur le Arduino. Suivant, connecter l'Église adventiste du septième jour épingle sur le Module OLED vers l'A4 épingle (SDA) sur le Arduino, et le SCL épingle vers l'A5 épingle (SCL) sur le Arduino.
2. Installer la bibliothèque:Pour simplifier le processus de contrôle de la Écran OLED, vous devrez installer un bibliothèque dans le Arduino IDE. Deux choix populaires sont Adafruit SSD1306 bibliothèque et le U8g2 bibliothèque. Vous pouvez les installer bibliothèques à travers le Arduino Bibliothèque Gestionnaire en allant dans Sketch > Inclure Bibliothèque > Gérer les bibliothèques, rechercher «SSD1306" ou "U8g2", puis en cliquant sur "Installer".
3. Télécharger le code:Une fois que le bibliothèque est installé, vous pouvez télécharger un échantillon esquissez votre Arduino pour tester le afficher. L'Adafruit SSD1306 bibliothèque est accompagné d'exemples de croquis qui montrent comment initialiser le afficher, dessiner des formes de base et afficher texte. Vous pouvez trouver ces exemples dans le Arduino IDE sous Fichier > Exemples > Adafruit SSD1306. Sélectionner l'exemple pour 128×32 I2C affiche.
4. Modifier le code:Après avoir vérifié que le afficher fonctionne correctement, vous pouvez modifier l'exemple code ou écrivez vos propres croquis pour créer des graphiques personnalisés et afficher des informations sur le OLED. Le bibliothèque fournit des fonctions pour dessin pixels, lignes, rectangles, cercles et texte.

N'oubliez pas de consulter la documentation spécifique bibliothèque vous utilisez pour comprendre toutes les fonctions disponibles et leur utilisation. Avec ces étapes simples, vous pouvez rapidement obtenir votre 0.91 pouce 128×32 Écran OLED opérationnel avec un Arduino Uno.

6. SPI vs. I2C pour les écrans OLED : quelle interface convient à votre projet ?

Lorsque vous travaillez avec Modules d'affichage OLED, vous rencontrerez souvent deux interfaces de communication série courantes : SPI (Périphérique série Interface) et I2C (Circuit inter-intégré). Les deux interfaces ont leurs avantages et leurs inconvénients, et le choix entre elles dépend des exigences spécifiques de votre projet.

Interface I2C:

• Simplicité: I2C utilise seulement deux fils pour la communication (SDA et SCL), ce qui simplifie le câblage et réduit le nombre de saisir broches requises sur le microcontrôleur.
• Adressage: Chaque appareil sur le I2C le bus a une adresse unique, permettant au microcontrôleur de communiquer avec plusieurs appareils en utilisant les mêmes deux fils.
• Vitesse: I2C est généralement plus lent que SPI, avec des vitesses standard de 100 kHz, 400 kHz et parfois jusqu'à 1 MHz ou plus.
• Consommation d'énergie:En raison de sa vitesse plus faible et de son protocole plus simple, I2C consomme généralement moins d'énergie que SPI, ce qui en fait un bon choix pour les appareils alimentés par batterie.

Interface SPI:

• Vitesse: SPI est généralement plus rapide que I2C, avec des vitesses atteignant souvent plusieurs mégahertz, voire des dizaines de mégahertz. Cela rend SPI convient aux applications nécessitant des taux de rafraîchissement élevés ou de grandes quantités de transfert de données.
• Complexité: SPI nécessite généralement plus de fils pour la communication (MOSI, MISO, SCK et CS), ce qui peut compliquer le câblage, en particulier lorsque plusieurs appareils sont impliqués.
• Adressage: SPI utilise une puce sélectionner (CS) ligne pour chaque appareil, ce qui signifie que le microcontrôleur a besoin d'un saisir broche pour chaque appareil il veut communiquer avec.
• Consommation d'énergie:En raison de sa vitesse plus élevée et de son protocole plus complexe, SPI consomme généralement plus d'énergie que I2C.

Pour le 0.91 pouce 128×32 Module d'affichage OLED, le Interface I2C est souvent le choix préféré en raison de sa simplicité et de son nombre de broches réduit. Cependant, si votre projet nécessite une connexion très rapide afficher mises à jour ou si vous utilisez déjà SPI pour les autres composants, puis en utilisant un SPI version de la Module OLED pourrait être plus approprié.

7. Bibliothèque d'affichage : exploration du côté logiciel – bibliothèques et exemples de code

Pour contrôler le 0,91 pouce 128×32 Module d'affichage OLED à partir d'un microcontrôleur comme le Arduino Uno, vous devrez utiliser un logiciel bibliothèque qui fournit un ensemble de fonctions pour envoyer des commandes et des données à afficher. Plusieurs bibliothèques sont disponibles pour travailler avec SSD1306-basé Écrans OLED, dont deux des plus populaires sont l'Adafruit SSD1306 bibliothèque et le U8g2 bibliothèque.

L'Adafruit SSD1306 bibliothèque est spécialement conçu pour monochrome Écrans OLED qui utilisent le SSD1306 contrôleur, y compris le 0,91 pouce 128×32 module. Il fournit une API simple et facile à utiliser pour initialiser le afficher, dessin formes de base et affichage texte. Le bibliothèque est construit sur Adafruit GFX bibliothèque, qui fournit un ensemble commun de fonctions graphiques qui fonctionnent sur différents types de affiche.

Voici un code exemple qui montre comment initialiser le afficher et afficher quelques texte en utilisant l'Adafruit Bibliothèque SSD1306:

    #inclure <SPI.h>
    #inclure <Wire.h>
    #inclure <Adafruit_GFX.h>
    #inclure <Adafruit_SSD1306.h>

    #définir LARGEUR_ÉCRAN 128 // Largeur de l'écran OLED, en pixels
    #définir HAUTEUR_ÉCRAN 32 // Hauteur de l'écran OLED, en pixels

    // Déclaration pour une interface I2C
    #définir OLED_RESET 4 // Réinitialiser la broche # (ou -1 si vous partagez la broche de réinitialisation Arduino)
    #définir ADRESSE_ECRAN 0x3C ///< Voir la fiche technique pour l'adresse ; 0x3D pour 128x64, 0x3C pour 128x32
    Adafruit_SSD1306 afficher(LARGEUR_ÉCRAN, HAUTEUR_ÉCRAN, &Fil, RÉINITIALISATION_OLED);

    vide installation() {
      En série.commencer(9600);

      // SSD1306_SWITCHCAPVCC = génère une tension d'affichage à partir de 3,3 V en interne
      si(!afficher.commencer(SSD1306_SWITCHCAPVCC, ADRESSE_ÉCRAN)) {
        En série.imprimer(F(« Échec de l'allocation SSD1306 »));
        pour(;;); // Ne continuez pas, bouclez pour toujours
      }

      // Afficher le contenu initial du tampon d'affichage sur l'écran --
      // la bibliothèque initialise ceci avec un écran de démarrage Adafruit.
      afficher.afficher();
      retard(2000); // Pause de 2 secondes

      // Effacer le tampon
      afficher.clearDisplay();

      // Dessine un seul pixel en blanc
      afficher.drawPixel(10, 10, SSD1306_BLANC);

      // Affiche le tampon d'affichage sur l'écran. Vous DEVEZ appeler display() après
      // commandes de dessin pour les rendre visibles à l'écran !
      afficher.afficher();
      retard(2000);
      // display.display() n'est PAS nécessaire après chaque commande de dessin,
      // à moins que ce soit ce que vous voulez... vous pouvez plutôt regrouper plusieurs
      // opérations de dessin puis mise à jour de l'écran en une seule fois en appelant
      // display.display(). Ces exemples illustrent les deux approches...

      testdrawline();      // Dessiner plusieurs lignes

      testdrawrect();      // Dessiner des rectangles (contours)

      testfillrect();      // Dessiner des rectangles (remplis)

      testdrawcircle();    // Dessiner des cercles (contours)

      testfillcircle();    // Dessiner des cercles (remplis)

      testdrawroundrect(); // Dessiner des rectangles arrondis (contours)

      testfillroundrect(); // Dessiner des rectangles arrondis (remplis)

      testdrawtriangle();  // Dessiner des triangles (contours)

      testfilltriangle();  // Dessiner des triangles (remplis)

      testdrawchar();      // Dessiner les caractères de la police par défaut

      testdrawstyles();    // Dessiner des caractères « stylisés »

      testcrolltext();    // Dessiner un texte défilant

      testdrawbitmap();    // Dessiner une petite image bitmap

      // Inverser et restaurer l'affichage, en faisant une pause entre les deux
      afficher.invertDisplay(vrai);
      retard(1000);
      afficher.invertDisplay(faux);
      retard(1000); testanimate(logo_bmp, LARGEUR_LOGO, HAUTEUR_LOGO); // Animer des bitmaps
    }

Le U8g2 bibliothèque est plus complet bibliothèque qui prend en charge une large gamme de monochrome affiche, y compris OLED, LCD et papier électronique affiche. Il offre des fonctionnalités plus avancées que Adafruit Bibliothèque SSD1306, comme la prise en charge de plusieurs polices, caractères Unicode et divers dessin opérations.

Les deux bibliothèques sont bien documentés et sont accompagnés d'exemples de croquis qui montrent comment utiliser les différentes fonctions. Vous pouvez trouver ces exemples dans le Arduino IDE sous Fichier > Exemples après l'installation du bibliothèques. Tu peux télécharger les deux bibliothèques depuis Internet.

8. Dessin et affichage d'images : techniques de création de graphiques sur l'OLED 128×32

Création de graphiques et affichage d'images sur le 0.91 pouce 128×32 Écran OLED implique l'utilisation des fonctions fournies par le afficher bibliothèque manipuler l'individu pixels ou dessiner des formes prédéfinies. Les techniques spécifiques que vous utiliserez dépendront de la complexité des graphiques que vous souhaitez créer et des capacités du bibliothèque vous utilisez.

Dessin de base :

Le plus fondamental dessin l'opération consiste à définir la couleur de chaque individu pixels. Vous pouvez utiliser le drawPixel(x, y, couleur) fonction pour transformer un élément spécifique pixel allumé ou éteint (dans le cas d'un monochrome afficher). En combinant plusieurs dessinerPixel appels, vous pouvez créer des formes et des motifs simples.

Le afficher bibliothèques fournissent également des fonctions pour dessin formes de base comme des lignes, des rectangles et des cercles. Par exemple, l'Adafruit GFX bibliothèque offre des fonctions telles que dessiner une ligne(), dessinerRect(), fillRect(), dessinerCercle(), et fillCircle()Ces fonctions prennent des paramètres tels que les coordonnées de début et de fin, la largeur et la hauteur (pour les rectangles), le rayon (pour les cercles) et la couleur.

Affichage du texte :

Affichage texte sur le OLED est une exigence commune à de nombreux projets. afficher bibliothèques fournissent généralement des fonctions pour définir la police, taille, et la couleur de la texte, ainsi que le positionnement du curseur et l'impression de chaînes sur le afficher.

Le GFX d'Adafruit bibliothèque, par exemple, inclut une police par défaut et vous permet de sélectionner différentes tailles de police en utilisant setTextSize(). Vous pouvez définir la position du curseur avec définirCurseur(x, y) et imprimer texte en utilisant imprimer() ou println(). Le U8g2 bibliothèque offre plus avancée texte capacités de gestion, y compris la prise en charge de plusieurs polices et caractères Unicode.

Affichage de l'image :

Affichage image bitmap images sur le OLED nécessite la conversion du image données dans un format que le afficher contrôleur peut comprendre. Cela implique généralement la création d'un tableau d'octets où chaque bit représente un pixel sur le afficher. Pour le 128×32 OLED, vous auriez besoin d'un tableau de 512 octets (128 * 32 / 8 = 512).

Vous pouvez utiliser des outils logiciels spécialisés pour convertir image déposer dans le approprié image bitmap format. Une fois que vous avez le image bitmap données, vous pouvez utiliser une fonction comme dessinerBitmap() (fourni par certains bibliothèques) pour afficher le image sur le OLED. Vous devrez spécifier les coordonnées de départ, la largeur et la hauteur du image, et le image bitmap tableau.

Voici un exemple de la façon dont vous pourriez définir un simple image bitmap pour une forme de cœur et l'afficher à l'aide d'Adafruit Bibliothèque SSD1306:

    const statique unsigned char PROGMEM heart_bmp[] = { 0b00000000, 0b00000000,
      0b00000110, 0b01100000,
      0b00001111, 0b11110000,
      0b00011111, 0b11111000,
      0b00111111, 0b11111100,
      0b00111111, 0b11111100,
      0b01111111, 0b11111110,
      0b01111111, 0b11111110,
      0b00111111, 0b11111100,
      0b00011111, 0b11111000,
      0b00001111, 0b11110000,
      0b00000111, 0b11100000,
      0b00000011, 0b11000000,
      0b00000001, 0b10000000,
      0b00000000, 0b00000000
    }; // Dans votre boucle principale ou une fonction:
    afficher.drawBitmap(50, 0, coeur_bmp, 16, 16, 1);
    afficher.afficher();

Gardez à l'esprit que le 0,91 pouce 128×32 OLED a une mémoire limitée et une capacité relativement faible résolutionIl peut être nécessaire de simplifier ou de réduire la taille des images complexes pour qu'elles s'adaptent à ces contraintes.

9. Considérations relatives à l'alimentation électrique de votre module d'affichage OLED

Lorsque vous travaillez avec le 0.91 pouce 128×32 Module d'affichage OLED, il est important de considérer la puissance fournir exigences pour assurer un bon fonctionnement et éviter d'endommager le afficher. Écrans OLED sont généralement plus économes en énergie que les lampes traditionnelles Écran LCD parce qu'ils ne nécessitent pas de rétroéclairage. Cependant, la consommation d'énergie peut encore varier en fonction de facteurs tels que la luminosité réglage, le nombre de pixels qui sont illuminés, et le spécifique OLED technologie utilisée.

Le 0.91 pouce 128×32 Module OLED fonctionne généralement à une tension comprise entre 3,3 V et 5 V. La plupart des modules sont conçus pour être compatible avec des niveaux logiques de 3,3 V et 5 V, ce qui les rend polyvalents pour une utilisation avec différents microcontrôleurs. Il est essentiel de vérifier le spécification feuille pour votre spécifique module pour déterminer la tension de fonctionnement recommandée. Les besoins réels en énergie dépendent de la façon dont une grande partie de l'écran est éclairée à tout moment. Lorsque tous les pixels sont éteints, le afficher consomme très peu d'énergie. Lorsque tout le pixels sont allumés, le l'affichage consomme environ 20 mA sur l'affichage moyen utilise environ 20-25 mA de courant à pleine puissance luminosité. Cependant, si seulement une petite partie de la afficher est allumé, la consommation de courant sera considérablement plus faible.

Pour alimenter le Module OLED, vous pouvez généralement connecter la broche VCC à 3,3 V ou 5 V fournir sur votre microcontrôleur. Si vous utilisez un Arduino Uno, par exemple, vous pouvez connecter le VCC épingle au 5V épingle sur le Arduino. Quelques Modules OLED disposent de régulateurs de tension intégrés qui leur permettent d'accepter une gamme plus large de saisir tensions.

Il est important de noter que même si Écrans OLED sont relativement économes en énergie, ils peuvent néanmoins consommer une quantité importante de courant lors de l'affichage d'images lumineuses ou lorsqu'une grande partie de la écran est allumé. Si vous concevez un appareil alimenté par batterie, vous devrez en tenir compte lors du calcul de votre budget énergétique et du choix d'une batterie.

Pour optimiser la consommation d'énergie, vous pouvez régler la luminosité de la afficher en utilisant les commandes fournies par le afficher bibliothèque. Beaucoup bibliothèques vous permet de définir le contraste ou luminosité niveau, qui affecte la consommation de courant globale. En réduisant le luminosité peut réduire considérablement la consommation d'énergie, en particulier lors de l'affichage de contenu à prédominance sombre.

10. Détails techniques et où télécharger des ressources : fiches techniques, exemples de code et plus encore

Pour utiliser efficacement le 0.91 pouce 128×32 Module d'affichage OLED dans vos projets, il est essentiel d'avoir accès aux informations pertinentes technique documentation, fiches techniques, code échantillons et autres ressources. Ces ressources fournissent des informations précieuses sur les affichage spécifications, brochage, interface, contrôleur, et la programmation.

Le document le plus important est la fiche technique du Module d'affichage OLED elle-même. Cette fiche technique est généralement fournie par le fabricant et contient des informations détaillées technique informations sur le afficher, y compris:

• Caractéristiques:Les caractéristiques électriques, telles que la tension de fonctionnement, la consommation de courant et interface timing.
• Brochage : Un schéma montrant les affectations de broches pour le module, y compris les lignes électriques, de terre et de communication.
• Interface: Détails sur le protocole de communication (I2C ou SPI), y compris les diagrammes de synchronisation et les formats de commande.
• Contrôleur:Informations sur le contrôleur puce utilisée dans le module (par exemple, SSD1306), y compris ses fonctionnalités, sa carte mémoire et son ensemble de commandes.
• Dimensions : Dessins mécaniques montrant les caractéristiques physiques taille et les trous de montage du module.

Vous pouvez généralement trouver la fiche technique de votre produit spécifique Module OLED sur le site Web du fabricant ou sur le site Web du détaillant où vous avez acheté le afficher. Certains fabricants populaires de Modules d'affichage OLED incluent Adafruit, Waveshare et divers fabricants chinois dont les produits sont vendus via des marchés en ligne comme AliExpress et Banggood.

En plus de la fiche technique, vous aurez également besoin de la documentation relative à l' bibliothèque vous utilisez pour contrôler le afficher. Par exemple, si vous utilisez Adafruit SSD1306 bibliothèque, vous pouvez trouver la documentation sur le site Web d'Adafruit ou sur le référentiel GitHub pour le bibliothèque. La documentation comprend généralement une description des fonctions disponibles, des exemples code, et détails sur la façon d'installer et d'utiliser le bibliothèque.

Voici quelques liens utiles pour trouver des ressources liées à la version 0.91 pouce 128×32 Module d'affichage OLED:

• Adafruit SSD1306 Bibliothèque (GitHub) : [https://github.com/adafruit/Adafruit\_SSD1306](https://github.com/adafruit/Adafruit_SSD1306)
• Bibliothèque Adafruit GFX (GitHub) : [https://github.com/adafruit/Adafruit-GFX-Library](https://github.com/adafruit/Adafruit-GFX-Library)
• Bibliothèque U8g2 (GitHub) : [https://github.com/olikraus/u8g2](https://github.com/olikraus/u8g2)
• SSD1306 Fiche technique (exemple de Solomon Systech) : [https://www.solomon-systech.com/en/products/oled-display-driver-ic/ssd1306/](https://www.solomon-systech.com/en/products/oled-display-driver-ic/ssd1306/)

N'oubliez pas de consulter la documentation spécifique à votre Module OLED et bibliothèque, car il peut y avoir des variations dans les fonctionnalités, les brochages et les commandes entre les différents fabricants et versions. Il est judicieux de Cliquez sur quelques liens et faites des recherches appropriées avant de démarrer un projet.

Conclusion : 10 points clés à retenir sur 0.91 Modules d'affichage OLED 128 × 32 pouces

1. Le 0.91 pouce 128×32 Module d'affichage OLED est un compact, monochrome affichage graphique qui offre contraste élevé et des angles de vision larges grâce à son OLED technologie.
2. Le Interface I2C simplifie la connexion du Module OLED aux microcontrôleurs comme le Arduino Uno, ne nécessitant que deux lignes de données (SDA et SCL) en plus de l'alimentation et de la terre.
3. Le SSD1306 est un terme couramment utilisé contrôleur puce pour 0,91 pouce 128×32 Écrans OLED, fournissant un intégré graphique tampon et gestion des détails de bas niveau de la conduite du OLED panneau.
4. Bibliothèques comme l'Adafruit SSD1306 et U8g2 simplifient le processus de contrôle du Écran OLED d'un Arduino ou autre microcontrôleur, offrant des fonctions pour dessin formes, textes et images.
5. Le afficher fonctionne généralement à 3,3 V ou 5 V, avec une consommation électrique dépendant de la luminosité réglage et le nombre de pixels qui sont allumés. La moyenne des utilisations de l'affichage environ 20 mA.
6. SPI est une alternative interface à I2C pour Écrans OLED, offrant des vitesses plus rapides mais nécessitant plus de connexions.
7. Basique dessin sur le OLED implique la manipulation d'individus pixels en utilisant des fonctions comme dessinerPixel(), tandis que des formes plus complexes peuvent être dessinées à l'aide de fonctions telles que dessiner une ligne(), dessinerRect(), et dessinerCercle().
8. Affichage texte implique de définir la police, taille, et la couleur, le positionnement du curseur et l'impression des chaînes sur le afficher en utilisant les fonctions fournies par le bibliothèque.
9. Image bitmap les images peuvent être affichées en les convertissant en un tableau d'octets où chaque bit représente un pixel et en utilisant une fonction comme dessinerBitmap() pour transférer les données vers le affichage mémoire.
10. Accéder aux fiches techniques, code échantillons, et bibliothèque la documentation est essentielle pour utiliser efficacement la version 0.91 pouce 128×32 Module d'affichage OLED. Les ressources peuvent souvent être trouvées sur les sites Web des fabricants comme Adafruit ou les référentiels GitHub pour le bibliothèques.

En comprenant ces points clés, vous serez bien équipé pour intégrer le 0.91 pouce 128×32 Module d'affichage OLED dans votre prochain projet électronique, en ajoutant un visuel net et compact interface à vos créations. N'oubliez pas que vous pouvez trouver des informations utiles tutoriel en ligne, nous pouvons également vous fournir soutien Si tu en as besoin.