9. Input Devices

I2C bus diagram showing SDA, SCL, pull-up resistors, the microcontroller (master) and the sensor (slave).

The pull-up resistor connects the signal line to VCC. Without it, the line would float and the microcontroller cannot read a reliable logic level.

The DS3231 module. The large silver component is the backup battery holder, and the chip itself is on the back of the board.

DS3231 pinout: VCC, GND, SDA, SCL, SQW (square wave output), and 32K (32 kHz output). For basic use, only the first four are needed.

Converting Gerbers to PNG using Gerber2PNG

The milling machine does not read Gerber files directly. So first we convert them to PNG images using the Gerber2PNG FabLab Kerala tool. These images will be used in Mods Project to generate the actual toolpaths.

1. To do so we first we open the Gerber2PNG tool. And upload the copper layer Gerber file (F.Cu) and the drill file we did earlier. The tool will generate a preview of your board.

2. Then it will generate a preview of the board after uploading. Check that the traces and pads look correct, because this is how the milling machine will see your design.

After checking the preview, you can download the PNG files for each layer. In here I have and extra footprint as I forgot to update the pin header from 5x pin to 4x, but because it isn't connected to anything it doesn't affect the functionality of the circuit.

Generating RML Toolpaths in Mods Project

Mods Project converts our PNG images into RML files that the Roland SRM-20 milling machine can execute. We generate a separate RML file for each operation: traces, drills, and outline. Each uses a different tool and different cutting parameters.

1. Open Mods Project. Right-click anywhere on the canvas to open the menu. Select Programs > Open Server Program > Roland SRM-20 mill raster 2D.

2. The default node interface for the SRM-20 appears. Load the trace PNG into the "read PNG" node by clicking on it and selecting the file.

Then select the tool type. For the traces we use the 60º #501 V-bit. For the drills we use the 1/32" drill tool and lastly for the outline we use the 1/16" cutout tool.

3. My adapter didn't had drill holes, so I just used the traces and cutout tool. For the traces, I configured the mill raster 2D node like this: tool diameter 0.4 mm, cut depth 0.1016 mm, offset overlap 4. These settings control how deep the V-bit engraves and how many passes it makes.

Then I set the origin to 0,0,0 (X, Y, Z offset), amd configured the speed to 4 mm/s. These values tell the machine where to start and how fast to move.

I repeated the process for the outline, using the 1/16" cutout tool. The mill raster 2D node looked like this: tool diameter 1.6 mm, cut depth 0.6096 and max depth 1.7018 mm. This means that the machine will repeat 3 times the toolpath to cut the max depth, each pass it cuts 0.6096 mm.

I also moved the origin to the 0,0,0 position and changed the speed to 2 mm/s. Then I calculated the toolpath and downloaded the RML file.

1. Attach the copper board to the sacrificial bed with double-sided tape. Press firmly and evenly across the entire surface to avoid warping during the cut.

2. Secure the sacrificial bed to the machine table using the fixing screws. Nothing should move once the machine starts cutting.

3. Install the V-bit (60° engraving tool) in the spindle for the trace engraving step. Tighten securely.

4. Open VPanel on the computer. Use the arrow controls to move the tool to the desired X, Y origin (the corner of your board where the cut should start). Click "Set X,Y Origin".

5. Lower the Z axis carefully until the tip of the V-bit just touches the copper surface. With the spindle spinning, lower it slowly and listen for the moment it makes contact. Click "Set Z Origin".

6. Go to Cut in VPanel, select the traces.rml file and click Output. The machine will begin engraving the copper traces automatically.

7. After the traces are done, change the tool to the 1/16" cutout bit. Re-calibrate the Z origin with the new tool before sending the outline RML file.

8. The finished milled board, removed from the sacrificial bed. Clean any copper dust from the traces before moving to soldering.

1. The milled board before soldering. Inspect the traces under good lighting to check for any bridges (accidental connections between traces) or broken traces before starting.

2. Components laid out: two SMD resistors (4.7 kΩ), one 4-pin header connector, and the XIAO I2C breakout pins. Verify component values with a multimeter before soldering.

3. Apply a small amount of flux to the pads before placing each SMD component. Flux improves solder flow and helps prevent cold joints.

4. Tack one end of the resistor first to hold it in place. Then solder the other end, and go back to finish the first joint. Use tweezers to hold SMD components since they are very small.

5. Soldering the header connector. Make sure it is perfectly perpendicular to the board before soldering all pins — a tilted connector will cause issues when plugging in the DS3231.

6. Finished soldered board. Inspect each joint: a good solder joint is shiny and smooth, shaped like a small volcano. A dull or blobby joint may be a cold joint and should be re-soldered.

The resistance value confusion: SMD resistors use a numeric code on their surface. 4R7 means 4.7 Ω (the "R" is the decimal point). 4701 or 472 means 4.7 kΩ (4700 Ω). I grabbed the wrong reel from the components drawer.

Why does this matter? A 4.7 Ω pull-up resistor draws too much current (nearly 700 mA from a 3.3 V line), which can damage the microcontroller's I2C pins and will keep the SDA/SCL lines pulled so strongly to VCC that no device can pull them low to send data. I2C cannot work this way.

