Mutantc V4 - Diy Handheld For Your Professional Works

Made by rahmanshaber / 3D Printing / Communication / Productivity / Weather / IoT

About the project

A Raspberry-pi handheld platform with a physical keyboard, Display,Expansion header for add-on boards and NuroLink port to connect accessories.

Project info

Difficulty: Moderate

Platforms: Autodesk, Raspberry Pi, Linux, Arm, Espressif

Estimated time: 3 hours

License: MIT license (MIT)

Items used in this project

Hardware components

	ESP32-S2-WROVER Module - 4 MB flash and 2 MB PSRAM	x 1
	Raspberry Pi 4 Model B 1GB, 2GB, 4GB or 8GB RAM	x 1
	4 Inch TFT Display for Raspberry Pi - Resistive Touch Screen	x 1

Software apps and online services

	Arduino
	Fusion 360
	Eagle

Hand tools and fabrication machines

	3D printer	x 1
	PCB	x 1
	Soldering Iron	x 1

Story

mutantC is a Raspberry Pi UMPC. An open platform device to use any serious professional work and create your ecosystem of automation. It is fully Open-Source hardware. So you can hack it as you wish. Make your expansion-card like GPS, Radio etc and attach them. You can access all the ports of the Pi. The back part is attached with 4 screws. It can hold a 4" or 3.5" touch screen. Also have a 52 button physical keyboard. It doesn't need any custom OS, you can use plain Raspberry Pi OS and install the LCD driver, that's it. So little parts needed to make one. The priciest thing is the LCD and Pi.

Please shear the link to all your friends .

Project Links

YouTube Project Website Discord Matrix Twitter

Build Guide

1. Order the parts from online, here is the full Parts list.

2. Order the 3D printed parts, you need to print 4 parts, here is the parts files. You can Order them from PCBWay 3D printing service.

3. Order the PCBs, there is 3 PCB you need, here is the files you need to order. You can also order the PCBs from PCBWay PCB prototype service.

That way you can get the 3D parts and PCB fast within minimum days and save shipping costs.

Now solder the parts and flash the firmware from here. Now flash a SD card with Raspberry Pi OS and install the LCD driver from the place you brought the LCD module.

That's it you got your fully working mutantC v4. If you want to try out some Expansion Boards you can see some of them from here, there is 6 of them currently.

Schematics, diagrams and documents

thumbstick_pcb

main_pcb

display_pcb

CAD, enclosures and custom parts

display_top

body_top

body_bottom

mid_frame

display_bottom

Code

firmware v4.1

// firmware V4.1
// mutantC v4

#include "Arduino.h"
#include "hidcomposite.h"
#include <Keypad.h>

HIDcomposite device;

const int LED_1 = 17; 
const int LED_2 = 5; 
const int POWER_MAIN =37;
const int POWER_OFF_BTN =26;
const int POWER_EX =39;
const int POWER_LCD =38;
const int BUZZER =40;
const int PI_STATE =42;
const int BATTERY_MESUREMENT =18;

// Thumbstick, set pin numbers for the five buttons:
const int rightButton = 9;
const int upButton= 8;
const int leftButton = 4;
const int downButton= 10;
const int mouseButton = 3;

// For Thumbstick
int range = 10;              // output range of X or Y movement; affects movement speed
int responseDelay = 10;     // response delay of the mouse, in ms

// Switch Stats
static bool keymapState = 0;
static bool expansionState = 0;
static bool lcdState = 0;
bool powerstate = 0;

// For Keypad
const byte ROWS = 5;
const byte COLS = 11;

// For Battery Voltage
int value = 0;
float voltage;

#define POWEROFF              0x91
#define KMAP_SWITCH           0x92
#define EXPANSION_SWITCH      0x93
#define LCD_SWITCH            0x94
#define NOTIFICATION_LED      0x95
#define KMOUSE_LEFT           0x96
#define KMOUSE_RIGHT          0x97
#define KBATTERY_SWITCH       0x98
#define NOTIFICATION_BUZZER   0x99

