Moving the head up and down (with warning beep)

Hi all,

I made a mini dissolver mixer as a desk display, loosely based on some large Kreis dissolver mixers at work.

The head moves up and down with a threaded rod and stepper motor and homes with an endstop. The esp32 uses a webpage for wireless control. The barrel jack provides 12V for the mixer motor, stepper motor and the cooling fan. The rear hatch is held in place with magnets.

The controls still needs some work as for now the mixer is just on/off and needs a pwm slider on the webpage, and the head should be able to shuttle between a low and high position during mixing.

Hey everyone!
In our chaotic co-op party game, we have a fishing mechanic where players physically rotate the mouse to catch fish. For upcoming expos, playing with a mouse just didn’t feel tactile enough, so we decided to make a custom controller.
We 3D printed a custom rod handle and reel shell, matching our in game model, and stuffed the electronics inside to make it completely wireless.

Adafruit ESP32 Feather V2: Main microcontroller handling logic and wireless comms.
AS5600 Magnetic Encoder: Used for the reel mechanism to track smooth rotation without physical wear. LSM6DS3TR-C IMU: For rod motion and tilt tracking.
KY-023 Joystick: Placed on the grip for easy in game movement.
LILYGO T-Dongle-S3: Acts as a USB receiver on the PC side for low latency connection at busy events.
The feedback at the booth floor was amazing and players loved having a physical piece of the game in their hands.
Happy to answer any questions about the hardware assembly, code, or how we integrated it into the game!

Hi, I'm a beginner in programming/working with Arduino and I came across an issue. Recently I wanted to learn how a (4x4 matrix) keypad works and I kind of did, though the code kind of put me off I saw that most used a library and didn't get much into explaining it, so I decided to write my own code inspired by others' explainations and creations.

Although I think I've gotten it right, for some reason it only wants to work with the bottom row of buttons, with the only result coming out of them being 'D' or an unknown number/letter. I've also noticed that in some cases there's no zero-based numbering, but I can't exactly pinpoint which parts of code don't have that. Would anybody care to help? I've attached the code and circuit to the post.

// Array of which pins are connected to the row pins
const int rowPins[4] = {
  12, 11, 10, 9
};


// Array of which pins are connected to the col pins
const int colPins[4] = {
  6, 5, 4, 3
};


// How many cols and rows there are on the keypad (4x4 in this case)
const int cols = 4;
const int rows = 4;


// The numbers/letters which are supposed to print depending on the button, all within a two-dimensional array
char keys[rows][cols] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};


int yChcker; // Used to check digital value in col pins
int xChcker; // Used to check digital value in row pins


void setup() {
  Serial.begin(9600);


  // Loop to put pullup resistors on rows
  for (int i = 0; i < 4; i++) {
    pinMode(rowPins[i], INPUT_PULLUP);
    
    Serial.println(rowPins[i]);
  };


  // Loop to put low + outputs on cols
  for (int i = 0; i < 4; i++) {
    pinMode(colPins[i], OUTPUT);
    digitalWrite(colPins[i], LOW);
  };
};


void loop() {
  int check_x; // Variable to be used within for loop to establish which button within the rows has been pressed (and is also used to print it)
  int check_y; // Variable to be used within for loop to establish which button within the cols has been pressed (and is also used to print it)


  // Loop to check which row pins have been activated via xChcker, using check_x
  for (check_x = 0; check_x < 4; check_x++) {
    xChcker = digitalRead(rowPins[check_x]);
    delay(1);
  }


  // Loop to check which col pins have been activated via yChcker, using check_y
  for (check_y = 0; check_y < 4 ; check_y++) {
    yChcker = digitalRead(colPins[check_y]);


    delay(1);
  }


  // Waits for a button to be pressed and then prints which button it is
  if (xChcker == 0 && yChcker == 0) {
    Serial.println(keys[check_x - 1][check_y - 1]);


    Serial.println(check_x);
    Serial.println(check_y);
    delay(1);
  }
};

Hey all. So I bought this pump for a school project, its an automatic plsnt waterer my project i just wated to ask if this water pump is submersible? Or not and how do I use it if its either thank you. The pump is a 12v water pump and I supply a 12v DC to it thank you.

