Want Nazarome Chupale on a tiny 0.96" SSD1306 OLED? This project plays a 150-frame mono loop with Adafruit SSD1306. It's the same export style as the other song builds on this site, but it has its own timing and sketch file.
⬇ Free download, Nazarome Chupale OLED code
Full main.ino with all PROGMEM frames · ZIP or git clone
Parts list
- Board: ESP8266 NodeMCU / Wemos D1 Mini or ESP32 (recommended)
- Display: 0.96" SSD1306 I2C OLED, 128×64, usually
0x3C - 4 Dupont wires (VCC, GND, SDA, SCL)
- A USB cable and Arduino IDE on your computer
Connection / wiring
The sketch comment lists Uno pins (SDA A4, SCL A5). Don't use them here. You'll want an ESP board for this frame count.
| OLED pin | Arduino Uno / Nano | ESP8266 (NodeMCU) | ESP32 |
|---|---|---|---|
| VCC | 5V (or 3.3V if module requires) | 3.3V | 3.3V |
| GND | GND | GND | GND |
| SDA | A4 | D2 (GPIO4) | GPIO21 |
| SCL | A5 | D1 (GPIO5) | GPIO22 |
On ESP8266, call Wire.begin(4, 5) before display.begin() if your default I2C pins fail.
If the screen stays black, try address 0x3D and read
OLED blank screen fixes.
Libraries
- In Arduino IDE, open Tools → Manage Libraries
- Install Adafruit SSD1306
- Install Adafruit GFX Library
- Select your ESP board, set a flash size of at least 1MB, and choose the right COM port
How the player works
Frames live in const uint8_t PROGMEM frameN[1024]. You'll see loop() step the index every 147 ms:
void loop() {
static uint8_t frameIdx = 0;
static unsigned long lastMs = 0;
const uint8_t* frames[] = { frame0, frame1, /* ... */ frame149 };
const uint8_t numFrames = 150;
if (millis() - lastMs >= 147) {
lastMs = millis();
display.clearDisplay();
display.drawBitmap(0, 0, frames[frameIdx], 128, 64, SSD1306_WHITE);
display.display();
frameIdx = (frameIdx + 1) % numFrames;
}
}
Change 147 to speed the loop up or down. A smaller number gives you a higher frame rate
(example: 100 ≈ 10 fps).
Upload & run
- Open nazaromechupale and download the ZIP or clone it
- Arduino IDE requires the folder name to match the file. Rename your unzipped folder to
main, then openmain.ino - Install Adafruit GFX + SSD1306 if you haven't already
- Pick ESP8266 or ESP32, set flash size to 1MB or more, and choose your COM port
- Click Upload
- Watch Serial at 115200. If you see
SSD1306 allocation failed, check your power, wiring, or the I2C address
Ready to flash?
Grab the complete Nazarome Chupale main.ino from GitHub and flash it yourself.
Make your own song animation
I exported this sketch from oledanimationmaker.com. You can do the same:
- Open the free tool in Chrome or Edge
- Go to Import and drop in a short clip (you can use up to 200 frames)
- Tune the threshold and dither, then check your live OLED preview
- Click Get the Code → Adafruit SSD1306 Arduino
- Save the sketch and push it to your own GitHub repo
If you want more, try these guides: GIF to OLED, Video to OLED, PROGMEM flash limits.
Troubleshooting
- Sketch too big, switch to ESP8266/ESP32 with a larger flash size, or cut some of your frames
- Blank OLED, check you're on 3.3V for ESP, check SDA/SCL, then try
0x3D - Folder name error, the file is
main.ino, so you need to name the foldermain - Slow / laggy, raise the 147 ms delay if your panel can't keep up, and use solid USB power
- Doesn't play sound, this build is pictures only. Add a speaker on a separate project if you want audio
FAQ
Is the Nazarome Chupale OLED code free?
Yes, and you can get it at github.com/itzmeAshish/nazaromechupale.
Does it play audio?
No. This is a visual OLED animation. If you need the song audio, pair a speaker on its own circuit.
Can I change the clip?
Yes. Import a different GIF or video into OLED Animation Maker and export a new sketch.
Build more OLED song & GIF animations
You get a pixel editor, video import, WebSerial live preview, and Arduino & MicroPython export, free in your browser.
Open OLED Animation Maker →What the nazaromechupale sketch contains
The repo is itzmeAshish/nazaromechupale.
The song title on this page is Nazarome Chupale. The OLED side of that
title is a silent 150-frame loop. main.ino holds frame0
through frame149, each a 1024-byte PROGMEM bitmap, plus the
Adafruit player that draws them at 0x3C on a 128×64 SSD1306. You won't find a
sample of the recording or a line of lyric text in the file. If your panel is doing
its job, you see pictures only.
The sketch file is main.ino, so the folder has to be named main.
GitHub's ZIP often lands as nazaromechupale-main. Rename that directory
before you double-click the file. If you open it from the long folder name, the IDE will
offer to move the sketch, and it's easy to accept a copy that's missing the rest
of the download. This is the main layout, the same rule I used for Thangamaana,
not the code.ino layout you'll see in Kalayani or Ganesha Day 7.
setup() starts Serial at 115200 and the display. loop() is
the 147 ms walker you saw above: clear, drawBitmap of the current
pointer at 128×64, display(), then wrap with numFrames equal
to 150. You won't find buttons, brightness or a one-shot mode.
Speed table for the 147 ms player
Stock speed is 147 ms, about 6.8 fps. One pass for you is 150 × 147 ms = 22,050 ms, about 22.1 seconds. That's close to Thangamaana's 149 ms step, as you might expect, but this loop is 50 frames shorter, so your cycle ends about eight seconds sooner. It's much slower than the 67 ms Ganesha and Khayalon players, which is why you can usually get by with a default I2C clock here.
| Delay | Approx. fps | 150-frame pass | Why you'd pick it |
|---|---|---|---|
| 200 ms | 5 | 30 s | Each bitmap stays up long enough for you to see it across a room |
| 147 ms (stock) | ~6.8 | ~22.1 s | The published Nazarome Chupale timing |
| 100 ms | 10 | 15 s | A quicker loop that your 100 kHz transfer can still clear |
| 67 ms | ~15 | ~10 s | Only if you also raise the I2C clock, or accept that display() sets the pace |
The 22 second figure is the number to check with a watch. If your pass lands near 22 seconds, the stock delay is really in the binary you uploaded. If it lands near 10 seconds, the sketch on your board isn't this file's 147 ms constant anymore.
Pins the comment lists, and the pins you should use
The comment lists Uno wiring: SDA A4, SCL A5. That legend is accurate for a classic Uno or Nano, and you'll find many modules run from 5V because they carry a regulator. It's the wrong board for this binary, though. Flash your ESP and follow the ESP column.
- ESP8266 NodeMCU: 3.3V, GND, SDA on D2 (GPIO4), SCL on D1 (GPIO5). Use
Wire.begin(4, 5)if your core's default pins aren't those two. In Tools, a flash size of at least 1MB is the floor this page already names. A 4MB module is the one that won't surprise you. - ESP32: 3.3V, SDA GPIO21, SCL GPIO22. Select an ESP32 board entry, not the NodeMCU entry, even if your dupont colors look the same.
- Leave A4 and A5 for a future short export. If you wire this 150-frame file to an Uno and ignore the size error, you don't get a slower animation. You get no upload.
150 frames against a 32 KB Uno
150 × 1024 = 153,600 bytes, about 150 KB before the Adafruit libraries. Your Uno's flash is about 32 KB. That gap is the whole explanation of "sketch too big." A classic Nano is in the same box. If you lower 147 ms, you change nothing about that number. An ESP32 or a 4MB ESP8266 is the board this loop is for. A 512 KB ESP8266 profile will also fail once you add the core, so don't pick it. If your Tools menu still says 1MB with a large filesystem, the sketch region can come up short even though your chip is physically bigger. Give the sketch the space and shrink the filesystem, or move to the 4MB choice if you can.
The page's "at least 1MB" line is the minimum that can even see a 150 KB table. I'd treat
4MB as the setting you ship. If you must stay on an Uno, sample a new clip in the maker
at a tiny frame count and export a different sketch. Please don't hex-edit this
main.ino down to size. I wouldn't.
Changing 147 without breaking the wrap
Only the comparison changes: millis() - lastMs >= 147. Keep the pointer
list and keep numFrames at 150. The line
frameIdx = (frameIdx + 1) % numFrames is what returns you to
frame0 after frame149. If you set numFrames to
149 you'll never draw the last bitmap. If you set it to 151 you'll read past the
table.
For filming, 200 ms gives you a 30 second pass and makes each picture obvious. For a
busier desk piece, 100 ms gives you 15 seconds and still fits a 100 kHz transfer, unlike
a 67 ms target. You don't need Wire.setClock to enjoy the stock 147 ms
loop. Add it only if you deliberately push the delay toward the 15 fps row and your
watch no longer matches the table.
A recording that shows one full pass
I'd plan on about 25 seconds of footage at the stock delay, a little more
than the 22.1 second cycle. Frame the 0.96" glass tightly, and keep lamps out of
the reflection. Start before a picture you'll recognize and stop after that same picture
has returned. That single return proves to you that all 150 indexes ran, not just
frame0 through frame10.
Your take should be silent on the board's side. Nazarome Chupale in this project is the visual. Pairing a speaker is a different build, and you'd wire it separately. A good panel recording has crisp white pixels, a black background, and no rolling shimmer. If the shimmer speeds up when you touch the dupont housing, you've got a bad connector. If the image looks stable but "too dark," you may have picked that threshold in a re-export. The published frames are already 1-bit, so you don't retune them with the IDE.
Black screen, 0x3D, and the wrong board package
- Black screen: ESP VCC is 3.3V. GND is common. Match SDA and SCL to the table for the chip you selected, not the chip printed in the comment.
- Wrong address: make one edit, from
0x3Cto0x3D, if Serial showsSSD1306 allocation failed. Scan only after both addresses fail. If a scanner finds nothing, you have a wiring fault. If it finds 0x3C, your sketch is still calling the other address. - IDE mismatch: ESP8266 package versus ESP32 package. If you upload the wrong binary you'll get the old firmware or a boot loop, and the OLED never starts. Also confirm your port. A leftover Uno port won't program a NodeMCU.
- Not enough flash: 150 KB of frames won't link on an Uno. On ESP8266, avoid the small flash profiles. Folder name errors (
main) happen before the linker, so fix the folder first and you'll see the real size message.
Four practical questions for this build
Does Nazarome Chupale on this OLED include the song audio?
No. main.ino is a 150-frame picture loop. The name is the song title, and your display doesn't play the track.
The ZIP folder is not called main. Do I rename the file or the folder?
Rename the folder to main so it matches main.ino. That's the IDE rule for this repo, and you'll hit it on every ZIP. Then open the sketch from inside that folder.
I set the delay to 67 to match the Ganesha project and the speed barely changed. Why?
display() on a 100 kHz bus already costs on the order of 90 ms per full frame, so a delay shorter than that can't win. Use 147 or 100 if you want predictable timing. Or call Wire.setClock(400000) after the bus starts, and measure a 10 second pass before you trust 15 fps.
Which error means flash, and which error means the panel?
If you see "sketch too big," or an ESP8266 segment that doesn't fit, that's flash. Fix your board or the flash-size menu. If the sketch uploaded and Serial says SSD1306 allocation failed, that's the panel: power, SDA/SCL, or 0x3C versus 0x3D. A board-menu mismatch often looks like the second problem because nothing runs.
Related posts
Free tools: OLED Animation Maker for your SSD1306 and SH1106 animations, Assemble Studio for name and logo animations, the Shadow Box Lamp Generator for 3D-printed shadow lamps, Text to STL for 3D-printed names and keychains, and 3MF to Web to show 3D prints on any website. New: the Image to Byte Array converter, the OLED Robot Eyes generator and the Lithophane Maker. See all tools.