static uint8_t keymapAlpha [] = {
  KMOUSE_RIGHT, LCD_SWITCH, EXPANSION_SWITCH, KBATTERY_SWITCH, NOTIFICATION_BUZZER, POWEROFF, NOTIFICATION_LED,  'E',  'E',  KMAP_SWITCH,  KMOUSE_LEFT,
  HID_KEY_1,           HID_KEY_2,  HID_KEY_3, HID_KEY_4,  HID_KEY_5,  HID_KEY_6, HID_KEY_7, HID_KEY_8, HID_KEY_9,  HID_KEY_0,   HID_KEY_ARROW_LEFT ,
  HID_KEY_Q,           HID_KEY_W,  HID_KEY_E, HID_KEY_R,  HID_KEY_T,  HID_KEY_Y, HID_KEY_U, HID_KEY_I, HID_KEY_O,  HID_KEY_P,   HID_KEY_ARROW_RIGHT        ,
  HID_KEY_CAPS_LOCK  , HID_KEY_A,  HID_KEY_S, HID_KEY_D,  HID_KEY_F,  HID_KEY_G, HID_KEY_H, HID_KEY_J, HID_KEY_K,  HID_KEY_L,   HID_KEY_BACKSPACE,
  HID_KEY_CONTROL_LEFT, HID_KEY_GUI_LEFT, HID_KEY_Z,  HID_KEY_X, HID_KEY_C, HID_KEY_V, HID_KEY_B,  HID_KEY_N,   HID_KEY_M,   HID_KEY_SPACE,  HID_KEY_RETURN             
};

static uint8_t keymapSymbols[] = {
  KMOUSE_RIGHT, LCD_SWITCH, EXPANSION_SWITCH, KBATTERY_SWITCH, NOTIFICATION_BUZZER, POWEROFF, NOTIFICATION_LED,  'E',  'E',  KMAP_SWITCH,  KMOUSE_LEFT,
  HID_KEY_ESCAPE,       HID_KEY_APOSTROPHE, HID_KEY_BACKSLASH,  HID_KEY_SLASH,  HID_KEY_SLASH,  HID_KEY_SLASH, HID_KEY_SLASH, HID_KEY_SEMICOLON,  HID_KEY_APOSTROPHE,  HID_KEY_BRACKET_RIGHT,  HID_KEY_ARROW_LEFT,
  HID_KEY_TAB,          HID_KEY_BRACKET_RIGHT,  HID_KEY_ARROW_UP, HID_KEY_BRACKET_RIGHT, HID_KEY_BRACKET_RIGHT,      HID_KEY_BRACKET_RIGHT,  HID_KEY_BRACKET_RIGHT,    HID_KEY_BRACKET_RIGHT,      HID_KEY_BRACKET_RIGHT,  HID_KEY_BRACKET_RIGHT, HID_KEY_ARROW_RIGHT,
  HID_KEY_CAPS_LOCK,    'E',  HID_KEY_ARROW_DOWN, 'E',   HID_KEY_BRACKET_RIGHT, HID_KEY_BRACKET_RIGHT , HID_KEY_BRACKET_LEFT      , HID_KEY_BRACKET_RIGHT, HID_KEY_BRACKET_RIGHT, HID_KEY_BRACKET_RIGHT, HID_KEY_BACKSPACE,
  HID_KEY_CONTROL_LEFT , HID_KEY_GUI_LEFT,  HID_KEY_EQUAL, HID_KEY_MINUS,   HID_KEY_SLASH,   HID_KEY_BRACKET_RIGHT,      HID_KEY_KEYPAD_EQUAL,      HID_KEY_COMMA,     HID_KEY_PERIOD,     HID_KEY_BRACKET_RIGHT,  HID_KEY_RETURN
};

static char dummyKeypad[ROWS][COLS] = {
  { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10},
  {11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21},
  {22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32},
  {33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43},
  {44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54}
};

byte rowPins[ROWS] = {2, 41, 11, 12, 13};                     //connect to the row pinouts of the keypad
byte colPins[COLS] = {6, 21, 33, 36, 34, 35, 16, 1, 14, 15, 7}; //connect to the column pinouts of the 

//initialize an instance of class NewKeypad
Keypad Dummy  = Keypad(makeKeymap(dummyKeypad), rowPins, colPins, ROWS, COLS);

