Core Electronics Forum

Sparkfun Photon Micro OLED Shield - doesn't work

Hi,

I bought Sparkfun Photon Micro OLED Shield, but it doesn’t work.

I followed the SparkFun tutorial, but the screen is still blank.

Can anyone please help?

Thanks very much!
Karl

Hi Karl,

Sorry to hear you’ve run into issues! We’ve got a couple handy and will do some testing on our side. In between, and just so that we’re both on the same page, can you share your code here with the preformatted text tool?

Sure Graham, thanks for your help!

I followed the tutorial: https://learn.sparkfun.com/tutorials/photon-oled-shield-hookup-guide and copied & used the code in the tutorial, which is as below:

/*
Micro-OLED-Shield-Example.ino
SparkFun Micro OLED Library Hello World Example
Jim Lindblom @ SparkFun Electronics
Original Creation Date: June 22, 2015

This sketch prints a friendly, recognizable logo on the OLED Shield, then
  goes on to demo the Micro OLED library's functionality drawing pixels,
  lines, shapes, and text.

  Hardware Connections:
  This sketch was written specifically for the Photon Micro OLED Shield, which does all the wiring for you. If you have a Micro OLED breakout, use the following hardware setup:

MicroOLED ------------- Photon
  GND ------------------- GND
  VDD ------------------- 3.3V (VCC)
D1/MOSI ----------------- A5 (don't change)
D0/SCK ------------------ A3 (don't change)
  D2
  D/C ------------------- D6 (can be any digital pin)
  RST ------------------- D7 (can be any digital pin)
  CS  ------------------- A2 (can be any digital pin)

  Development environment specifics:
IDE: Particle Build
Hardware Platform: Particle Photon
                   SparkFun Photon Micro OLED Shield

  This code is beerware; if you see me (or any other SparkFun
  employee) at the local, and you've found our code helpful,
  please buy us a round!

  Distributed as-is; no warranty is given.
*/

//////////////////////////////////
// MicroOLED Object Declaration //
//////////////////////////////////
// Declare a MicroOLED object. If no parameters are supplied, default pins are
// used, which will work for the Photon Micro OLED Shield (RST=D7, DC=D6, CS=A2)

MicroOLED oled;

void setup()
{
  oled.begin();    // Initialize the OLED
  oled.clear(ALL); // Clear the display's internal memory
  oled.display();  // Display what's in the buffer (splashscreen)
  delay(1000);     // Delay 1000 ms
  oled.clear(PAGE); // Clear the buffer.

  randomSeed(analogRead(A0) + analogRead(A1));
}

void loop()
{
  pixelExample();  // Run the pixel example function
  lineExample();   // Then the line example function
  shapeExample();  // Then the shape example
  textExamples();  // Finally the text example
}

void pixelExample()
{
  printTitle("Pixels", 1);

  for (int i=0; i<512; i++)
  {
oled.pixel(random(oled.getLCDWidth()), random(oled.getLCDHeight()));
oled.display();
  }
}

void lineExample()
{
  int middleX = oled.getLCDWidth() / 2;
  int middleY = oled.getLCDHeight() / 2;
  int xEnd, yEnd;
  int lineWidth = min(middleX, middleY);

  printTitle("Lines!", 1);

  for (int i=0; i<3; i++)
  {
for (int deg=0; deg<360; deg+=15)
{
  xEnd = lineWidth * cos(deg * M_PI / 180.0);
  yEnd = lineWidth * sin(deg * M_PI / 180.0);

  oled.line(middleX, middleY, middleX + xEnd, middleY + yEnd);
  oled.display();
  delay(10);
}
for (int deg=0; deg<360; deg+=15)
{
  xEnd = lineWidth * cos(deg * M_PI / 180.0);
  yEnd = lineWidth * sin(deg * M_PI / 180.0);

  oled.line(middleX, middleY, middleX + xEnd, middleY + yEnd, BLACK, NORM);
  oled.display();
  delay(10);
}
  }
}

