OLED Shield per
Modulo WeMos D1 mini

ultimo aggiornamento 11 marzo 2018


JLCPCB - 2$ per prototipi di PCB, di qualsiasi colore. Produzione in 24 ore!
L'Azienda di prototipi PCB più popolare, con oltre 700.000 clienti in tutto il mondo!
Recati presso la JLCPCB, riceverai regali e coupon gratuiti
presso Maker Faire Rome il 18-20 ottobre


 


Lo shield può essere acquistato sul sito codice WEOLED

Indice

Descrizione

L'OLED shield è un piccolo display monocromatico, il suo costo è di circa 7 €, di tipo OLED da 0,66 "64 x 48 pixel che utilizza la tecnologia di visualizzazione OLED, il modulo è concepito principalmente per essere collegato al modulo Wemos D1 Mini o Wemos Pro.

 

OurPCB, your most reliable PCB and PCBA supplier.

Focusing on PCB Prototype and PCB Assembly Turnkey Services.

One-Stop Wire Harness & Cable Assemblies Solution

 

La tipologia OLED indica che non solo il display è molto luminoso e chiaro con un elevato rapporto di contrasto ma ha un consumo energetico molto inferiore rispetto ad altri display tecnologie come l'LCD retroilluminato, è anche molto visibile sia in condizioni di oscurità totale che di luce intensa.
Per interfacciare il modulo il display utilizza un'interfaccia seriale I2C che richiede solo due pin di dati. Il circuito di reset è a bordo e significa che non è necessario un pin di reset aggiuntivo.
Sebbene il modulo sia progettato per essere utilizzato con le mini schede Wemos D1 Mini o Wemos Pro, il display OLED con il controller di visualizzazione SSD1306 (datasheet) può quindi essere utilizzato come modulo di visualizzazione con altre schede microcontrollore come Arduino
il kit del modulo comprende inoltre 2 header x 8 pin maschio-maschio, per il loro montaggio è richiesta la saldatura,permettono al modulo di essere facilmente inserito nel Mini header WeMos D1.

 

 

 

NOTA: attualmente del modulo è possibile trovare la versione V2.0.0, che implementa anche due piccoli pulsanti

Per altre informazioni ed aggiornamenti vedere la pagina originale.

 

 

Schema elettrico

Il circuito del display è molto semplice in quanto oltre al display sono presenti pochi altri componenti, sul PCB sono presenti alcune piazzole SJ1, che permettono se cortocircuitate di variare l'indirizzo I2C.

Pin utilizzati per la gestione del modulo

 

 

Vista frontale del OLED shield

Vista posteriore dello OLED shield

 

Caratteristiche

Dimensione schermo

