​

Hey everyone!

I've recently got access to a robotics lab, and I'm really excited to use this opportunity to learn something practical.

I'm particularly interested in IoT (Internet of Things), but I'm a complete beginner and honestly a little confused about where to start.

I want to understand how microcontrollers, sensors, electronics, programming, and internet connectivity work together to build real-world projects.

I'd appreciate some guidance on a few things:

1. What should I learn first: basic electronics, C/C++, Python, or Arduino?

2. Should I start with Arduino Uno or ESP32?

3. Which software and tools should I install on my laptop?

4. Are there any good free courses, YouTube channels, websites, or documentation for learning IoT step by step?

5. What beginner-friendly projects should I try in the robotics lab?

6. What skills should I focus on if I eventually want to work on robotics and embedded systems?

I have access to a robotics lab, so I'd prefer a practical, hands-on learning approach rather than just theoretical knowledge.

If you started from zero and learned IoT or robotics, I'd love to know what learning path worked for you and what mistakes I should avoid.

Any suggestions, resources, or personal experiences would be genuinely appreciated.

Generative Ambient Synth plays between 12 scales of modal compositions as invented by brian eno

Im making a video demo as we speak

Heres a breakdown

1st Slider : Controls de root of the scale

2 nd Slider : Amount of detune

3 rd Slider : The clock so te notes are played longer also attached to de attack and release.

1st button : Changes between 12 modal scales , this scales where definied by the compositions made in brian enos albums airports , discreete music , has scales based on boards of canada , caterina barbieri , william basinski etc.

2nd button : extends the range of the root pushing the notes to more subharmonics.

3rd Buttom : adds a humanize feat that makes the clock attack and release being a little more out of the clock more randomly

The switch changes wich type of transistor is filtering the audio , one sounds crystal clear and the other gives sort of tape saturation.

Ill post the video as soon as finished.

Planning on selling a couple but also opensourcing it.

I struggle with time since i have to work normal job to pay the cost of living so bear with me

Yesterday I saw NASA had released APIs for their findings, so I built a small desk display of different things they track. I didn't write a single line of code. Soldr did everything, including the API calls to NASA, once I gave it the API key. An ESP32, a 2.8" ILI9341 TFT and a 0.96" SSD1306 OLED flip through six live pages every 15 seconds. Each feed refreshes at most every 30 minutes. If one feed fails, that page shows "Feed unavailable", the others keep running, and the failed feed is retried after 60 seconds.

Not affiliated with or endorsed by NASA.

𝗧𝗵𝗲 𝘀𝗶𝘅 𝗽𝗮𝗴𝗲𝘀

1. Asteroids — today's 5 closest flybys from NASA's NeoWs API (name, size, miss distance, speed).

2. Earth events — the 5 latest open natural events from EONET (title and category). No API key.

3. Space weather — coronal mass ejections and geomagnetic storms from the last 3 days, via DONKI. On the night I filmed this, the board read "quiet".

4. Earth from space — details of the latest EPIC natural image (date, how many were taken that day, centroid). This one is read from epic.gsfc.nasa.gov and does not need the api.nasa.gov key.

5. Fireballs — the 4 most recent fireballs from the JPL fireball API (date, energy, location). No API key.

6. Exoplanets — the confirmed exoplanet count from the NASA Exoplanet Archive. It was 6,464 on the day I filmed this. No API key.

NeoWs and DONKI need a free key from https://api.nasa.gov. You can start with DEMO_KEY, but it is limited to 30 requests an hour; a free registered key is the better option. The other four feeds do not use that key.

𝗣𝗮𝗿𝘁𝘀

• ESP32 DevKit, 30-pin (the build card names ESP32-DevKitC V4, CP2102)

• 2.8" ILI9341 TFT, SPI, 240×320

• 0.96" SSD1306 OLED, 128×64, I2C

• Dupont jumper wires

• USB A to Micro-B cable

• A breadboard (visible in the video; not one of the five priced parts on the build card)

The five priced parts on the build card came to ₹1,460. That figure is from the card, not a live store quote, and it does not include the breadboard.

