Build Instructions

Collapse

• 1

  PCB ASSEMBLY PROCESS

  • We start the PCB assembly process by applying solder paste to each SMD component pad using a solder paste syringe. We’re using 63-37 SnPb paste, which has a melting temperature of 200°C.
  • Next, we begin the pick-and-place process, which involves picking up SMD components using ESD tweezers and placing them in their designated locations.
  • Once placed, we lift the circuit and set it on our SMD reflow hotplate. The hotplate heats the PCB from below until it reaches the solder paste’s melting temperature. As soon as the PCB hits 200°C, the solder paste melts and secures the components to the board.
  • After that, we place a 6×6 tactile switch on the bottom side of the PCB and solder it in place using a soldering iron.
  • The rest of the through-hole components are added from the top side, including three 4×4 tactile switches and one Type-C port.
  • Finally, we place the Waveshare ESP32 board in its position and solder it using a soldering iron. We simply align it over the mounting pads and use excess solder on each pad to join the ESP32 board to the PCB.
• 2

  POWER SOURCE

  For the power source of this project, we are utilizing a 3.7V 600mAh Li-Po cell, which can provide a total runtime of more than 10 hours, which is pretty decent, considering we won’t be using it continuously. After diagnosing, we can turn the device OFF, which gives us a backup of 2–3 days depending on usage.

  We solder the positive and negative terminals of the lithium cell to the battery connectors provided on the circuit.

  By pressing the 6×6 tactile switch added on the backside of the circuit, the device turns ON. Double-tapping the switch turns the device OFF.

  We can also charge this setup by plugging in a 5V supply via the provided Type-C port. During charging, the indicator LED will blink, and it turns stable once the lithium cell is fully charged.

