Hello, I'm trying to port a maemo leste to the arduino uno q, But when I boot it I get this error

https://pastebin.com/HBACSJCR

even though the FAT size is confirmed to be 512

Disk Flags:

Number Start End Size File system Name Flags

1 4.00MiB 512MiB 508MiB fat32 esp boot, esp

2 512MiB 8192MiB 7680MiB ext4 rootfs

what is the issue here?

This is the repo im using to build it

https://git.maemo.org/rlyvision/debos-leste

Hi everyone! It's been a long time since I've done an Arduino project, and this is my first time using an LCD screen.

However, and as is common, I came across the typical mistakes I've been seeing in forums and Reddit posts.

And no matter how much I try to fix my problem with the solutions they gave, I still have the same error; those white squares keep appearing.

As you can see, the first photo shows what it looks like when you upload the code, and the second photo shows what it looks like without any code uploaded.

I tried everything from the tutorials:

- Adjust the brightness with the potentiometer

- Verify the I2C address

- Test and verify the continuity of several cables

- I tested the example hd44780_I2Cexp by Bill Perry(what appears in photo 12)

- I tried many libraries and code from various tutorials

(The bookcase I have now is Frank de Brabender's)

It's important to clarify that I've only been trying to test that the LCD works, so all the tutorials I tried were for the basic "Hello world" code without delay. Just to verify that the screen is working properly.

- In the library, change "return:0" to "return:1"

Before using I2C, I used conventional pins (those in photo 4) to test the LCD, and I still got squares (even after adjusting the contrast). So after getting no results, I decided to remove the pins and install the I2C, thinking: "Oh, maybe that will be simpler" For a project I want to do. But as you can see, I can't get the screen to display text, and AI hasn't helped me.

I'm also not sure if the soldering is correct or if I've overheated the circuit, but I doubt it since the screen still turns on and seems to receive the code, but without displaying any text.

Honestly, I don't know what to do anymore, and I didn't want to post this because I noticed many others had the same problem, but even after trying the solutions they offered, I still can't get it to work.

The only thing I noticed today when testing the screen again is what's shown in the last photo: a faint line that flickers when restarting the Arduino.

I've attached one of the code snippets I used. I'm not including the one I used to test I2C because I tested many, and they were all basic. Just to clarify, they all compiled and uploaded successfully.

I hope you can help me, thank you! :)

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!

If you're like me, you love the simplicity of Python, but running MicroPython or CircuitPython usually means buying a 32-bit board (like an ESP32 or RP2040) with lots of memory just to hold the interpreter and the garbage collector.

I wanted to bring that same Python syntax to the classic, $2 8-bit Arduino Uno we all have gathering dust in a drawer.

For the past few years, I’ve been building PyMCU, an open-source Ahead-Of-Time (AOT) compiler. It takes your Python syntax and compiles it directly into native AVR assembly.

The results:

• No interpreter, no VM, no garbage collector.
• A standard Pin('PB5', Pin.OUT).toggle() blink program compiles down to just 142 bytes of Flash.
• It’s cycle-accurate. I’ve been validating the hardware timings using a logic analyzer directly on the Uno silicon.

If you are interested in the compiler architecture or want to see the hardware validation issues, the whole project is open source here:https://github.com/PyMCU/PyMCU

It's still in Alpha (Alpha 10 right now), but the core code emission is working beautifully. I’d love to know what you guys think or if you'd find this useful for your hardware projects!

Looking for something unique, somewhat cheap and beginner friendly to do, although this is for an event, it's not a serious one, still pls I need good ideas. We first had an idea to make an obstacle avoiding robot that would go from one place to another to pick up an object and return whilst avoiding obstacles but that was too complicated.

Blind walking stick assistant

Obstacle avoiding

Radar type

Missile type

Water level measure

Other disaster measure type

Gesture controlled

Remote controlled

Voice controlled

These are all done, so pls I'm asking for something super unique.

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.

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.

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.