How to Become a Machine.

A journey into Transhumanism and How to become a machine.

This project began with a fascination for the Transhumanism, a techno-optimistic community with the aim is to become a machine in order to enhance their senses or defeating death by migrating from the ‘meat machine’ to the ‘steal machine’ via cryonic and mind uploading technology. Although, Transhumanism it‘s also about having ‘faith’ on a superior entity, a divine algorithm.

This project endeavours to anticipate what is the meaning of being a machine, and how it can challenge the perception we have of sharing our body with an algorithm (AI).

In collaboration with David Wood, leader of the London Transhumanist party, I am creating the machine, the transhumanism believes in. During this journey, I have realised that being a machine is not just about moving in a new body or discovering new senses, but it’s also sharing our new body with an algorithm. Does our human body is becoming the vessel of an artificial entity?

To build this experience of my future-self inside a machine I began my experiment with this question: how a machine built by humans can script human being? This was the point of start of my making process to build the exoskeleton which controls my body. Indeed, the methodology used in this project is to think through a making process. I wanted to respond to this question: How the machine can restrict a human body in order to understand the meaning of adapting ourselves inside a new body. Through this experience, I challenged my prosthesis by adding a deeper layer on how I can become this machine. In fact, at the moment I finished to build the first prosthetic arm linked to an algorithm, I challenged myself on what means being a machine. It's not just about restricting the human body to anticipate the passage of the meat machine to the steel machine. But it's understanding that our body is embodied by an algorithm in a cohabitation relationship.

I became the machine at the moment I accepted that I was controlled by it and developed new senses, not because of the restriction of my movements but because of a second algorithmic brain which communicates with me. I established an empathetic relationship with this machine, where I am literally a vessel accepting the orders of an artificial entity. In this same methodology, I came back to the London transhumanist group to ask them what they think about the idea that we will not be the only master of a new body.

With this discussion, I wanted to engage the transhumanism community with my project, which they did by interpreting my thoughts and concept between them to understand why I was making those assumptions on their faith in technologies. Even if, I strive to think that this methodology was beneficial to justify the why and how of my project, I also found this difficult to give my opinion to a community which is built on the speculation of a future where technology is the solution to any problem.

To conclude on this project where I experienced what is being a machine, by contextualising a future where transhumanist thoughts are actually real solution/situations I am making a critic of the present context where assistant technology is a reality. I strive to think that it's not about reprimanding the overuse of assistant technologies but it is to state that we should behave with them with another perspective. My aim is to say that rather than humanising algorithm we should redefine the relationship we have with it.

I deliberately auto-persuade myself that I was a robot by being controlled by an algorithm which ordered where to go depending on environmental conditions. This machine is the transhumanism representation of what will be my future-self, but also the symbolic image of the almost religious faith we put in technologies to resolve human problems. "When the Saints Go Machine" project is knowing more about human being behaviour with technology through becoming and experiencing this technology.

I consider this project as an ongoing one where the structures are defined but still to be more engaged with the techno-optimistic community. By making a tutorial on internet, I want to create a debate around the question of being a Transhumanist but also on how we currently behave with everyday technologies.

In the following steps, I will first explain to you how I became a machine and what are the materials needed to become it.

Step 1: Understanding of Transhumanism - Interviews

In order to define what is the best way to become a machine, I have been in transhumanism meetings organized by "London Futurist", the London most influent group lead by David Wood. From those discussions, I understood soon enough that in order to become this machine I should first experiment what is it to be inside a new body and being control by this body.

To anticipate the experience of having his mind uploaded inside a machine I asked them what for them will be our body and how we are going to be in control of it. They replied to me that we are going to define new senses which go beyond the one we already use by using the data the machine will intercept and use them to control our movement, our behaviour and the way we live with the information around us. One of the techno-optimistic explained to me that for him, being a machine is the most sustainable way to mitigate the effect of climate change by using humidity/temperature/CO2 sensors and restricted our body in correlation with those data.

This intense picture of the transhumanism way of thinking was the point of start to build the machine I put myself into.

Step 2: Thinking Through Making - How a Machine Built by Human Can Script a Human.

More than embracing transhuman thoughts about being a machine I needed to experiment with the material and started to constitute my machine.

To start aforementioned experimentation I disassembled a 3D printer to recycle the old parts and incorporate them into my body.

I put a 3D model of a human into the 3D printer controller and install the X/Y/Z motors into my elbow and shoulder to see how the original purpose of making objects can be translated to manipulate and restrict the human body. Promptly, it appeared that the human mechanics are not as flexible as the 3D printer would like them to be.

Even if this experience was thoughtful, it still lacks some materials to properly talk about understanding and experience what is being a machine. From this adventure, let's move to a deepest understanding of the human body to control in a better way.

Step 3: Becoming Through Making. the Human/Machine First Exoskeleton

Here we are! Let's build the first robotic arm.

