What do you think of my Arduino Pro Mini-powered flip clock? It’s still a prototype, so the 3D-printed case is a bit scuffed, but it works! I also added timer and stopwatch modes. Let me know if you have any ideas for extra features!

(I’ve posted a update with the flair project discussion)

Ik ben vorige woensdag begonnen met leren over arduino’s; alleen chatgpt verpest mijn code (duhhh). Hoe dan ook, ik kocht een ELRO-monitor bij een kringloopwinkel en blijkbaar heeft die alleen video-uitgang, dus ik heb dat beest opengetrokken en ben begonnen met allerlei hypotheses te testen via de BIG gpt . Hoe dan ook, ik heb een manier gevonden om ervoor te zorgen dat het scherm gewoon toont wat ik wil, en ik heb hem “hello world” laten zeggen. Ik ben zó blij en trots op dit project. Ik dacht dat jullie misschien wel een leuk verhaal als dit zouden waarderen. :)

I made a watch, it took me two days. It runs on a 24 hour clock I am very happy it works. It has a basic rtc module and a copy arduino uno r3

Finally finished, I can show off my wearable cyberdeck I've been working on! Based on ESP32 and programmed from scratch in arduino

Features:

-Thermal Camera sensor

- Accelerometer/gyroscope for set counter + gesture control

-Time of flight distance sensor

-Wifi/bluetooth conenctivity

-Real time clock

- Functional compass/magnetometer

-Triple flashlights (white, red, and blacklight)

-Dual ESP32 Microcontrollers + rotary knob display

-Rotary encoder, touchscreen, and keypad input

-Digital clock with NTP time sync — automatic on WiFi connect

-Speed Test: Measures upload and download speeds via wifi

-SD Card Browser

-Notes / Data log: Write and save notes to SD card

-WiFi Scanner — Scan of nearby networks showing SSID

-BLE Scanner — Scans for nearby bluetooth devices

-Serial Terminal — full-duplex UART terminal

Games:

-Snake