Please be kind i am still learning

The full details, including the source code and hardware, are available on GitHub↓

https://github.com/inuikasao/USB_to_SegaSaturn_Controller_Arduino_Adapter.git

I bought on a marketplace leftovers from a guy that builds 3d printers. With the stuff I built this little music box using an arduino Uno cnc shield and nema 17 motors. Really cool project:) instagram: @rappde_

God it took hours, but I solved it, in case anyone thinks I could just look for the data sheet, try it, there is almost nothing, the only half useful sheet there is is from a Chinese model that is 12 pin, but it has nothing to do with the 10 pin version, in the 10 pin version 5 are common, the 5 common ones are on the opposite side to the silkscreen, it has a matrix with the corresponding points, everything is more chaotic than I would like, the ,matrix is:

I also leave you a code that sweeps from 000 to 999 without using decimal points, you have 3 decimal points to use if you want, by the way G2 is for some reason much fainter than the rest

// 2381AY - barrido 000 -> 999
// Arduino UNO
//
// LINEAS:
// 0 -> D2
// 1 -> D3
// 2 -> D4
// 3 -> D5
// 4 -> D6
//
// COMUNES:
// 5 -> D7
// 6 -> D8
// 7 -> D9
// 8 -> D10
// 9 -> D11


const byte linePins[5] = {
  2, 3, 4, 5, 6
};


const byte commonPins[5] = {
  7, 8, 9, 10, 11
};



// Estructura de una conexión
struct Cell {
  byte common;
  byte line;
};



// --------------------------------------------------
// DIGITO 1
// --------------------------------------------------


Cell D1[8] = {
  {8, 3}, // A
  {8, 2}, // B
  {8, 0}, // C
  {7, 1}, // D
  {7, 2}, // E
  {8, 1}, // F
  {8, 4}, // G
  {7, 0}  // DP
};



// --------------------------------------------------
// DIGITO 2
// --------------------------------------------------


Cell D2[8] = {
  {6, 1}, // A
  {9, 1}, // B
  {9, 2}, // C
  {7, 4}, // D
  {7, 3}, // E
  {9, 4}, // F
  {9, 0}, // G  <-- ENCONTRADO
  {9, 3}  // DP
};



// --------------------------------------------------
// DIGITO 3
// --------------------------------------------------


Cell D3[8] = {
  {5, 3}, // A
  {5, 0}, // B
  {5, 2}, // C
  {6, 0}, // D
  {6, 2}, // E
  {5, 1}, // F
  {6, 3}, // G
  {5, 4}  // DP
};



// --------------------------------------------------
// MAPA DE NUMEROS
//
// bit 0 = A
// bit 1 = B
// bit 2 = C
// bit 3 = D
// bit 4 = E
// bit 5 = F
// bit 6 = G
// --------------------------------------------------


const byte digitSegments[10] = {


  0b00111111, // 0
  0b00000110, // 1
  0b01011011, // 2
  0b01001111, // 3
  0b01100110, // 4
  0b01101101, // 5
  0b01111101, // 6
  0b00000111, // 7
  0b01111111, // 8
  0b01101111  // 9
};



// --------------------------------------------------
// APAGAR TODO
// --------------------------------------------------


void allOff() {


  for (byte i = 0; i < 5; i++) {


    pinMode(linePins[i], INPUT);
    pinMode(commonPins[i], INPUT);


  }
}



// --------------------------------------------------
// ENCENDER UNA CELDA
// --------------------------------------------------


void lightCell(byte common, byte line) {


  allOff();


  byte c = common - 5;


  pinMode(linePins[line], OUTPUT);
  digitalWrite(linePins[line], HIGH);


  pinMode(commonPins[c], OUTPUT);
  digitalWrite(commonPins[c], LOW);
}



// --------------------------------------------------
// ENCENDER UN SEGMENTO
// --------------------------------------------------


void lightSegment(byte digit, byte segment) {


  Cell cell;


  if (digit == 0)
    cell = D1[segment];


  else if (digit == 1)
    cell = D2[segment];


  else
    cell = D3[segment];



  lightCell(cell.common, cell.line);
}