This crappy making is the result of research on what are the mechanics of the human body and the translation of those mechanics into three pieces of wood and a 12v linear actuator motor controlled by an Arduino controller. The middle piece is the representation of the elbow which needs to be both attached to the actuator the (upper-arm) and the other arm part. Depending on the size of the elbow and its position it will more or less change the movement of the arm.

Step 4: Design the Body Frame + Creating the Algorithm to Control It

After determining the mechanics of the arm, I followed this path to build the following body parts:

• x2 arms controllers
• x2 legs controllers
• x2 hand controller

The body parts are controlled by a temperature/humidity sensor which controlled the movement of the body by restricting my body and communicating with me through fingers sign.

From this step, I realized what means being a machine. It's not just about restricting the human body to anticipate the passage of the meat machine to the steel machine. But it's understanding that our body is embodied by an algorithm in a cohabitation relationship.

I became the machine at the moment I accepted that I was controlled by it and developed new senses, not because of the restriction of my movements but because of a second algorithmic brain which communicates with me. I established a relationship with this machine, where I am literally a vessel accepting the orders of an artificial entity.

Step 5: I Am a Machine.

To conclude on this project where I experienced what is being a machine, by contextualizing a future where transhumanist thoughts are actually real solution/situations I am making a critic of the present context where assistant technology is a reality. I strive to think that it's not about reprimanding the overuse of assistant technologies but it is to state that we should behave with them with another perspective. My aim is to say that rather than humanizing algorithm we should redefine the relationship we have with it.

I deliberately auto-persuade myself that I was a robot by being controlled by an algorithm which ordered where to go depending on environmental conditions. This machine is the transhumanism representation of what will be our future-self, but also the symbolic image of the almost religious faith we put in technologies to resolve human problems.

"When the Saints Go Machine" project is knowing more about human being behaviour with technology through becoming this technology.

Step 6: DIY: Become a Machine!

It's now your turn to experiment yourself as a machine.

Material Needed:

• x3 Arduino controllers
• x1 DHT 22 Temperature/humidity/gas sensor
• x3 12 batteries
• Acrylic pieces to build the machine parts
• Polymer
• x20 M4 bolts
• x20 M4 nuts
• Wires females/males
• x4 12v linear actuator motors
• x6 3.3 360° servo motors

ArmsxLegs code:

#include