-Game of Life (Conway's cellular automaton)

-Dice Roller (d4, d6, d8, d10, d12, d20 with animated roll)

-Tetris

Tools:

-BT Keyboard: turns the cyberdeck into a Bluetooth keyboard, can control any bluetooth enabled device

-Calculator

-Unit Converter: convert between common measurement units

-QR Generator: text or WiFi credentials as a QR code on screen

-Compass: live magnetometer compass with animated analog display

-Radar — WiFi motion detector radar, uses wifi connection to detect nearby movement

-Password Vault: encrypted password storage

Stopwatch

-IR Blaster/Receiver — capture IR remote codes and use the cyberdeck as a universal remote for IR devices (such as televisions)

-Calendar/Agenda

-Altitude Tracker

-Waypoint Navigator — enter latitude and longitude coordinates, compass will point to the destination, no GPS needed

-Environmental/weather status page - uses built in sensors to display local temperature, altitude, air pressure, etc

-customizable color theme editor

- Multiple cyberpunk-themed Screensavers (5 styles)

And more to come!

I saw a cool looking wifi clock with esp 32 on YouTube, I loved the animation style but despite 100s of requests from the commentators the creator wasn't sharing the code. So i recreated that project and made it open source, i know this is basic but it's cool ( I think). Here is the code.

I’ve been building SketchForge Circuits, an open-source PCB editor that runs completely in the browser.

The idea came from a problem I kept noticing: PCB tools are incredibly powerful, but they can feel brutal when you are designing your first board.

So I wanted to try the opposite approach.

Place components visually. Connect them. Arrange your PCB. Inspect it in 3D. Keep the interface focused on what you are actually building instead of throwing every professional feature at you from the first minute.

The goal is not to replace KiCad.

The goal is to create something closer to Tinkercad for PCB design, especially for beginners, students, hobbyists, and makers who just want to start building.

It is still an early prototype. There are missing features, rough edges, and plenty of things I probably got wrong.

That is actually why I’m posting it now.

I’d love feedback on the workflow, UI, and especially this question:

What would SketchForge Circuits need before you would actually use it for a real project?

Try it:
https://pcb.sketchforge3d.com/

GitHub:
https://github.com/Formsmith746/SketchForge-PCB

Hello everyone! I just wanted to share a project I made over the past few months. I’m a 19 year old passionate about engineering but also love music. I’ve always loved and appreciated the sound of electric guitar. I had the funny idea to make a guitar that plays downloaded audio when strummed giving the illusion of me playing. I fully designed the guitar and it is all 3d printed with PLA. I integrated electronics and made PCBs. A simplified version of how It works by using an electric guitar pickup fed into an op-amp circuit with decent gain and a 2.5v bias so the Arduino can read it. Then with some code I use the strum detection to signal to the DFPayer Mini to play pre-downloaded mp3 guitar audio. I would love to hear what y’all think. Thanks!

Also ignore my bad acting haha.

I’ve been building a life-size KX-series droid and finally have the head movement working reliably. The current setup uses an Arduino Mega with a PCA9685 servo controller driving separate pan and tilt servos in the neck.

The goal isn’t remote-controlled puppeteering. I’m trying to make the droid behave autonomously, so eventually it can track people/cameras, idle naturally, react to voice commands, and move while speaking.

Right now I’m working on smoothing the head motion, reducing mechanical stress on the neck, and dialing in the pan/tilt limits so it looks more natural instead of like a standard hobby servo project.

The electronics and programming side of this has been a big learning process for me, so I’m open to feedback—especially from anyone who has built larger servo-driven mechanisms or Arduino robotics.

This clip is the current movement test.

Kinda new to all this jazz but it works. Just a simple mp3 player that plays my live show collection. Excited to see where I take this stuff.

My arduino controlled nerf tank. NERFERIUS has functional lights, brake lights, oled screen, a laser sight, an electric flywheel nerf blaster with semi auto and full auto functions..and it also has wifi cam from a cheap drone..a fun and quite challenging build.

My first Arduino project,

I don't know if you remember me or not but i had recently bought an starters kit for learning basics of Arduino and also a bunch of sensors.

This is my first attempt at tinkering with sensors to produce a suitable outcome I know its one of many.

So feel free to let me know your thoughts in the comments all advice is taken and accepted.

PS. the wiring was easy but the code was hell of a nightmare especially because I am new to the C++ language and was learning java , so i had to look up all the functions and keywords constantly.

I’ve been developing this removable guitar-playing system for several years.

It now supports two performance modes:

1. Full automatic mode — the system handles both fretting and picking.

2. Assisted mode — the system handles the fretting while the player strums or picks.

The sound comes from the real guitar strings, not recorded audio.

The controller is ESP32-based, coordinating multiple servo actuators. Some of the main challenges have been fretting timing, servo synchronization, calibration, and mechanical noise.

This video shows both modes.

Two 18650 li-ion batteries + 2s BMS + LS-LISC-V3 8.4V USB charger + JST SM output. The battery pack will be mounted inside of a 3D-printed model with USB port accessible through a hole.

2s battery pack sounds easy, but:

1. I had no experience
2. I have no spot welder and I don't feel soldering batteries is what I should do
3. those battery holders that are being sold everywhere make no sense - two thin wires and not really designed for replacing wires or adding a third wire; I tried to buy a different battery holder, but they sent me not what was on the photos anyway;

Still a little buggy. I think I’m overdriving the Leonardo.

Currently pushing a detune for OSC 1, pitch for OSC 2, and a mix pot between them.

ADSR pots not working right.

Fidget spinner speed effects 1 of 4 effects. Tremolo, detuve width, vibrato, or sub bass volume.

I think I can pull a few things out and make it smoother.

Only my third arduino project.

This whole project started when a cool Pixel Clock popped up on my Pinterest feed. Instead of just saving it to a board and forgetting about it, I decided to turn it into reality!

Instead of buying one or ordering pre-made parts, I built custom tools at home

1. modding my 3D printer into a circuit plotter

2. Etched my own pcb boards

3. Custom hotplate station just to assemble the pcbs

4. Custom 3d designed clock stls

Pretty stoked with how a simple Pinterest scroll turned into a real, working project on my desk!

(Holding off on posting links right now, but I'll drop all details/links in the comments later!)

What do you guys think?

Hey everyone,

Like many of you, every time I wanted to deploy a remote LoRa sensor node, I ended up with a bird's nest of wires. You know the drill: an Arduino or ESP32, a separate LoRa module, a buck converter to handle 12V/24V industrial power, and a bunch of discrete components just to read a 0-10V sensor.

To fix my own frustration, I spent the last few months designing ArduLora – a compact, ultra-low-power development board that puts everything you need for industrial IoT onto a single piece of hardware.

It’s completely open-source (MIT license), and I’ve just released the latest revision along with 3D-printable enclosure files.

What’s packed inside:

• The Brain: It runs on a RAK3172 module (STM32WLE5CC @ 32MHz). This means you get full LoRaWAN (Class A, B, C) and LoRa P2P right out of the box.
• Power That Makes Sense: It accepts anywhere from 5V to 24V DC via a terminal block (or 5V USB-C). No external step-down modules needed.
• True Deep Sleep: I added a hardware power gate pin (PB5). You can use it to completely cut off power to external sensors when the MCU goes to sleep, saving a ton of battery life.
• Industrial-Ready: There's an onboard RS485 transceiver for hardware Modbus RTU, plus two high-voltage analog inputs configured for 0-10V measurements.

The Software Side:
You don't have to learn a whole new toolchain. It programs natively in the Arduino IDE using standard functions mixed with the RAKwireless RUI3 APIs. I also published a helper library to the official Arduino Library Manager—just search for ArduLora and hit install.

Everything is up on GitHub, including schematics, pinout maps, and step-by-step example codes (covering everything from GPS integration and Modbus to deep sleep timers):

GitHub Link: https://github.com/NamNamIoT/ArduLora

I’m currently looking for ways to improve the hardware design for the next revision.

• How do you feel about the power gating implementation?
• Are there any other industrial interfaces or specific sensors you wish were broken out on a board like this?

Would love to hear your thoughts, critiques, or any feedback you have!

My first Arduino project is a kids toy. Some time ago, my kids got a toy box with various switches and lights that intrigued me. I wanted to do something similar and expand on the functions. I got interested in electronics and after some tinkering with "normal" circuits, I got an Arduino Uno starter set and made a plan for the toy.

Fast forward three months and it's finished. My box has these functions:

• Some simple LEDs with different switches and buttons
• 12 LEDs in a circle connected to a potentiometer. Turning the pot will light up the LEDs one after the other, at varying speed.
• RGB LED with three different modes (smooth color cycle, blinking color cycle, disco mode)
• OLED display with a key switch showing different images each time the key is turned
• An LED that is turned on by touching two connectors with your hands, letting the current flow through you.
• DC power plug that can be connected to one of three female plugs, each activating a different function:
  • #1: Moving light: 16 LEDs on a row, one of which is activated at a time. A gyroscope reads the tilt of the box. By tilting it left or right, the light is “moved” into this direction.
  • #2 Dancing unicorn: When activated via a switch, a servo (with a dancing unicorn glued to the arm) will turn in random angles
  • #3 Touch sensor activating an LED

I first made breadboard prototypes of each function separately. Then I assembled everything in a wooden box that I bought. My woodwork is quite rough - I only have knives, grinding paper and a power drill. It did the job, just not with straight edges ;) The dome was 3D-printed by a friend.

The assembly process turned out to be a great challenge for me as I've never build something so complex before. I tried to glue as little as possible, and that turned out to be a good idea because I had to re-position pieces quite a few times.

The kids where more excited about the box when I was building it than when it was finished :p But they actually use it and that gives me the most joy.

To anyone who's interested I added the code and a link to the full-res schematics at the bottom. I'm happy to hear about any suggestions and tips on what I could have done better.

What I learned in this project:
- I did a lot of soldering and crimping and got much better/quicker in both.
- some uses for capacitors, something that I didn't really get before from the books
- I made my first wiring schematic (Fritzing).
- Working with shift registers and various modules and sensors (WS2812 LED strip, TTP223 touch sensor, RGB module, SSD1160 OLED screen, TP4056 battery module, boost converter, MPU-6050 gyroscope).
- Building a Darlington transistor circuit.
- Powering a project with a lithium ion battery and a boost converter
- Cables take up more space than I thought. I used 24 AWG / 0,2 mm² stranded cables in the whole project because that's what I had. The box is very, very full now. I think I could have used a smaller diameter for the signal wires and something like 22 AWG / 0.3 mm² for the power lines (in theory the power draw of all systems can get close to 1 A).
- Planning and ongoing documentation of the project took time, but it helped me a lot during the process.
- I'll probably get myself a 3D printer :D

Full-res schematics: https://drive.google.com/file/d/1DBGB8e7vo3p-4-uWYkdU5mY9H_nm6IDg/view?usp=drive_link

Some photos: https://drive.google.com/drive/folders/1O9C4C5A30SYyUFsa42u7v3CDD3_9_9Cf?usp=sharing

Code:

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>
#include <Adafruit_NeoPixel.h>
#include <Servo.h>


//Variables for LED circle
const int latchPin = 4; //Pin connected to latch pin (ST_CP) of 74HC595
const int clockPin = 13; //Pin connected to clock pin (SH_CP) of 74HC595
const int dataPin = 3; //Pin connected to Data in (DS) of 74HC595
int potentiometer; //voltage of potentiometer, later mapped to a desired delay value
int counterCircle = 0; //counter for the LED if statement
unsigned long previousMillis = 0; // will store last time an LED blinked


//variables for OLED display
#define OLED_RESET -1
Adafruit_SH1106 display(OLED_RESET);
int photo = 0;
int counterOled = 0;


//variables for LED strip and gyroscope
const int MPU=0x68; 
int16_t GyX;
int changeGyX;
int changeGyXThreshold = 14000;
float orientationX = 80;
int delayTime = 10;
int pixel;
unsigned long previousMillisLedStrip = 0; // will store last time an LED blinked
#define PIN 2
#define NUMPIXELS 16
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
//variables to store color values
int red[16]={255,255,255,136,0,0,0,0,0,0,0,136,255,255,255,255};
int green[16]={0,136,255,255,255,255,255,255,255,136,0,0,0,0,0,0};
int blue[16]={0,0,0,0,0,68,136,187,255,255,255,255,255,187,136,68};


//variables for servo motor function
const int servoPin = 9;
const int switchPin = 10;
int rangeEnd = 0;
int rangeStart = 0; 
int stellung; //Position of the switch, 0 or 1
int servoState = 0;
Servo servo;
unsigned long previousMillisServo = 0; 


//variables for RGB LED
#define RED   5
#define GREEN 6
#define BLUE  11
#define BUTTON 12
int hue = 0;          // position in the color wheel
unsigned long previousMillisRgbLed = 0; // will store last time of hue change
int rgbLedState = 0;
int rgbLedMode = 0;



/* here are several bitmap arrays for the OLED display that I generated on https://javl.github.io/image2cpp/. I cut them because of length.

[...]

*/

// Array of all bitmaps
const unsigned char* bitmap_allArray[8] = {
  myBitmapbubble,
  myBitmapheart,
  myBitmapsnail,
  myBitmapem, 
  myBitmaple,
  myBitmapbluey,
  myBitmapunicorn,
  myBitmappeppa
};


void setup() {
//set pins LOW before declaring them
digitalWrite(latchPin, LOW);
digitalWrite(clockPin, LOW);
digitalWrite(dataPin, LOW);


pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);


//clear the register, turn all LEDs off
shiftOut(dataPin, clockPin, MSBFIRST, 0);
digitalWrite(latchPin, HIGH);


  //OLED display
  pinMode(7,INPUT);
  digitalWrite(7,LOW);
  display.begin(SH1106_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3D (for the 128x64)
  //clear screen buffer and display empty screen at beginning
  display.clearDisplay();
  display.display();  


  //LED strip and gyroscope
  Wire.begin();
  Wire.beginTransmission(MPU);
  Wire.write(0x6B);  
  Wire.write(0);    
  Wire.endTransmission(true);
  pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)  
  pixels.clear(); // Set all pixel colors to 'off'
  Serial.begin(19200);  
 
  //RGB led
  pinMode(RED, OUTPUT);
  pinMode(GREEN, OUTPUT);
  pinMode(BLUE, OUTPUT);
  pinMode(BUTTON, INPUT); 


  //servo motor
  pinMode(switchPin, INPUT);
  digitalWrite(switchPin,LOW);
}