void setup(void){


  /*  Turn on the FET that powers on the board and RPI first */
  pinMode(POWER_MAIN, OUTPUT);
  digitalWrite(POWER_MAIN, HIGH);

  
  // Set PIN Stater
  pinMode(LED_1, OUTPUT);
  pinMode(LED_2, OUTPUT);
  pinMode(POWER_OFF_BTN, INPUT_PULLUP);
//  pinMode(POWER_EX, OUTPUT);
//  pinMode(POWER_LCD, OUTPUT);
  pinMode(BUZZER, OUTPUT);
  pinMode(BATTERY_MESUREMENT, INPUT_PULLUP);
  pinMode(PI_STATE, INPUT_PULLUP);

  // Set thumbstick PIN Stater
  pinMode(upButton, INPUT_PULLUP);
  pinMode(downButton, INPUT_PULLUP);
  pinMode(leftButton, INPUT_PULLUP);
  pinMode(rightButton, INPUT_PULLUP);
  pinMode(mouseButton, INPUT_PULLUP);


  // Set Switch State
//  digitalWrite(POWER_EX, LOW);
  digitalWrite(POWER_LCD, LOW);
  digitalWrite(BUZZER, LOW);
//  powerstate = digitalRead(POWER_OFF_BTN);

  power_lcd();
  
  // Serial setup
  Serial.begin(115200);

  // Set up Keyboard and Mouse HID
  device.begin();
  
  // Set up keypad matrix
  Dummy.setHoldTime(1);
  Dummy.setDebounceTime(0);
  Dummy.addEventListener(keypadEvent);
  delay(1000);
}

static uint16_t powered_on = 1000;
void loop(void){

//  digitalWrite(LED_1, HIGH);
//  digitalWrite(LED_2, HIGH);
//  delay(1000);                   
//  digitalWrite(LED_1, LOW);    
//  digitalWrite(LED_2, LOW);

//  Serial.println(powerstate);
//  Serial.println(digitalRead(POWER_OFF));
  static uint16_t powered_on = 1000;
/* Ignore the poweroff button just after it has been pressed to turn the power on */
  if (powered_on > 0) {
    powered_on--;
  } else {
    if (!digitalRead(POWER_OFF_BTN))
      poweroff();
  }


  // Check Mouse state
  thumbstick ();
  
  // Check Keyboard state
  processKeys();
}

static void selectAlphabet(void)
{
  digitalWrite(LED_1, LOW);
  keymapState = 0;
}

static void selectSymbols(void)
{
  digitalWrite(LED_1, HIGH);
  keymapState = 1;
}

static void switchKeymap(void)
{
  if (keymapState)
    selectAlphabet();
  else
    selectSymbols();
}

static uint8_t mapKey(char key)
{
  if (keymapState)
    return keymapSymbols[key];

  return keymapAlpha[key];
}

static void keypadEvent(KeypadEvent key)
{
  if (Dummy.getState() != PRESSED)
    return;

  uint8_t kcode = mapKey(key);
  
  switch (kcode) {
  case KMAP_SWITCH:
    switchKeymap();
  break;
  case KBATTERY_SWITCH:
    battery_state();
  break;
  case KMOUSE_LEFT:
    mouse_left();
  break;
  case KMOUSE_RIGHT:
    mouse_rgiht();
  break;
  case NOTIFICATION_BUZZER:
    notificationBuzzer();
  break;
  case EXPANSION_SWITCH:
    power_expansion();
  break;
  case NOTIFICATION_LED:
    notificationLED();
  break;
  case LCD_SWITCH:
    power_lcd();
  break;
  case POWEROFF:
    poweroff();
  break;
  }
}

static uint8_t modifierKey = 0;

static void processKeys(void)
{
 if (!Dummy.getKeys())
   return;

 int i;

 for (i = 0; i < LIST_MAX; i++) {
   if (!Dummy.key[i].stateChanged)
     continue;

   uint8_t key = mapKey(Dummy.key[i].kchar);

   if (key == KMAP_SWITCH || key == KBATTERY_SWITCH || key == NOTIFICATION_BUZZER || key == KMOUSE_LEFT || key == KMOUSE_RIGHT || key == EXPANSION_SWITCH || key == NOTIFICATION_LED || key == LCD_SWITCH || key == POWEROFF)
     continue;

   switch (Dummy.key[i].kstate) {
   case PRESSED: {
       if (key == HID_KEY_CONTROL_LEFT) {
           device.sendPress(0, KEYBOARD_MODIFIER_LEFTCTRL);
           modifierKey = KEYBOARD_MODIFIER_LEFTCTRL;
       } else if (key == HID_KEY_GUI_LEFT) {
           device.sendPress(0, KEYBOARD_MODIFIER_LEFTGUI);
           modifierKey = KEYBOARD_MODIFIER_LEFTCTRL;
       } else {
           device.sendPress(key, modifierKey);
           modifierKey = 0;
       }
   }
   break;
   case RELEASED: {
     device.sendRelease();
     modifierKey = 0;
   }
   break;
   }
 }
}