: 64×48 pixels (0.66” diagonale 0.66 "16,8 mm)

Tensione di funzionamento

: 3.3V

Driver IC:

: SSD1306

Interfaccia

: I2C

indirizzi I2C

0x3C or 0x3D

Libreria di gestione

Per utilizzare il display OLED è necessario installare l'apposita libreria, questa può essere cercata tra le librerie installabili nell’IDE, basterà inserire nel campo "SparkFun Micro OLED", in questo caso si è installata quella nella versione 1.2.0, una volta caricata sarà mostrata la dicitura "INSTALLED".

Libreria alternativa

Oltre alla libreria realizzata da SparkFun, se ne potrà utilizzare un'altro tipo, anche in questo caso può essere cercata tra le librerie installabili nell’IDE, basterà inserire nel campo "ssd1306", e si dovrà installare quella realizzata da Adafruit + mcauser, una volta caricata sarà mostrata la dicitura "INSTALLED".

Analogamente, sempre per gestire la parte grafica occorre caricare la libreria grafica "Adafruit GFX Library", in questo caso si è scelta la versione 1.2.9, una volta caricata sarà mostrata la dicitura "INSTALLED".
Per maggiori informazioni vedere il link.

 

Programmi di test

Si possono poi installare i programmi di test per gli shield per Wemos D1 Mini, dove sono presenti le seguenti sezioni:

Importazione di una libreria .zip

La libreria può essere trovata a questa pagina, oppure direttamente da questo link.
Le librerie sono spesso distribuite come file ZIP o cartella. Il nome della cartella è il nome della libreria. All'interno della cartella ci sarà un file .cpp, un file .h e spesso un file keywords.txt, una cartella di esempi e altri file richiesti dalla libreria. A partire dalla versione 1.0.5, è possibile installare librerie di terze parti nell'IDE. Non decomprimere la libreria scaricata, lasciarla così com'è.
Per cui, nell'IDE di Arduino, andare sotto il menu Skech > #ncludi libreria>  e nella parte superiore dell'elenco a discesa, selezionare l'opzione "Aggiungi libreria .ZIP" e ricercare il file appena scaricato

a fine operazione la libreria sarà disponibile sotto fil menu File > Esempi

Test del modulo

Per il test dell'OLED Shield , si è utilizzato un modulo Wemos D1 Mini alimentato dal DC Power Shield e  montati su una Tripler Base.  Al DC Power Shield è stata collegata una batteria da 9V, collegata tramite il DC plug.

Il programma utilizzato "OLED_Clock_with_SparkFun.ino" può essere trovato nella cartella:

WEMOS D1 mini Examples > 04.Shields > OLED_Shield >Use_SparkFun_Library > OLED_Clock_with_SparkFun >

Per regolare l'ora segnata dall'orologi occre modificare le seguenti linee

// Use these variables to set the initial time
int hours = 9;
int minutes = 0;
int seconds = 0;

#include <Wire.h>  // Include Wire if you're using I2C
#include <SFE_MicroOLED.h>  // Include the SFE_MicroOLED library


#define PIN_RESET 255  //
#define DC_JUMPER 0  // I2C Addres: 0 - 0x3C, 1 - 0x3D

//////////////////////////////////
// MicroOLED Object Declaration //
//////////////////////////////////

MicroOLED oled(PIN_RESET, DC_JUMPER);  // I2C Example

// Use these variables to set the initial time
int hours = 9;
int minutes = 0;
int seconds = 0;

// How fast do you want the clock to spin? Set this to 1 for fun.
// Set this to 1000 to get _about_ 1 second timing.
const int CLOCK_SPEED = 1000;

// Global variables to help draw the clock face:
const int MIDDLE_Y = oled.getLCDHeight() / 2;
const int MIDDLE_X = oled.getLCDWidth() / 2;

int CLOCK_RADIUS;
int POS_12_X, POS_12_Y;
int POS_3_X, POS_3_Y;
int POS_6_X, POS_6_Y;
int POS_9_X, POS_9_Y;
int S_LENGTH;
int M_LENGTH;
int H_LENGTH;

unsigned long lastDraw = 0;

void initClockVariables()
{
  // Calculate constants for clock face component positions:
  oled.setFontType(0);
  CLOCK_RADIUS = min(MIDDLE_X, MIDDLE_Y) - 1;
  POS_12_X = MIDDLE_X - oled.getFontWidth();
  POS_12_Y = MIDDLE_Y - CLOCK_RADIUS + 2;
  POS_3_X  = MIDDLE_X + CLOCK_RADIUS - oled.getFontWidth() - 1;
  POS_3_Y  = MIDDLE_Y - oled.getFontHeight()/2;
  POS_6_X  = MIDDLE_X - oled.getFontWidth()/2;
  POS_6_Y  = MIDDLE_Y + CLOCK_RADIUS - oled.getFontHeight() - 1;
  POS_9_X  = MIDDLE_X - CLOCK_RADIUS + oled.getFontWidth() - 2;
  POS_9_Y  = MIDDLE_Y - oled.getFontHeight()/2;
  
  // Calculate clock arm lengths
  S_LENGTH = CLOCK_RADIUS - 2;
  M_LENGTH = S_LENGTH * 0.7;
  H_LENGTH = S_LENGTH * 0.5;
}

void setup()
{
  oled.begin();     // Initialize the OLED
  oled.clear(PAGE); // Clear the display's internal memory
  oled.clear(ALL);  // Clear the library's display buffer
  oled.display();   // Display what's in the buffer (splashscreen)
  
  initClockVariables();
  
  oled.clear(ALL);
  drawFace();
  drawArms(hours, minutes, seconds);
  oled.display(); // display the memory buffer drawn
}

void loop()
{
  
  // Check if we need to update seconds, minutes, hours:
  if (lastDraw + CLOCK_SPEED < millis())
  {
    lastDraw = millis();
    // Add a second, update minutes/hours if necessary:
    updateTime();
    
    // Draw the clock:
    oled.clear(PAGE);  // Clear the buffer
    drawFace();  // Draw the face to the buffer
    drawArms(hours, minutes, seconds);  // Draw arms to the buffer
    oled.display(); // Draw the memory buffer
  }
}

// Simple function to increment seconds and then increment minutes
// and hours if necessary.
void updateTime()
{
  seconds++;  // Increment seconds
  if (seconds >= 60)  // If seconds overflows (>=60)
  {
    seconds = 0;  // Set seconds back to 0
    minutes++;    // Increment minutes
    if (minutes >= 60)  // If minutes overflows (>=60)
    {
      minutes = 0;  // Set minutes back to 0
      hours++;      // Increment hours
      if (hours >= 12)  // If hours overflows (>=12)
      {
        hours = 0;  // Set hours back to 0
      }
    }
  }
}

// Draw the clock's three arms: seconds, minutes, hours.
void drawArms(int h, int m, int s)
{
  double midHours;  // this will be used to slightly adjust the hour hand
  static int hx, hy, mx, my, sx, sy;
  
  // Adjust time to shift display 90 degrees ccw
  // this will turn the clock the same direction as text:
  h -= 3;
  m -= 15;
  s -= 15;
  if (h <= 0)
    h += 12;
  if (m < 0)
    m += 60;
  if (s < 0)
    s += 60;
  
  // Calculate and draw new lines:
  s = map(s, 0, 60, 0, 360);  // map the 0-60, to "360 degrees"
  sx = S_LENGTH * cos(PI * ((float)s) / 180);  // woo trig!
  sy = S_LENGTH * sin(PI * ((float)s) / 180);  // woo trig!
  // draw the second hand:
  oled.line(MIDDLE_X, MIDDLE_Y, MIDDLE_X + sx, MIDDLE_Y + sy);
  
  m = map(m, 0, 60, 0, 360);  // map the 0-60, to "360 degrees"
  mx = M_LENGTH * cos(PI * ((float)m) / 180);  // woo trig!
  my = M_LENGTH * sin(PI * ((float)m) / 180);  // woo trig!
  // draw the minute hand
  oled.line(MIDDLE_X, MIDDLE_Y, MIDDLE_X + mx, MIDDLE_Y + my);
  
  midHours = minutes/12;  // midHours is used to set the hours hand to middling levels between whole hours
  h *= 5;  // Get hours and midhours to the same scale
  h += midHours;  // add hours and midhours
  h = map(h, 0, 60, 0, 360);  // map the 0-60, to "360 degrees"
  hx = H_LENGTH * cos(PI * ((float)h) / 180);  // woo trig!
  hy = H_LENGTH * sin(PI * ((float)h) / 180);  // woo trig!
  // draw the hour hand:
  oled.line(MIDDLE_X, MIDDLE_Y, MIDDLE_X + hx, MIDDLE_Y + hy);
}

// Draw an analog clock face
void drawFace()
{
  // Draw the clock border
  oled.circle(MIDDLE_X, MIDDLE_Y, CLOCK_RADIUS);
  
  // Draw the clock numbers
  oled.setFontType(0); // set font type 0, please see declaration in SFE_MicroOLED.cpp
  oled.setCursor(POS_12_X, POS_12_Y); // points cursor to x=27 y=0
  oled.print(12);
  oled.setCursor(POS_6_X, POS_6_Y);
  oled.print(6);
  oled.setCursor(POS_9_X, POS_9_Y);
  oled.print(9);
  oled.setCursor(POS_3_X, POS_3_Y);
  oled.print(3);
}

Filmato

 

 

Elenco revisioni:

11/03/2018

Emissione preliminare