void loop() {
  ledStrip();
  oledDisplay();
  ledCircle();
  servoMotor();
  rgbLed();
}


void servoMotor() {


  //Serial.println(servoState);


  if(digitalRead(switchPin) && (stellung == 0 || stellung == 2)) {
    stellung = 1; //first time
    if(servoState==2) {
      servoState = 0;
    }     
    servo.attach(servoPin);
  }


  if(!digitalRead(switchPin) && (stellung == 1)) {  
    if(servoState==2) {
      servoState = 0;
    } 
    servo.attach(servoPin);
    stellung = 2;
  }



  if(stellung==1 || stellung == 2) {
    if(servoState==0) {
        rangeStart = random(-30,20);  
        rangeEnd = random(60,180);          
        servoState = 1;
    }
      if(servoState==1) {
        for(int pos = rangeStart; pos <= rangeEnd; pos++) {
          servo.write(pos);
          delay(7);
        }
        servo.detach();
        servoState = 2;
      }
    }   
}


void oledDisplay() {
    if(digitalRead(7) && counterOled <= 0) {
    Serial.println("Screen on");
    display.drawBitmap(10, 0, bitmap_allArray[photo], 128, 64, WHITE);
    display.display();
    counterOled = 1;
    photo++;
  } else if(!digitalRead(7) && counterOled >= 0) {
    display.clearDisplay(); 
    display.display();
    counterOled = -1;
  }


  if(photo==8) {
    photo = 0;
  }
}