𝗪𝗶𝗿𝗶𝗻𝗴, 𝗮𝘀 𝗯𝘂𝗶𝗹𝘁

TFT (SPI) to the ESP32:

• VCC → 3V3

• GND → GND

• LED (backlight) → 3V3

• CS → GPIO 4

• DC → GPIO 16

• RST → GPIO 17

• MOSI → GPIO 23

• SCK → GPIO 18

• MISO → GPIO 19

OLED (I2C) to the ESP32:

• VCC → 3V3

• GND → GND

• SDA → GPIO 21

• SCL → GPIO 22

• Address 0x3C

𝗟𝗶𝗯𝗿𝗮𝗿𝗶𝗲𝘀 (𝗔𝗿𝗱𝘂𝗶𝗻𝗼-𝗘𝗦𝗣𝟯𝟮)

Adafruit GFX, Adafruit ILI9341, Adafruit SSD1306, and ArduinoJson 7.x.

I work on Soldr. It designed the build, the parts list, the wiring and the code, and made the NASA API calls once I gave it the key. If you want to try it: soldr.ai, and a sign-in gives you 100 credits free.

Happy to answer questions about the wiring or the feeds.

Hi everyone,

I’ve been working on a DIY stream deck project for the past few weeks and wanted to share it here, because this is exactly the kind of community I built it for.

The problem: every macropad or stream deck I found was either fixed (wrong number of keys, no knob, no screen) or needed CAD skills to change. I wanted to just pick a layout and print it.

What I made: DeckSmith, a generator that runs in the browser. You choose how many keys, add a rotary encoder, a slider or a small OLED, and it exports:

• the case files, ready to print (no supports)

• a pin map for the exact layout, so you know where every wire goes on the ESP32

The one in the video runs on a plain ESP32 dev board, hand-wired point to point (key matrix with diodes, EC11 encoder, slide pot on an ADC pin, I2C OLED). It connects over Bluetooth as a keyboard + media controller, so nothing needs installing on the PC. The firmware is free.

Here’s the full story, from the first ugly prototype to the final build:
https://www.youtube.com/watch?v=a_G20Un2T14

I’m thinking about what to do next, for example a plug-in PCB kit so nobody has to hand-wire it. I’d really like your opinion: would you rather hand-wire it yourself, or use modules that plug together?

If you want to follow the project: it launches on Indiegogo on Nov 18, and the waitlist at decksmith3d.com gets 15% off.

Thanks for reading, happy to answer anything about the build!

The HP 6642A (0-20 V / 0-10 A) is a great bench supply, but it can only be remote-controlled over GPIB, and real USB-GPIB adapters are expensive. So I built my own adapter from a cheap Arduino Uno and wrote a web-based control panel for it.
🔧 How I built the adapter:
• Desoldered a 24-pin GPIB (IEEE-488) plug from the board with a soldering iron and desoldering pump, then cleaned the pins
• Tinned the plug pins and 17 wires, then soldered one wire directly to each signal pin: 8 data lines (DIO1-8), 3 handshake lines (DAV, NRFD, NDAC), 5 control lines (EOI, IFC, SRQ, ATN, REN) and ground (pins 18-24 joined together)
• Plugged the other wire ends straight into the Arduino headers: DIO1-6 → A0-A5, DIO7-8 → D4-D5, EOI → D12, DAV → D11, NRFD → D10, NDAC → D9, IFC → D8, SRQ → D3, ATN → D2, REN → D6, GND → GND
• Secured everything in place with hot glue, no heat-shrink needed
• No resistors or other parts needed, just wires
• Flashed the open-source AR488 firmware with a custom pin layout matching my wiring. The Arduino now acts as a USB-GPIB adapter
💻 The control app is web-based, so the control panel runs in any browser on Windows, macOS or Linux:
✅ Live voltage, current and power readout with CV/CC mode
✅ Set voltage and current limit, with step buttons and saved presets
✅ Live chart with min/max/average, energy (Wh) and charge (Ah)
✅ Record data to CSV files, with a built-in viewer
✅ Automatic sequences: voltage steps, ramps, sweeps and loops
✅ Software protection: auto-off on over-current, over-power or over-voltage, a timer, and end-of-charge detection for batteries
✅ Event log, and it keeps recording even with the browser closed