<p>#define MOTORLATCH 12
#define MOTORCLK 4
#define MOTORENABLE 7
#define MOTORDATA 8</p><p>#define MOTOR1_A 2
#define MOTOR1_B 3
#define MOTOR2_A 1
#define MOTOR2_B 4
#define MOTOR3_A 5
#define MOTOR3_B 7
#define MOTOR4_A 0
#define MOTOR4_B 6</p><p>#define MOTOR1_PWM 11
#define MOTOR2_PWM 3
#define MOTOR3_PWM 6
#define MOTOR4_PWM 5
#define SERVO1_PWM 10
#define SERVO2_PWM 9</p><p>#define FORWARD 1
#define BACKWARD 2
#define BRAKE 3
#define RELEASE 4</p><p>Servo servo_1;
Servo servo_2;
Servo servo_3;
Servo servo_4;</p><p>void setup()
{
  Serial.begin(9600);
  Serial.println("Simple Motor Shield sketch");</p><p>  servo_1.attach(SERVO1_PWM);
  servo_2.attach(SERVO2_PWM);
}</p><p>void loop()
{</p><p>  servo_1.write(255);  
    servo_2.write(255);  
  delay(1000);
  servo_1.write(180);
    servo_2.write(180);
  delay(2000);</p><p>  motor(1, BACKWARD, 128);</p><p>  delay(10000 );
  motor(1, RELEASE, 0);</p><p>  delay(50);
  motor(1, FORWARD, 255);</p><p>  delay(10000);
  motor(1, RELEASE, 0);</p><p>    delay(50);</p><p>    motor(2, BACKWARD, 128);
  delay(10000 );</p><p>    motor(2, RELEASE, 0);
  delay(50);</p><p>   motor(2, FORWARD, 255);
  delay(10000);</p><p>    motor(2, RELEASE, 0);
    delay(50);</p><p>}</p><p>void motor(int nMotor, int command, int speed)
{
  int motorA, motorB;</p><p>  if (nMotor >= 1 && nMotor <= 4)
  {  
    switch (nMotor)
    {
    case 1:
      motorA   = MOTOR1_A;
      motorB   = MOTOR1_B;
      break;
    case 2:
      motorA   = MOTOR2_A;
      motorB   = MOTOR2_B;
      break;
    case 3:
      motorA   = MOTOR3_A;
      motorB   = MOTOR3_B;
      break;
    case 4:
      motorA   = MOTOR4_A;
      motorB   = MOTOR4_B;
      break;
    default:
      break;
    }</p><p>    switch (command)
    {
    case FORWARD:
      motor_output (motorA, HIGH, speed);
      motor_output (motorB, LOW, -1);     // -1: no PWM set
      break;
    case BACKWARD:
      motor_output (motorA, LOW, speed);
      motor_output (motorB, HIGH, -1);    // -1: no PWM set
      break;
    case BRAKE:
      // The AdaFruit library didn't implement a brake.
      // The L293D motor driver ic doesn't have a good
      // brake anyway.
      // It uses transistors inside, and not mosfets.
      // Some use a software break, by using a short
      // reverse voltage.
      // This brake will try to brake, by enabling 
      // the output and by pulling both outputs to ground.
      // But it isn't a good break.
      motor_output (motorA, LOW, 255); // 255: fully on.
      motor_output (motorB, LOW, -1);  // -1: no PWM set
      break;
    case RELEASE:
      motor_output (motorA, LOW, 0);  // 0: output floating.
      motor_output (motorB, LOW, -1); // -1: no PWM set
      break;
    default:
      break;
    }
  }
}</p><p>void motor_output (int output, int high_low, int speed)
{
  int motorPWM;</p><p>  switch (output)
  {
  case MOTOR1_A:
  case MOTOR1_B:
    motorPWM = MOTOR1_PWM;
    break;
  case MOTOR2_A:
  case MOTOR2_B:
    motorPWM = MOTOR2_PWM;
    break;
  case MOTOR3_A:
  case MOTOR3_B:
    motorPWM = MOTOR3_PWM;
    break;
  case MOTOR4_A:
  case MOTOR4_B:
    motorPWM = MOTOR4_PWM;
    break;
  default:
    // Use speed as error flag, -3333 = invalid output.
    speed = -3333;
    break;
  }</p><p>  if (speed != -3333)
  {
    // Set the direction with the shift register 
    // on the MotorShield, even if the speed = -1.
    // In that case the direction will be set, but
    // not the PWM.
    shiftWrite(output, high_low);</p><p>    // set PWM only if it is valid
    if (speed >= 0 && speed <= 255)    
    {
      analogWrite(motorPWM, speed);
    }
  }
}</p><p>// ---------------------------------
// shiftWrite
//
// The parameters are just like digitalWrite().
//
// The output is the pin 0...7 (the pin behind 
// the shift register).
// The second parameter is HIGH or LOW.
//
// There is no initialization function.
// Initialization is automatically done at the first
// time it is used.
//
void shiftWrite(int output, int high_low)
{
  static int latch_copy;
  static int shift_register_initialized = false;</p><p>  // Do the initialization on the fly, 
  // at the first time it is used.
  if (!shift_register_initialized)
  {
    // Set pins for shift register to output
    pinMode(MOTORLATCH, OUTPUT);
    pinMode(MOTORENABLE, OUTPUT);
    pinMode(MOTORDATA, OUTPUT);
    pinMode(MOTORCLK, OUTPUT);</p><p>    // Set pins for shift register to default value (low);
    digitalWrite(MOTORDATA, LOW);
    digitalWrite(MOTORLATCH, LOW);
    digitalWrite(MOTORCLK, LOW);
    // Enable the shift register, set Enable pin Low.
    digitalWrite(MOTORENABLE, LOW);</p><p>    // start with all outputs (of the shift register) low
    latch_copy = 0;</p><p>    shift_register_initialized = true;
  }</p><p>  // The defines HIGH and LOW are 1 and 0.
  // So this is valid.
  bitWrite(latch_copy, output, high_low);</p><p>  // Use the default Arduino 'shiftOut()' function to
  // shift the bits with the MOTORCLK as clock pulse.
  // The 74HC595 shiftregister wants the MSB first.
  // After that, generate a latch pulse with MOTORLATCH.
  shiftOut(MOTORDATA, MOTORCLK, MSBFIRST, latch_copy);
  delayMicroseconds(5);    // For safety, not really needed.
  digitalWrite(MOTORLATCH, HIGH);
  delayMicroseconds(5);    // For safety, not really needed.
  digitalWrite(MOTORLATCH, LOW);
}</p>

Hands code:

<p>#include <servo.h><br></servo.h></p><p>Servo myservo;
Servo myservo2;
Servo myservo3;
Servo myservo4;
Servo myservo5;
Servo myservo6;
int pos = 0;</p><p>void setup() {
  myservo.attach(9);
  myservo2.attach(10);
  myservo3.attach(11);
  myservo4.attach(3);
  myservo5.attach(5);
  myservo6.attach(6);
}</p><p>void loop() {
  for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
    // in steps of 1 degree
    myservo.write(pos);
    myservo2.write(pos);
    myservo3.write(pos);
    myservo4.write(pos);
    myservo5.write(pos);
    myservo6.write(pos); // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
    myservo.write(pos);
    myservo2.write(pos);
    myservo3.write(pos);
    myservo4.write(pos);
    myservo5.write(pos);
    myservo6.write(pos);            // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
}</p>