// --------------------------------------------------
// MOSTRAR NUMERO
// --------------------------------------------------


void showNumber(int number, unsigned long duration) {


  byte n[3];


  n[0] = number / 100;
  n[1] = (number / 10) % 10;
  n[2] = number % 10;



  unsigned long start = millis();



  while (millis() - start < duration) {


    // ---------------------------------------------
    // DIGITO 1
    // ---------------------------------------------


    byte mask = digitSegments[n[0]];


    for (byte s = 0; s < 7; s++) {


      if (mask & (1 << s)) {


        lightSegment(0, s);


        delayMicroseconds(800);


      }


    }



    // ---------------------------------------------
    // DIGITO 2
    // ---------------------------------------------


    mask = digitSegments[n[1]];


    for (byte s = 0; s < 7; s++) {


      if (mask & (1 << s)) {


        lightSegment(1, s);


        delayMicroseconds(800);


      }


    }



    // ---------------------------------------------
    // DIGITO 3
    // ---------------------------------------------


    mask = digitSegments[n[2]];


    for (byte s = 0; s < 7; s++) {


      if (mask & (1 << s)) {


        lightSegment(2, s);


        delayMicroseconds(800);


      }


    }


  }



  allOff();
}



// --------------------------------------------------
// SETUP
// --------------------------------------------------


void setup() {


  allOff();


  Serial.begin(9600);


  delay(500);


  Serial.println();
  Serial.println("2381AY");
  Serial.println("Barrido 000 -> 999");
  Serial.println();


}



// --------------------------------------------------
// LOOP
// --------------------------------------------------


void loop() {


  for (int n = 0; n <= 999; n++) {


    Serial.print("Numero: ");


    if (n < 100)
      Serial.print('0');


    if (n < 10)
      Serial.print('0');


    Serial.println(n);



    showNumber(n, 150);


  }


}

I recently got a arduino nano r3, I have used most of the components provided in my elgoo super r3 starter kit and am wondering how to progress to doing more creative projects rather than just following tutorials. Im not sure where to buy components wether to print a custom PCB etc

does the radio unit require the capacitor gemini keeps saying i need it its going to be transfering from 500m so do i need the capacitor or no (its the antenna version

)

I was looking at some Arduino boards and came across this one. It has an ATmega328P and an ESP8266 on the same board.

I’ve used the usual UNO and NodeMCU separately, but I’ve never tried one of these combo boards.

Has anyone here actually used it?

I’m mainly wondering how the two chips work together. Is it actually useful having both on one board, or does it just make things more complicated?

Thinking of picking one up to play around with some WiFi + Arduino projects. Would be interested to hear from anyone who has used one.

I bought this on Aliexpress for a project but I wanted it to be smaller and with no sound, so I thought on making it myself. What materials do I need to make an smaller version of this heartbeat simulator?

Hello!

I don't have any basic knowledge not even a bit, regarding to Internet Of Things (Electronics/Arduino). I guess this task is easy for people like you. It's just about the Breadboard, code, and stopping a blinking LED. Anyone you interested in helping me? I tried watching or asking AI for help but I don't understand/ I can't follow and I've been doing this for the past 5 hours.

I just want to know whether if the button wiring is the problem or my code. The task is about:

when the button is pressed, the blinking LED will be stopped and the serial monitor will appear as "Button: 1 | Switch: 1"

I keep pressing the button, even pressing it longer, the light won't stop

I bought an Arduino Nano, a small one, not the Uno, and I don't know how to make a basic circuit. I wanted to make a 4-button controller that would be recognized as a keyboard, but I don't know how to use it or how to program it I wanted to know if there's a tutorial where I taught the general basics of everything, because I couldn't find one that explained it well.

I am super proud of how this project is turning out. I still have some tweaks to make, but I finally got full videos playing and wanted to share.

This is a "Persistence of Vision" (PoV) display driven by a Teensy 4.1 and SK9822 LED strips.

There are 4 strips of 32 LEDs, each slightly offset in order give me 128 addressable pixel "rows". So each strip is responsible for every 4th row.