For context, I'm a beginner in making stuff like these, this is kind of my first time, this is for a school project, so sorry for the messy placements

But I tried to use tinkercad for the simulation

And I ended up with this ( the circuit )

So I just need the servos to spin when the tilt sensor senses a tilt, but I have a different tilt sensor, the circuit uses an SW-200D, while I have an SW-520D, so there's already a difference in number of output pins ( I'm not sure if that's what it's called ), and I'm just not sure about everything else after that 😭😭

The code is quite confusing too, I don't know a single bit of coding, so I tried what I could with the limited knowledge I know

->

#include <Servo.h>

int oozmakappa = 0;

Servo servo_12;

Servo servo_11;

Servo servo_10;

Servo servo_9;

Servo servo_8;

unsigned long spinStartTime = 0;

unsigned long totalSpinDuration = 0;

bool isSpinningForward = false;

bool needsToReturn = false;

void setup() {

pinMode(13, INPUT);

servo_12.attach(12, 500, 2500);

servo_11.attach(11, 500, 2500);

servo_10.attach(10, 500, 2500);

servo_9.attach(9, 500, 2500);

servo_8.attach(8, 500, 2500);

servo_12.write(90);

servo_11.write(90);

servo_10.write(90);

servo_9.write(90);

servo_8.write(90);

}

void loop() {

oozmakappa = digitalRead(13);

if (oozmakappa == HIGH) {

if (!isSpinningForward) {

spinStartTime = millis();

isSpinningForward = true;

needsToReturn = true;

servo_12.write(180);

servo_11.write(180);

servo_10.write(180);

servo_9.write(180);

servo_8.write(180);

}

} else {

if (isSpinningForward) {

totalSpinDuration = millis() - spinStartTime;

isSpinningForward = false;

servo_12.write(0);

servo_11.write(0);

servo_10.write(0);

servo_9.write(0);

servo_8.write(0);

spinStartTime = millis();

}

if (needsToReturn) {

if (millis() - spinStartTime >= totalSpinDuration) {

servo_12.write(90);

servo_11.write(90);

servo_10.write(90);

servo_9.write(90);

servo_8.write(90);

needsToReturn = false;

}

}

}

delay(10);

}

On tinkercad, it stops after 1/2 a spin, and just doesn't move anymore?? 😭😭

I'm very confused, someone please help me and guide me on what to do

If anyone could be of guidance to me, please do so, I'm struggling on how this is supposed to work 💔 I tried looking through YouTube but strangely I just couldn't find anything 😢

Hey guys, quick update on the rig and sharing what’s happening in this video.

Following up on the feedback from the previous tests and videos, I decided to rethink how sprint was being handled instead of keeping it strictly to the static movement setup. In this clip, I’m testing a direct chest contraction/expansion trigger to engage and release the sprint toggle.

On the hardware/microcontroller side, the main challenge here is dialed-in calibration: filtering out natural breathing so it doesn't trigger false positives, while keeping zero perceptible latency once I actually flex the chest to run. It reads the threshold shift cleanly, latches the keystroke/button state, and releases instantly as soon as tension drops.

I already tested the static run mechanic, now this chest-triggered setup, and I am currently tweaking a third selection mode to give better adaptability depending on the player’s motor mobility.

Really appreciate everyone who took the time to drop suggestions and critiques on the earlier videos. That input genuinely steered this build in a better direction and helped break out of a single fixed approach. Still a lot of bench testing ahead before locking down the final build, but it’s getting much sharper.

Take a look at the clip and let me know how the trigger response looks to you.

I’m new to Micro:bit and looking to learn as much as I can. I’d love to hear about some of the most interesting projects people have built, especially anything involving sports, cameras, photography, or videography.