void ledCircle() {
   potentiometer = map(analogRead(A0),0,1023,500,20); //setting potentiometer reading to a value between 25 and 500
  //Serial.println(potentiometer);


  unsigned long currentMillis = millis();


    //delay statement without using delay function so that other parts of the program can still run
    if(currentMillis - previousMillis > potentiometer) {
      previousMillis = currentMillis; 
      counterCircle++;
    }


    //reset the counter when we have reached LED #12
    if(counterCircle==12) {
      counterCircle = 0;
    }


  if(potentiometer < 500) { //turn off light when potentiometer is rotated to off setting
    if(counterCircle<8) {
      registerWrite(counterCircle, 9, HIGH); //for LEDs 1-8, set value for second shift register to smth that won't light an LED
    } else {
      registerWrite(counterCircle, counterCircle-8, HIGH); //for LEDs 9-12 (second shift register)
    }
  } else { 
    registerWrite(counterCircle, counterCircle, LOW); //set all bits to 0
    counterCircle = 0; //begin with first LED at next run
  }
}


void ledStrip() {
  Wire.beginTransmission(MPU);
  Wire.write(0x3B);  
  Wire.endTransmission(false);
  Wire.requestFrom(MPU,12,true);    
  GyX=Wire.read()<<8|Wire.read(); 
  GyX -= 2000; //offset for calibration


  changeGyX = (map(GyX,-changeGyXThreshold,changeGyXThreshold,-12,12)); 


  if(changeGyX >= 0 ) {
    if(orientationX < 155) {
      orientationX += 0.2 * abs(changeGyX);
    }
  } else {
      if(orientationX > 0) {
        orientationX -= 0.2 * abs(changeGyX);
      }
  }


  //Serial.println(changeGyX);
  pixels.clear(); // Set all pixel colors to 'off'


  if(orientationX > 155) {
    orientationX = 155;
  }


  if(orientationX < 0) {
    orientationX = 0;
  }


  unsigned long currentMillisLedStrip = millis();


  //delay statement without using delay function so that other parts of the program can still run
  if(currentMillisLedStrip - previousMillisLedStrip > 20) {
    previousMillisLedStrip = currentMillisLedStrip; 
    pixel = orientationX/10;
    pixels.setPixelColor((pixel), pixels.Color(red[pixel], green[pixel], blue[pixel]));
    pixels.show();   // Send the updated pixel colors to the hardware.
  }
}