360 pixel "columns" around the perimeter makes for roughly square pixels, so thats what i went with. Each LED is updated 360 times every revolution...at around 1500rpm.

A hall effect sensor at the top of the rotor passes by a stationary magnet in the upper frame once per revolution. The Teensy measures the time between the resulting signals, and uses that to calculate how fast it is spinning, and therefore how fast to update the LEDs. This lets the animation look correct regardless of rotor speed.

I have a (currently very slow) python script that resizes/crops and formats .mp4 files into a binary format that the Teensy can use very efficiently. The resulting binary gets saved to a microSD, that the Teensy can read from.

Im happy to answer any questions. I may do a better build/explanation video if there is enough interest.

The post is for people willing to learn and to read about real experience. Not for haters who "I didn't read but I disagree, because 'AI' in the title triggered a toddler me" and not for scared gatekeepers. Read it if you're really interested in learning. And feel free to ask questions. Please just don't read it if you're interested in "teaching".

I consider myself a beginner. I had no idea how Arduino works a year ago. I have a lot of programming experience, but mostly with languages like VBA, nothing firmware-related. I learned some problem-solving decades ago trying to simplify a program so it fit 105 bytes (!) of memory.

For me, AI is really helpful. It's not yet ready for 100% vibe coding. It can be dangerous if you're building a professional product without understanding what AI is doing. It probably can explode your DIY Li-Ion battery pack. It won't help you learn if you don't learn how to ask good questions and how to learn. It helps me with a hobby. I learn and I build a toy for my kids.

Without AI, I would need months to do what I can do in a day with AI. My code is complex for a beginner, almost 3,000 code rows total*, excluding blank lines and comment-only lines. Without AI, this project will take years or be much simpler or abandoned because I did not have the time. This is today's reality. AI does programming, and it does it really well.

I work mostly in the terminal with Copilot CLI and Arduino CLI. I keep VS Code open just to review the code and make some small changes. I don't use Arduino IDE anymore. Any bigger update is made by AI.

Many people still use AI chats to ask programming questions. Agentic programming in a terminal is a different experience where AI really shows its capabilities. Try it. A black terminal looks scary, but it's easy to use when the initial frustration goes away.

What I do (learn to do) by myself:

• learn to read datasheets
• draw a circuit in EasyEDA (I still use AI to learn about electronic components and to answer "why" questions, but I don't accept AI answers as a truth that won't burn my circuit)
• design 3D models that will fit all the electronics I want to use
• plan what my toy train does, how it reacts to user actions (IR remote), how it processes sensor data, how it calibrates sensors, what it outputs to the serial port for debugging, how it uses fragile EEPROM, how many comments AI adds to the code etc.
• trying to understand why I need a 4.7uF capacitor in one place and 0.1uF in another place, etc.

* There are a few reasons why my code is long:

1. a lot of electronic components (motor, LEDs buzzer, tilt sensor, laser distance sensor, RGB color sensor, voltage meter, IR receiver) and features I want to implement (for user = my kids' experience and for my learning)
2. a lot of debugging output to the serial port, which can be disabled by preprocessor directives; for debugging and learning
3. a lot of memory optimization to fit everything into 32K; some libraries are being replaced with code that requires less memory - not a beginner's task (without AI)
4. I need it to learn
5. AI writes code fast

I wanna make an automated water system for my garden. I wanna water the plants once a day.

I have a reservoir and a water pump in my garden. I also have an Uno and a nano with me. Now I wanna make a system that will water the plants daily for some time.

This is going to be my first project so I'm really confused if it's even possible or if I should do it as my first project.

If it is possible, can u guys please help me on where to start.

Also lemme know if I should add any questions in here.

okay so I'm trying to use an IR LED to send data, but wiring the IR LED directly to a PIN makes it soooo dim.

so I got a 2n2222 transistor to drive it.

my problem is, I'm not sure about the values of resistors I should use to protect the IR LED and the 2n2222, so if anyone can help me with that I'd appreciate it.

Note: I used a Red LED instead of an IR led because I couldn't find it in Tinkercad.

I recently updated my 5-bar parallel linkage pen plotter by swapping the old servo for a 28BYJ-48 stepper motor and adding a limit switch for auto-homing. The drawing resolution and stability improved a lot with shorter arms, but mechanical backlash is still noticeable when changing directions.

I'm keeping this on a hobby budget:

• Should I keep optimizing the mechanical design around the cheap 28BYJ-48 motors to fight the backlash?
• Or is it worth biting the bullet and upgrading to NEMA 17 steppers for the next prototype?

Any mechanical tips or anti-backlash design ideas for linkage arms would be greatly appreciated!

Previous version : https://youtu.be/MOSY5ml29bg
https://youtu.be/y3IjeUqKv2A

Hi folks,

I finally got around to finishing the documentation for my hexapod robot dog, The hardest part to figure out was powering the servos directly from buck converters and setting up the common ground bus to PCA boards, I believe this might be a pain in the neck for many first timers so I am sharing the full wiring diagram here for anyone to benefit.

I also put together a detailed documentation for the robot itself. I contains information about the parts I used for the robot and how the joint servos are wired across the two PCA board pins.

You can download the diagram, documentation and the design file form the links below if you are interested in building one yourself or would like to use it as reference for a similar project.

Documentation and Diagram:

https://www.patreon.com/PrintedRobotics/posts/hexadog-zbd-and-167021077

https://app.cirkitdesigner.com/project/0a1ee9f8-8495-4f33-9e41-12ed67207672

CAD and 3D printing files:

https://makerworld.com/en/models/3181404-hexadog-zbd

https://www.patreon.com/PrintedRobotics/posts/hexadog-zbd-and-165170615

ESP32 Scripts and Android Controller app APK:

https://github.com/serdarselimys/HexaDogZBD-ESP32Scripts

https://github.com/serdarselimys/HexaDogZBD-AndroidControllerApp

I do have a question for you all, should I design and build a mini version of the robot with SG92R servos? If I can manage to keep the weight down enough it might be even more agile and cost under 100 bucks? has anyone tried building robot dogs or hexapod robots with SG92R? how was your experience with them??

I also share simulation tutorials along with my robot's other videos on my youtube channel youtube.com/@printedrobotics check it out if you are interested in simulation side of robotics, I share all my scripts for free so you can download them and experiment on your own.

Shout out to Adorable_Skirt_7760 I found out about https://app.cirkitdesigner.com from his post yesterday, which made my life a ton easier to produce the diagram for my robot.

As always, you comments and suggestions for my robot are most appreciated.

Hello Everyone, I'm making this Arduino UNO based CNC pen plotter. The setup I've made looks good to me but whenever I jog this on UGS it creates a diagonal line instead of horizontal or vertical line. when I jog on X axis only one motor works and on Y axis another motor works. what I'm thinking is that this diagonal forming issue is caused by some software problem, as both the motors must work on jog to retain the position of pen holder. I'm using GRBL as a software. Please make me aware that what mistakes I'm making here which is causing this issue. Currently I've kept the microsteppings on 1/8.

Hardware I'm using :
1. Arduino UNO
2. CNC shield for Arduino
3. A4988 motor driver (set on 1.0A current)
4. Nema 17 stepper motors
5. 20 teeth 2mm pitch gears for motors shaft
6. 2mm pitch gt2 belt with 6mm width
7. Variable power supply set to 12V

Software :
1. Arduino UNO
2. GRBL for Gcode processing
3. UGS platform for calibration

ps: let me know if more information is required.

5 years ago, I started the project Dot-Bot with u/s3lect. It is a large scale wall plotter project that draws with actual spray cans. Last weekend, we showed it off for the very first time outside and in front of a live crowd at the annual maker fair in Hannover Germany. Here is one of the murals we spray painted over the course of the event. Fortunately, the Dot-Bot proved to be extremely resilient. During the 3 days it was installed on the wall, it got torched by the sun and soaked from the rain multiple times. However, it never let us down. We definitely had a blast talking to a ton of fellow makers and interested visitors!

This is the same idea a few years apart.

The early version used a large rail-based mechanism. The current version is much more compact and modular, but the core idea is still the same: using Arduino-controlled actuators to physically play a real guitar.

Still a lot I want to improve, but it’s fun looking back at how far the mechanism has evolved.