void shapeExample()
{
  printTitle("Shapes!", 0);

  // Silly pong demo. It takes a lot of work to fake pong...
  int paddleW = 3;  // Paddle width
  int paddleH = 15;  // Paddle height
  // Paddle 0 (left) position coordinates
  int paddle0_Y = (oled.getLCDHeight() / 2) - (paddleH / 2);
  int paddle0_X = 2;
  // Paddle 1 (right) position coordinates
  int paddle1_Y = (oled.getLCDHeight() / 2) - (paddleH / 2);
  int paddle1_X = oled.getLCDWidth() - 3 - paddleW;
  int ball_rad = 2;  // Ball radius
  // Ball position coordinates
  int ball_X = paddle0_X + paddleW + ball_rad;
  int ball_Y = random(1 + ball_rad, oled.getLCDHeight() - ball_rad);//paddle0_Y + ball_rad;
  int ballVelocityX = 1;  // Ball left/right velocity
  int ballVelocityY = 1;  // Ball up/down velocity
  int paddle0Velocity = -1;  // Paddle 0 velocity
  int paddle1Velocity = 1;  // Paddle 1 velocity

  //while(ball_X >= paddle0_X + paddleW - 1)
  while ((ball_X - ball_rad > 1) && 
     (ball_X + ball_rad < oled.getLCDWidth() - 2))
  {
// Increment ball's position
ball_X+=ballVelocityX;
ball_Y+=ballVelocityY;
// Check if the ball is colliding with the left paddle
if (ball_X - ball_rad < paddle0_X + paddleW)
{
  // Check if ball is within paddle's height
  if ((ball_Y > paddle0_Y) && (ball_Y < paddle0_Y + paddleH))
  {
    ball_X++;  // Move ball over one to the right
    ballVelocityX = -ballVelocityX; // Change velocity
  }
}
// Check if the ball hit the right paddle
if (ball_X + ball_rad > paddle1_X)
{
  // Check if ball is within paddle's height
  if ((ball_Y > paddle1_Y) && (ball_Y < paddle1_Y + paddleH))
  {
    ball_X--;  // Move ball over one to the left
    ballVelocityX = -ballVelocityX; // change velocity
  }
}
// Check if the ball hit the top or bottom
if ((ball_Y <= ball_rad) || (ball_Y >= (oled.getLCDHeight() - ball_rad - 1)))
{
  // Change up/down velocity direction
  ballVelocityY = -ballVelocityY;
}
// Move the paddles up and down
paddle0_Y += paddle0Velocity;
paddle1_Y += paddle1Velocity;
// Change paddle 0's direction if it hit top/bottom
if ((paddle0_Y <= 1) || (paddle0_Y > oled.getLCDHeight() - 2 - paddleH))
{
  paddle0Velocity = -paddle0Velocity;
}
// Change paddle 1's direction if it hit top/bottom
if ((paddle1_Y <= 1) || (paddle1_Y > oled.getLCDHeight() - 2 - paddleH))
{
  paddle1Velocity = -paddle1Velocity;
}

// Draw the Pong Field
oled.clear(PAGE);  // Clear the page
// Draw an outline of the screen:
oled.rect(0, 0, oled.getLCDWidth() - 1, oled.getLCDHeight());
// Draw the center line
oled.rectFill(oled.getLCDWidth()/2 - 1, 0, 2, oled.getLCDHeight());
// Draw the Paddles:
oled.rectFill(paddle0_X, paddle0_Y, paddleW, paddleH);
oled.rectFill(paddle1_X, paddle1_Y, paddleW, paddleH);
// Draw the ball:
oled.circle(ball_X, ball_Y, ball_rad);
// Actually draw everything on the screen:
oled.display();
delay(25);  // Delay for visibility
  }
  delay(1000);
}

void textExamples()
{
  printTitle("Text!", 1);

  // Demonstrate font 0. 5x8 font
  oled.clear(PAGE);     // Clear the screen
  oled.setFontType(0);  // Set font to type 0
  oled.setCursor(0, 0); // Set cursor to top-left
  // There are 255 possible characters in the font 0 type.
  // Lets run through all of them and print them out!
  for (int i=0; i<=255; i++)
  {
// You can write byte values and they'll be mapped to
// their ASCII equivalent character.
oled.write(i);  // Write a byte out as a character
oled.display(); // Draw on the screen
delay(10);      // Wait 10ms
// We can only display 60 font 0 characters at a time.
// Every 60 characters, pause for a moment. Then clear
// the page and start over.
if ((i%60 == 0) && (i != 0))
{
  delay(500);           // Delay 500 ms
  oled.clear(PAGE);     // Clear the page
  oled.setCursor(0, 0); // Set cursor to top-left
}
  }
  delay(500);  // Wait 500ms before next example

  // Demonstrate font 1. 8x16. Let's use the print function
  // to display every character defined in this font.
  oled.setFontType(1);  // Set font to type 1
  oled.clear(PAGE);     // Clear the page
  oled.setCursor(0, 0); // Set cursor to top-left
  // Print can be used to print a string to the screen:
  oled.print(" !\"#$%&'()*+,-./01234");
  oled.display();       // Refresh the display
  delay(1000);          // Delay a second and repeat
  oled.clear(PAGE);
  oled.setCursor(0, 0);
  oled.print("56789:;<=>?@ABCDEFGHI");
  oled.display();
  delay(1000);
  oled.clear(PAGE);
  oled.setCursor(0, 0);
  oled.print("JKLMNOPQRSTUVWXYZ[\\]^");
  oled.display();
  delay(1000);
  oled.clear(PAGE);
  oled.setCursor(0, 0);
  oled.print("_`abcdefghijklmnopqrs");
  oled.display();
  delay(1000);
  oled.clear(PAGE);
  oled.setCursor(0, 0);
  oled.print("tuvwxyz{|}~");
  oled.display();
  delay(1000);

  // Demonstrate font 2. 10x16. Only numbers and '.' are defined. 
  // This font looks like 7-segment displays.
  // Lets use this big-ish font to display readings from the
  // analog pins.
  for (int i=0; i<25; i++)
  {
oled.clear(PAGE);            // Clear the display
oled.setCursor(0, 0);        // Set cursor to top-left
oled.setFontType(0);         // Smallest font
oled.print("A0:");          // Print "A0"
oled.setFontType(2);         // 7-segment font
oled.print(analogRead(A0));  // Print a0 reading
oled.setCursor(0, 16);       // Set cursor to top-middle-left
oled.setFontType(0);         // Repeat
oled.print("A1:");
oled.setFontType(2);
oled.print(analogRead(A1));
oled.setCursor(0, 32);
oled.setFontType(0);
oled.print("A7:");
oled.setFontType(2);
oled.print(analogRead(A7));
oled.display();
delay(100);
  }

  // Demonstrate font 3. 12x48. Stopwatch demo.
  oled.setFontType(3);  // Use the biggest font
  int ms = 0;
  int s = 0;
  while (s <= 50)
  {
oled.clear(PAGE);     // Clear the display
oled.setCursor(0, 0); // Set cursor to top-left
if (s < 10)
  oled.print("00");   // Print "00" if s is 1 digit
else if (s < 100)     
  oled.print("0");    // Print "0" if s is 2 digits
oled.print(s);        // Print s's value
oled.print(":");      // Print ":"
oled.print(ms);       // Print ms value
oled.display();       // Draw on the screen
ms++;         // Increment ms
if (ms >= 10) // If ms is >= 10
{
  ms = 0;     // Set ms back to 0
  s++;        // and increment s
}
delay(1);
  }
}