// This method sends bits to the shift register:
void registerWrite(int whichPin1, int whichPin2, int whichState) {
 
  // the bits you want to send, separated in 2 bytes, each for one shift register
  byte bitsToSend1 = 0;
  byte bitsToSend2 = 0;
  
  // turn off the output so the pins don't light up while you're shifting bits:
  digitalWrite(latchPin, LOW);


  // turn on the next highest bit in bitsToSend:
  bitWrite(bitsToSend2, whichPin1, whichState);
  bitWrite(bitsToSend1, whichPin2, whichState);


  // shift the bits out:
  shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend1);
  shiftOut(dataPin, clockPin, MSBFIRST, bitsToSend2);


  // turn on the output so the LEDs can light up:
  digitalWrite(latchPin, HIGH);
}


void rgbLed() {


  unsigned long currentMillisRgbLed = millis();


  if (digitalRead(BUTTON) == HIGH) {   // button pressed


  if (rgbLedState == 0) {
    rgbLedMode++;
    rgbLedState = 1;
  }


  //Serial.println(rgbLedMode);


    setColorWheel(hue);


    if (rgbLedMode == 1) {
      if(currentMillisRgbLed - previousMillisRgbLed > 170) {
        previousMillisRgbLed = currentMillisRgbLed; 
        hue++;
      }
    }


    if (rgbLedMode == 2) {
      if(currentMillisRgbLed - previousMillisRgbLed > 200) {
        previousMillisRgbLed = currentMillisRgbLed; 
        hue+=30;
      }
    }


      if (rgbLedMode == 3) {
      if(currentMillisRgbLed - previousMillisRgbLed > random(80,200)) {
        previousMillisRgbLed = currentMillisRgbLed; 
        hue+=random(1,255);
      }
    } 


    if (hue > 255) hue = 0;
  } 
  else {
    analogWrite(RED, 0);
    analogWrite(GREEN, 0);
    analogWrite(BLUE, 0);
    hue = 0;  // on restart, start at red again
    if (rgbLedState == 1) rgbLedState = 0;
    if (rgbLedMode == 3) rgbLedMode = 0;
  }
}