• 3

  CODE for Waveshare ESP32 C6 1.47 Display

  This is the finalized code running on the Medic Mini device. It differs slightly from our earlier demo sketch due to changes in the display and I/O configuration. The demo version used an ILI9341 display with the ESP32-C6 DevKit, which required a different set of GPIO assignments and library setup.

  In contrast, the final build uses the Waveshare ESP32-C6 1.47" display module.

  The below Breakdown highlights all the key differences introduced in this updated sketch.

  #include 
  
  // LCD pin map for ESP32-C6
  #define LCD_MOSI 6
  #define LCD_SCLK 7
  #define LCD_CS   14
  #define LCD_DC   15
  #define LCD_RST  21
  #define LCD_BL   22
  // Button pins
  #define BTN_YES     9
  #define BTN_NO      18
  #define BTN_UNSURE  19
  const char* symptoms[] = {
  "Headache",
  "Fever",
  "Cough",
  "Fatigue",
  "Nausea"
  };
  const int symptomCount = sizeof(symptoms) / sizeof(symptoms[0]);
  int responses[symptomCount]; // -1 = not answered, 0 = No, 1 = Yes, 2 = Not Sure
  int currentSymptom = -1;
  bool symptomDrawn = false;
  enum ScreenState {
  SCREEN_STARTUP,
  SCREEN_SYMPTOM,
  SCREEN_RESULT
  };
  ScreenState currentScreen = SCREEN_STARTUP;
  ScreenState lastScreen = SCREEN_STARTUP;
  // Button states
  bool lastYes = false;
  bool lastNo = false;
  bool lastUnsure = false;
  unsigned long lastInputTime = 0;
  const unsigned long inputLockout = 300;
  Arduino_DataBus *bus = new Arduino_ESP32SPI(
  LCD_DC, LCD_CS, LCD_SCLK, LCD_MOSI, GFX_NOT_DEFINED
  );
  Arduino_GFX *gfx = new Arduino_ST7789(
  bus,
  LCD_RST,
  2,
  true,
  172,
  320,
  34, 0,
  34, 0
  );
  // Stable press detection
  bool isStablePress(int pin, bool& lastState) {
  bool current = digitalRead(pin) == LOW;
  bool pressed = current && !lastState;
  lastState = current;
  return pressed;
  }
  void drawStartup() {
  gfx->fillScreen(BLACK);
  // Title split: Medic / Mini
  gfx->setTextSize(3);
  gfx->setTextColor(CYAN);
  gfx->setCursor(20, 40);
  gfx->println("Medic");
  gfx->setCursor(20, 80);
  gfx->println("Mini");
  // Subtitle split: Symptom / Checker
  gfx->setTextSize(2);
  gfx->setTextColor(WHITE);
  gfx->setCursor(20, 130);
  gfx->println("Symptom");
  gfx->setCursor(20, 160);
  gfx->println("Checker");
  // Red medical plus sign
  gfx->fillRect(80, 220, 20, 60, RED);  // vertical bar
  gfx->fillRect(60, 240, 60, 20, RED);  // horizontal bar
  }
  void drawSymptomPrompt(const char* symptom, int response) {
  gfx->fillScreen(BLACK);
  gfx->setTextSize(2);
  gfx->setTextColor(WHITE);
  gfx->setCursor(10, 80);
  gfx->println("Do you have");
  gfx->setCursor(10, 110);
  gfx->print(symptom);
  gfx->println("?");
  // Centered response label
  gfx->setTextSize(3);
  int centerX = 86;
  if (response == 1) {
  gfx->setTextColor(GREEN);
  gfx->setCursor(centerX - 30, 180);
  gfx->println("Yes");
  } else if (response == 0) {
  gfx->setTextColor(RED);
  gfx->setCursor(centerX - 30, 180);
  gfx->println("No");
  } else if (response == 2) {
  gfx->setTextColor(YELLOW);
  gfx->setCursor(centerX - 70, 180);
  gfx->println("Not Sure");
  }
  }
  void drawResult() {
  gfx->fillScreen(BLACK);
  gfx->setCursor(10, 60);
  gfx->setTextSize(2);
  gfx->setTextColor(GREEN);
  gfx->println("Processing...");
  delay(1000);
  int yesCount = 0;
  for (int i = 0; i < symptomCount; i++) {
  if (responses[i] == 1) yesCount++;
  }
  gfx->fillScreen(BLACK);
  gfx->setTextSize(2);
  gfx->setTextColor(WHITE);
  if (yesCount >= 3) {
  gfx->setCursor(10, 100);
  gfx->println("Possible");
  gfx->setCursor(10, 170);
  gfx->println("match:");
  gfx->setCursor(10, 210);
  gfx->setTextColor(YELLOW);
  gfx->println("Flu or Viral");
  } else if (yesCount == 2) {
  gfx->setCursor(10, 100);
  gfx->println("Mild symptoms");
  gfx->setCursor(10, 140);
  gfx->println("Monitor &");
  gfx->setCursor(10, 170);
  gfx->println("rest");
  } else {
  gfx->setCursor(10, 100);
  gfx->println("No major");
  gfx->setCursor(10, 140);
  gfx->println("match found");
  }
  gfx->setCursor(10, 200);
  gfx->setTextSize(1);
  gfx->setTextColor(CYAN);
  gfx->println("Press YES to restart");
  }
  void setup() {
  pinMode(LCD_BL, OUTPUT);
  digitalWrite(LCD_BL, HIGH);
  pinMode(BTN_YES, INPUT_PULLUP);
  pinMode(BTN_NO, INPUT_PULLUP);
  pinMode(BTN_UNSURE, INPUT_PULLUP);
  for (int i = 0; i < symptomCount; i++) {
  responses[i] = -1;
  }
  gfx->begin();
  drawStartup();
  }
  void loop() {
  unsigned long now = millis();
  if (currentScreen != lastScreen) {
  if (currentScreen == SCREEN_STARTUP) {
  drawStartup();
  } else if (currentScreen == SCREEN_RESULT) {
  drawResult();
  }
  lastScreen = currentScreen;
  }
  if (currentScreen == SCREEN_SYMPTOM &&
  currentSymptom < symptomCount &&
  !symptomDrawn) {
  drawSymptomPrompt(symptoms[currentSymptom], responses[currentSymptom]);
  symptomDrawn = true;
  }
  if (currentScreen == SCREEN_STARTUP &&
  (isStablePress(BTN_YES, lastYes) || isStablePress(BTN_NO, lastNo) || isStablePress(BTN_UNSURE, lastUnsure))) {
  currentSymptom = 0;
  currentScreen = SCREEN_SYMPTOM;
  symptomDrawn = false;
  delay(300);
  }
  if (currentScreen == SCREEN_SYMPTOM && currentSymptom < symptomCount) {
  if (now - lastInputTime > inputLockout) {
  if (isStablePress(BTN_YES, lastYes)) {
  responses[currentSymptom] = 1;
  drawSymptomPrompt(symptoms[currentSymptom], 1);
  delay(500);
  currentSymptom++;
  symptomDrawn = false;
  lastInputTime = now;
  } else if (isStablePress(BTN_NO, lastNo)) {
  responses[currentSymptom] = 0;
  drawSymptomPrompt(symptoms[currentSymptom], 0);
  delay(500);
  currentSymptom++;
  symptomDrawn = false;
  lastInputTime = now;
  } else if (isStablePress(BTN_UNSURE, lastUnsure)) {
  responses[currentSymptom] = 2;
  drawSymptomPrompt(symptoms[currentSymptom], 2);
  delay(500);
  currentSymptom++;
  symptomDrawn = false;
  lastInputTime = now;
  }
  if (currentSymptom >= symptomCount) {
  currentScreen = SCREEN_RESULT;
  }
  }
  }
  if (currentScreen == SCREEN_RESULT && isStablePress(BTN_YES, lastYes)) {
  for (int i = 0; i < symptomCount; i++) {
  responses[i] = -1;
  }
  currentSymptom = 0;
  currentScreen = SCREEN_SYMPTOM;
  symptomDrawn = false;
  delay(300);
  }
  }

  In our main sketch, we use the Arduino GFX Library to drive the ST7789 display.

  The following configuration sets up the screen dimensions, rotation, and offset parameters tailored to the Waveshare ESP32-C6 1.47" module.

  Arduino_GFX *gfx = new Arduino_ST7789(bus,LCD_RST,2,          // rotationtrue,       // IPS172,        // width320,        // height34, 0,      // X offset34, 0       // Y offset);

  We configured the pin mapping to match the default wiring of the Waveshare ESP32-C6 1.47" display. These assignments were based on the official Waveshare Wiki documentation.

  #define LCD_MOSI 6#define LCD_SCLK 7#define LCD_CS   14#define LCD_DC   15#define LCD_RST  21#define LCD_BL   22

  Next comes the button input.

  #define BTN_YES     9#define BTN_NO      18#define BTN_UNSURE  19

  The rest of the code logic remains unchanged from the previous demo sketch. The only modifications made here are the updated display configuration and revised input button mappings to match the final hardware.

  We uploaded the code into our ESP32 board and moved onto the next step, which was the enclosure assembly. From next, we cannot upload code into ESP32 because its USB will be inaccessible.

View all 6 instructions