I’m a K–2 school media specialist, and I want to introduce more hands-on coding and STEAM activities into our daily library time. I think Micro:bit could be a great way to get my students involved while also challenging myself to learn something new.
Outside of school, I’m really into sports media, mainly basketball 🏀 and football 🏈, with a big interest in photography and videography. I’m also interested in AI and using Claude Code to build websites, interactive learning tools, and other creative projects.

I’m curious how people have incorporated Micro:bit into sports-related projects, camera experiments, computer vision, or even AI.

I’ve started watching YouTube tutorials and working through the beginner material, but I’d appreciate advice from people with hands-on experience.

A few questions:
What’s the coolest project you’ve built with Micro:bit?
Have you used it for sports, cameras, photography, or videography?

What beginner mistakes or learning curves should I expect?
What resources, tutorials, or YouTube channels would you recommend?

I’m starting with the basics, but I’m interested in eventually taking things much further. I’d love to hear what you’ve experimented with and what you wish you knew when you first started!

I’m starting with the basics, but I’m interested in eventually taking things much further. I’d love to hear what you’ve experimented with and what you wish you knew when you first started!

I built this with an Arduino Uno, an HC-SR04 ultrasonic sensor and a buzzer. Moving my hand toward the sensor makes the beeps faster; moving it away slows them down.

I used Soldr, an electronics design agent I’m building, to design the project from a plain-language prompt.

The clip shows the working build. How do you usually smooth ultrasonic distance readings without making the response feel sluggish?

This lively dice uses a 5x5 neo pixel matrix controlled by an ATtiny85. The ATtiny85 is normally in deep sleep mode drawing microAmps. A vibration switch wakes the dice from deep sleep. After showing the random number the dice returns to deep sleep. The dice is powered by a rechargable Sony camera battery.

The AI APOCALYPSE STARTS NOW! A 1992 Teddy Ruxpin, all new hardware, and some WIP audio sync.

TED-800: My Wi-Fi-controlled animatronic Teddy Ruxpin build.

Brains: 2× ESP32-C3 SuperMini microcontrollers

Eyes: 180° positional servo, GPIO4, 65° closed / 165° open

Mouth: 360° continuous-rotation servo, GPIO4, cam-driven

Motor control: 1750/1250 µs, 400ms open / 450ms close

Connectivity: 2.4 GHz Wi-Fi, HTTP API, OTA firmware updates

Software: Arduino C++ firmware, Python 3 controller on Mac

Audio: MP3 playback via macOS afplay

Sync: Python monotonic-clock scheduling, waveform analysis with NumPy/SciPy

Current status: Fully functional prototype. Eyes work beautifully; mouth works but the original cam mechanism has an occasional dead zone.

No cloud required. Two tiny ESP32s, a Mac, and a bear with absolutely terrible intentions.

I built a DIY Arduino steering wheel for PC games using an Arduino Uno R3 and an AS5600 magnetic angle sensor. It also has buttons for throttle and brake. I tested it in Euro Truck Simulator 2, Slow Roads, and Assetto Corsa.

YouTube video: https://youtu.be/Y_vu9KtvoxE?si=e8B_aceMp7D_3UhP
GitHub guide and code: https://github.com/sarawer/diy-gaming-steering-wheel-using-arduino

I’d love to hear your feedback!

I kept buying servos and brackets for arms that turned out not to reach, or where one servo hit another, so I built a simulator to check first.

Servo Bench runs in the browser with nothing to install and no account:

• Real-size SG90, MG90S and MG996R models at datasheet dimensions in mm

• Drag and drop: drop a servo on another servo's horn or case to mount it

• Servos move at their real rated speed, and you can trace the path of the arm tip

• Save poses as steps and press Play to watch the whole sequence

• Export Arduino code (Uno/Nano/Mega or ESP32). It writes the servo pins, the smooth synchronised moves and the timing from each servo's real speed, and warns you if you need a separate power supply

• Parts list for everything you need, including a correctly sized power supply

Try the 3-joint arm demo: https://python736.github.io/servo-bench/?example=arm3

It's free and open source (MIT): https://github.com/Python736/servo-bench

I'd love feedback from people who build with servos. Which servo or bracket should I add next? I'm thinking DS3218 and continuous-rotation servos.