void thumbstick (void){
  
  // read the thumbstick buttons:
  int upState = digitalRead(upButton);
  int downState = digitalRead(downButton);
  int rightState = digitalRead(rightButton);
  int leftState = digitalRead(leftButton);

  // calculate the movement distance based on the button states:
  int  xDistance = (leftState - rightState) * range;
  int  yDistance = (upState - downState) * range;

  // if X or Y is non-zero, move:
  if ((xDistance != 0) || (yDistance != 0)) {
    device.move(xDistance, yDistance);
  }

  // a delay so the mouse doesn't move too fast:
  delay(responseDelay);
}


void mouse_left (void){
  device.pressLeft();
  delay(responseDelay); 
}

void mouse_rgiht (void){
  device.pressRight();
  delay(responseDelay);
}


static void power_lcd(void)
{
  if(lcdState){
    // digitalWrite(POWER_LCD, LOW);
    pinMode( POWER_LCD, OUTPUT ) ;  // pin register is LOW at set up so this forces the pin LOW
    Serial.println("POWER_LCD=LOW");
    lcdState = 0;
  } else {
    // digitalWrite(POWER_LCD, HIGH);
    pinMode( POWER_LCD, INPUT ) ;     // high impedance : allow pin (gate) to float high via pull up resistor.
    Serial.println("POWER_LCD=HIGH");
    lcdState = 1;
  }
}

//static void power_lcd(void)
//{
//  if(lcdState){
//    digitalWrite(POWER_LCD, LOW);
//    Serial.println("POWER_LCD=LOW");
//    lcdState = 0;
//  } else {
//    digitalWrite(POWER_LCD, HIGH);
//    Serial.println("POWER_LCD=HIGH");
//    lcdState = 1;
//  }
//}

static void power_expansion(void)
{
//  if(expansionState){
//    digitalWrite(POWER_EX, LOW);
//    Serial.println("POWER_EX=LOW");
//    expansionState = 0;
//  } else {
//    digitalWrite(POWER_EX, HIGH);
//    Serial.println("POWER_EX=HIGH");
//    expansionState = 1;
//  }
//
//  
  if(expansionState){
    // digitalWrite(POWER_LCD, LOW);
    pinMode( POWER_EX, OUTPUT ) ;  // pin register is LOW at set up so this forces the pin LOW
    Serial.println("POWER_EX=LOW");
    expansionState = 0;
  } else {
    // digitalWrite(POWER_LCD, HIGH);
    pinMode( POWER_EX, INPUT ) ;     // high impedance : allow pin (gate) to float high via pull up resistor.
    Serial.println("POWER_EX=HIGH");
    expansionState = 1;
  }
}

static void notificationLED(void)
{
  Serial.println("notificationLED");
  digitalWrite(LED_2, HIGH);
  delay(25);
  digitalWrite(LED_2, LOW);
  delay(25);
  digitalWrite(LED_2, HIGH);
  delay(25);
  digitalWrite(LED_2, LOW);
  delay(25);
  digitalWrite(LED_1, HIGH);
  delay(25);
  digitalWrite(LED_1, LOW);
  delay(25);
  digitalWrite(LED_1, HIGH);
  delay(25);
  digitalWrite(LED_1, LOW);
  delay(25);
}

static void notificationBuzzer(void)
{
  Serial.println("notificationBuzzer");
  digitalWrite(BUZZER, HIGH);
  delay(50);
  digitalWrite(BUZZER, LOW);
  delay(50);
  digitalWrite(BUZZER, HIGH);
  delay(50);
  digitalWrite(BUZZER, LOW);
}

static void poweroff(void)
{
//  uint8_t i;

  /* Ask RPi to powerdown */
//  Keyboard.write(CONSUMER_POWER);

//  /* Wait for about 16 seconds */
//  for (i = 0; i < 20; i++) {
//    notification();
//  }
 // delay(16000);
  /* And finally turn off the power */
  Serial.println("poweroffOFF");
  digitalWrite(POWER_MAIN, LOW);
}

static void battery_state(void)
{
  Serial.println("battery_state");
  Serial.println(read_voltage());
}

static float read_voltage(void)
{
  // Get Battery voltage
  value = analogRead(BATTERY_MESUREMENT);
  voltage = value * 5.0/1023;
//  Serial.print("Voltage= ");
//  Serial.println(voltage);
  delay(200);
  return voltage;
}

// written by
// Cyril Hrubis @metan-ucw
// Abrar @s96Abrar
// rahmanshaber @rahmanshaber

Shop

Project Hub

Video

Blog

Shop home

3D printing

Single Board Computers

Development kits

Sensors

Internet of things

Robotics

Accessories

Product of the Week

Electromaker Educator

The Electromaker Show

The Electromaker Podcast