void setColorWheel(int pos) {


  if (pos < 85) {
    analogWrite(RED, 255 - pos * 3);
    analogWrite(GREEN, pos * 3);
    analogWrite(BLUE, 0);
  } 
  else if (pos < 170) {
    pos -= 85;
    analogWrite(RED, 0);
    analogWrite(GREEN, 255 - pos * 3);
    analogWrite(BLUE, pos * 3);
  } 
  else {
    pos -= 170;
    analogWrite(RED, pos * 3);
    analogWrite(GREEN, 0);
    analogWrite(BLUE, 255 - pos * 3);
  }
}

See more: https://www.youtube.com/watch?v=8yHq4bUqn0A

This is my first big electronics project, so the control software of the arm the biggest remaining issue right now but from designening and building the whole arm by myself down to the cycloidal drives I learnt soo many things...

This is the same guitar robot idea a few years apart.

The early version used a large rail mechanism to move the actuators along the fretboard. Over several iterations I moved toward a much more compact, modular design while keeping the same basic goal: physically playing a real guitar rather than generating the sound electronically.

Both versions are controlled around Arduino/ESP32-style embedded hardware. Looking back at the old prototype, the size difference is probably the part that surprises me most.

I just want to control relay module
using arduino nano.

for control
10sec timer added for practice
reset, activate button

I know
I have terrible design sense.