// Center and print a small title
// This function is quick and dirty. Only works for titles one
// line long.
void printTitle(String title, int font)
{
  int middleX = oled.getLCDWidth() / 2;
  int middleY = oled.getLCDHeight() / 2;

  oled.clear(PAGE);
  oled.setFontType(font);
  // Try to set the cursor in the middle of the screen
  oled.setCursor(middleX - (oled.getFontWidth() * (title.length()/2)),
             middleY - (oled.getFontWidth() / 2));
  // Print the title:
  oled.print(title);
  oled.display();
  delay(1500);
  oled.clear(PAGE);
}

Hi Karl,
Along with copying the code, have you also included the required libraries as mentioned just above the code block? Remember that with Particle.io you need to use the Library tab and include it in your app, not just copy the #include tag.

Yes Sam, I did. The code was successfully complied and downloaded to the Photon.

Hmm that’s strange. I just tested the code on a Photon and it functions as it should. So your code this (line for line):
// This #include statement was automatically added by the Particle IDE.
#include “SparkFunMicroOLED/SparkFunMicroOLED.h”
#include “math.h”

Like I mentioned, I follow the tutorial and did this:

  • This will lead you to list of all your apps - click on the name of the app you just created, and you should see a statement like #include “SparkFunMicroOLED/SparkFunMicroOLED.h” at the top of your app.
  • Last thing is to add the math library to our sketch - on the line below the first #include statement, type in: #include “math.h”

Now that we’ve included the library in our app, let’s give it some code - just copy the demo code below and paste it into your app, below the include statements.

Also, the code was successfully verified and compiled. I think that means I included everything that I needed. I even tried to make the LED on/off in between the statements:

  pixelExample();  // Run the pixel example function
  lineExample();   // Then the line example function
  shapeExample();  // Then the shape example
  textExamples();  // Finally the text example

in void loop(). The LED was working but the screen was still blank.

Ok, just making sure because the extra step you have to go to for the library inclusions can be a little convoluted and has caught me out a few times when I’ve just written a #include tag in. It sounds like it could be a hardware issue. Do you have another Photon board you could try and test with?

Unfortunately no, I have only one Photon plus this shield.

Have you tried any other projects with the Photon? Could you take a close look at your shield board and check to see if there are any damaged traces or bad solder joints? Perhaps upload some photos

I’ve tried some other projects on Photon without the OLED shield. They were all running OK.

I read the comments on Sparkfun website for this product, I noticed someone else encountered similar issue. So as they suggested I took a close look at the shield after I realised something went wrong, especially around the spot of the ribbon cable. To be honest I didn’t find anything noticeable.

Hi guys,

I’m wondering, what if it’s really a hardware issue? If it is, what’s the next step?

A. You guide me to try to fix it by myself ?

or 

B. I post it back to get it replaced or refund ?

It looks like we are doing A now. I don’t mind to try if it’s possible, but if I made things worse (like accidentally cut the cable or smash the screen or damage the soldering pad, etc.), can I still get support or refund ?

Thanks!

Hi Karl,

Our thoughts exactly. If you shoot an email through to support@core-electronics.com.au we can help sort this out.

OK, thanks Sam!