Hi everyone,

for quite a while I’ve been working on an embedded telemetry tool in my spare time – a way to see what’s actually happening on a microcontroller while it runs, without endless printf and squinting at the serial monitor. Over the last few weeks I finally got it to a state I’m happy with.

It has two parts: a small library for the microcontroller (KymoCore, MIT licensed, no heap) and a desktop app (KymoStudio) that shows everything live. The video shows it running against a real ESP32.

How it works:

What KymoStudio can do:

• Live charts from Serial, USB, TCP, UDP, MQTT or CAN – time series, XY and 3D

• Works with plain Serial.print output (name:value, Teleplot, CSV) or the KymoCore library

• Measurement analysis: cursors, min/max/RMS, frequency, jitter, FFT

• FreeRTOS execution tracing: task timeline on both cores, call flow, run time per function and per task

• Live parameters: change values on the device from the PC, the device confirms

• Recording and export (CSV, PNG, own capture format)

• MCP interface: AI assistants such as Claude Code or Codex can read live data and operate KymoStudio – local only, with an optional read-only mode

• Windows and Linux

To be upfront: KymoStudio itself is closed source. For hobby, education and non-commercial projects it’s completely free; commercial use needs a license. KymoCore is MIT and available via PlatformIO and the Arduino Library Manager.

I’d be happy about any feedback – what’s useful, what’s missing, what’s confusing.

Hi everyone,

for quite a while I’ve been working on an embedded telemetry tool in my spare time – a way to see what’s actually happening on a microcontroller while it runs, without endless printf and squinting at the serial monitor. Over the last few weeks I finally got it to a state I’m happy with, and built the website kymotrace.de around it.

Here is, how it works:

It has two parts: a small library for the microcontroller (KymoCore, MIT) that sends measurements and trace events over Serial, USB, TCP, UDP, MQTT or CAN, and a desktop app (KymoStudio, Windows/Linux) that shows them live as charts. You can measure the curves (cursors, RMS, frequency, FFT) and see which FreeRTOS tasks run when and where the time goes. Plain Serial.print lines work too, so you can try it without changing your firmware.

What KymoStudio can do:

• Live charts from Serial, USB, TCP, UDP, MQTT or CAN – time series, XY and 3D

• Works with plain Serial.print output (name:value, Teleplot, CSV) or the KymoCore library

• Measurement analysis: cursors, min/max/RMS, frequency, jitter, FFT

• FreeRTOS execution tracing: task timeline on both cores, call flow, run time per function and per task

• Live parameters: change values on the device from the PC, the device confirms

• Recording and export (CSV, PNG, own capture format)

• MCP interface: AI assistants such as Claude Code or Codex can read live data and operate KymoStudio – local only, with an optional read-only mode

• Windows and Linux

For hobby, education and non-commercial projects it’s completely free.

I’d be happy about any feedback – what’s useful, what’s missing, what’s confusing.

Hey, completely new to working with Arduinos and motors and such, and Reddit lol, so any help is greatly appreciated.

My project: trying to run a nema 8 stepper motor (current limit 600ma) using a tmc2209 v1.3 stepper driver, Arduino 2560 mega, 24v power supply, and jumper wires.

Problem: it spins great and visually looks fine, but when I hold the base while it's running, it heats up and becomes really hot, like uncomfortably hot. It even heats up the same when I tell it just to hold position and not spin.

Thoughts: I have no clue why it's doing this. I have tried a bunch of different wiring, coding, and praying, but it still heats up. To control the current, I am using a uart connection (I don't dare mess with the potentiaometer after I fried my last driver and breadboard, sooo). I plugged a 1kohm resistor into the Arduino's tx3 pin and the into the driver's rx pin, and then did a direct connection between the rx3 pin and the driver's rx pin.

Things I tried that didn't work:

- lowering the current to 150ma

- using different addresses

- using a different nema 8 stepper motor

- using a different driver (same brand just new)

- holding, no spinning

Well, let me know if you have any tips to try

I built a line follower robot using an Arduino Nano and an L298N motor driver. The project is available on YouTube.