I desoldered the wrong resistors using a desoldering pump and fresh flux. SMD desoldering requires heating one pad at a time while sliding the component off. Adding a little fresh solder first actually helps because it lowers the melting point.

Since I didn't have 4.7 kΩ SMD resistors available, I used through-hole resistors instead. Through-hole components have long wire legs that go through holes in the board (or in this case, I bent the legs and soldered them across the SMD pads). Not the prettiest fix, but it works.

After the fix, I verified the resistance across the SDA and SCL pads with a multimeter in resistance mode. It should read approximately 4.7 kΩ between each line and VCC.

The board after the fix, with through-hole resistors replacing the original SMD ones. The adapter is now ready for the programming phase.

First, an I2C scanner sketch. This is a diagnostic tool: it tries every possible I2C address (0x00 to 0x7F) and reports which ones respond. The DS3231 should appear at address 0x68.

// I2C Scanner – use this first to check if the DS3231 is detected
#include <Wire.h>

void setup() {
  Wire.begin();
  Serial.begin(9600);
  while (!Serial); // Wait for Serial Monitor to open
  Serial.println("Scanning I2C addresses...");
}

void loop() {
  byte count = 0;
  for (byte addr = 1; addr < 127; addr++) {
    Wire.beginTransmission(addr);
    byte error = Wire.endTransmission();
    if (error == 0) {
      Serial.print("Device found at 0x");
      if (addr < 16) Serial.print("0");
      Serial.println(addr, HEX);
      count++;
    }
  }
  if (count == 0) Serial.println("No devices found.");
  delay(5000); // Scan every 5 seconds
}

Expected Serial Monitor output when the DS3231 is connected and the adapter is working correctly. You should see exactly one address: 0x68.

Main DS3231 sketch: reads and prints date and time every second. Upload this after confirming the I2C scanner finds the sensor.

// DS3231 RTC – Read and display time
#include <Wire.h>
#include "RTClib.h"

RTC_DS3231 rtc;

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

  if (!rtc.begin()) {
    Serial.println("DS3231 not found. Check wiring.");
    while (1);
  }

  // Set time only on first upload (comment out after first use)
  // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  // The line above sets the RTC to the compile time of this sketch.
  // After uploading once with it uncommented, comment it out and
  // re-upload, otherwise it resets the time every time the board restarts.
}

void loop() {
  DateTime now = rtc.now();

  Serial.print(now.year(), DEC);
  Serial.print('/');
  Serial.print(now.month(), DEC);
  Serial.print('/');
  Serial.print(now.day(), DEC);
  Serial.print("  ");
  Serial.print(now.hour(), DEC);
  Serial.print(':');
  Serial.print(now.minute(), DEC);
  Serial.print(':');
  Serial.println(now.second(), DEC);

  delay(1000);
}

Expected Serial Monitor output when the DS3231 is working: a new timestamp is printed every second. The time advances correctly with each reading.

Error 1: Board did nothing after first upload. When I first connected the adapter and uploaded the DS3231 code, the Serial Monitor showed nothing at all. The program seemed to freeze.

Cause: The wrong resistors (4.7 Ω instead of 4.7 kΩ) were installed at this point. The I2C lines were clamped to VCC too strongly and no communication was possible. The fix was desoldering and replacing with the correct 4.7 kΩ through-hole resistors as described in the Errors tab of the Physical Process section.

Error 2: COM3 port not detected. After making the resistor fix and reconnecting the XIAO, Arduino IDE could not find the board. The Port menu showed no available ports.

Cause and fix: The XIAO uses a USB driver that sometimes does not install automatically on Windows. I went to Device Manager and saw the board appearing as an unknown device. I manually installed the driver by right-clicking and selecting "Update Driver". After that, the COM port appeared correctly. Another solution is to double-press the XIAO's reset button to put it in bootloader mode, which appears as a different, always-visible USB device.

Error 3: I2C scanner showed false positive addresses. After fixing the resistors and the COM port, I ran the I2C scanner to check if the DS3231 was detected. The scanner reported several devices at unexpected addresses (for example 0x00, 0x10, 0x3F) even with nothing connected.

Cause: This is a known behavior when the I2C lines are not properly pulled up. A floating SDA or SCL line picks up electrical noise and the microcontroller misinterprets it as responses from devices. It is also possible that the resistors, even after fixing, were not making proper contact with the pads. I re-checked and re-soldered the connections, and the scanner then showed only the expected address 0x68.

Current status: After fixing the resistor values, the driver issue, and the I2C noise, the scanner correctly detects the DS3231 at 0x68. However, the full sketch has not yet achieved stable communication. The Serial Monitor still sometimes prints "DS3231 not found" on restart.

Next steps: I will check the physical connection between the adapter and the DS3231 module, verify the SDA/SCL wiring order, and try a different I2C speed (using Wire.setClock(10000) for a slower 10 kHz clock) to rule out signal integrity issues. Documentation will be updated once the communication is fully stable.