Published April 23, 2021 © CC BY-NC-SA

Using Machine Learning To Mind Control A Flamethrower

A mind controlled flamethrower that works off of thoughts of fire: no need to try to control your meditation or concentration values.

AdvancedShowcase (no instructions)12 hours2,135

Using Machine Learning To Mind Control A Flamethrower

Things used in this project

Hardware components

Arduino Nano R3

Raspberry Pi 4 Model B

HC-05 Bluetooth Module

Software apps and online services

TensorFlow

Jupyter Notebook

Hand tools and fabrication machines

3D Printer (generic)

Soldering iron (generic)

Story

Video on the Project

Mind Control

The core of the project is the mind control and machine learning aspect. To do this part of the project, you only need the HC-05, any computer fast enough (I used a Raspberry Pi 4), and a mindflex. By the end, you will control any hardware or software switch you can connect to a Raspberry Pi!

Hacking the Mindflex

To hack a mindflex, you will first need to buy one: make sure to get at least one HC-05 and 2 HC-05s, and one extra Arduino if you want a reliable connection. You only need the headset, so you can get one on eBay for around 15 dollars. Make sure not to buy the new Starwars Force Trainer because it costs more, the electrodes are worse, and it takes a little more effort to get working.

Once you get your mindflex, you will need to set it up to wireless transmit the raw data. By default, the headset sends attention/meditation values, signal quality, and EEG power bands but only once per second at a 9600 serial baud rate. To get the mindflex into raw mode, you need to send the byte 0x02 in 9600 baud; however, since the HC-05 will be communicating in a baud rate of 56700, you will either need to send bytes that imitate 9600 in 56700 (unreliable) or use another device like an arduino nano to send the message.

I recommend using two HC-05’s that are bound together as it proves a more reliable connection than just using a standard Bluetooth connection. I won’t explain how to bind two of them together here, but here is a source on how to do it.

Open up the left side of the mindflex; you should see the internals of the mindflex. Wire the 5V of both the HC-05 and Arduino to the output of the switch on the mindflex; the GND of both to ground input of the mindflex; the RX of the HC-05 to the TX of the mindflex; and the TX of the arduino (HC-05 if not an arduino) to the RX of the mindflex. The TX and RX of the mindflex are labeled by T and R, respectively. Flash the arduino with 0x02.ino. Your mindflex should now output raw data 512 times per second.

Here is another project that deals with hacking the mindflex.

Internals of Mindflex

Connecting the Mindflex to Raspberry Pi

To start collecting the data, you need to connect the Raspberry Pi to the mindflex using the built-in Bluetooth module or another HC-05. I connected the HC-05 to the RPI’s serial pins in the GPIO as I found it was much more reliable.

Here is a post that deals with connecting an HC-05 to an RPI.

RPI Connected to HC-05

Collecting the Data

Come up with a good activation in your mind. You don’t have to use “fire” data but use whatever concept that you think would be good for an application (make sure to choose something that can be differentiated).

Use data.py on the RPI to collect data, and it should save it in a data folders called standard and fire (change the code if you want to change the titles). I recommend short recording periods of your activation state as you want the activation to be fast when actually using your model—I recorded my fire sessions for a quarter of a minute while my standard ones sometimes were an hour long.

You will probably not get equal amounts of standard and activation data as it takes much more effort and concentration to get. We will just multiply the activation data—still try to get at least 15 to 30 minutes—when preparing to train the model.

The purpose of a neural network is to handle noise: so remember to get a wide range when collecting your standard mind data. For example, when the signal quality is low, one or all of the electrodes aren’t on (these go under standard and do not pollute your other classification). All of these going under standard will help you build a resilient and accurate model. Also, try to collect data over multiple sessions to capture many different mental states.

What Collecting Data Could Look Like

Training the Model

After you think that you have gotten enough data, move the files from the RPI onto your computer, keeping the fire and standard data in separate folders. Make sure to move some standard data and fire data into respective standard and fire test folders to test the accuracy of your model.

The model uses one-dimensional CNN, a convolutional neural network: it extracts the features relevant to classifying between standard and activation. To train the model, try using my Jupyter Notebook: you just have to define the folders where you put the training standard and activation data and test data for those same types (used to test accuracy). Try new preprocessing methods, window times, and optimizations. After you click a bunch of times, you should get a TensorFlow Lite model that can be run on an RPI. If you don’t like the accuracy try collecting more data or a new activation concept—you probably won’t get over 80%.

Some of the parts are hard to understand and confusing as the code is not refined and some old unused features are still in there: ask me if you can’t figure something out. If you don’t have a desktop with a good graphics card, you can use Google Colab, a free service by Google.

The Model Architecture

Running the Model

Once you get your TFLite model, move the file onto the computer and put the model name in mind.py. Right now, I have the RPI turn on a GPIO pin, but you can define anything you want in the if statement. Good luck!

Building a Flamethrower

Honestly, I don’t recommend building a flamethrower as I think you could make some incredible and safer ideas with your AI-enabled mindflex. But if you want to build one, the concept of the flamethrower is pretty simple as it is just a solenoid valve shooting propane at an arc lighter. For this project, I 3D printed an enclosure, added buttons, and a screen to control the safety features. For the power source, I used a LiPo battery connected to a power distribution board typically used by drones: it had 5v and 12v outputs. The arc lighters are controlled by a relay, while the solenoid valve is controlled by a transistor. I use a relay to control the arc lighters and a transistor to control the solenoid valve.

I have included the stl files for the enclosures below. If you are going to use my design, I recommend wearing flame-resistant gloves. I have also included the code for the arduino nano that runs the whole thing—if you want, you can switch between mind and punch mode.

If you want to see more of the flamethrower aspect I recommend looking at Allen Pan's flamethrower here.

Code

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_LIS3DH.h>
#include <Adafruit_Sensor.h>

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels


#define SCREEN_ADDRESS 0x3C 
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire);

#define SolenoidPin 3
#define ArcLighterPin 6
//software SPI
Adafruit_LIS3DH lis = Adafruit_LIS3DH();



unsigned long punchStart = 0;//variable for non-blocking punch timeframe check
unsigned long lastTimeAccelMeasured; // variable used to check how long the last acceleration value was checked

float lastAccelMeasured = 0;
const long punchInterval = 300;

int punchAccel = 50;//the beginning of a punch in m/s^2

int flameTime = 250;



int punchMode=0;
int mindMode =0;
int timeMode =1;

int mindChargesLoaded = 0;

int sparkOn = 1;
int valveOn = 0;

const int leftButtonPin = 9;
const int rightButtonPin = 8;
const int upButtonPin = 10;
const int downButtonPin = 7;


const int mindInputPin = 2;
boolean buttonStateLeft = LOW;            
boolean lastButtonStateLeft = LOW;                
boolean currentButtonStateLeft = LOW;

boolean buttonStateRight = LOW;           
boolean lastButtonStateRight = LOW;                
boolean currentButtonStateRight = LOW;

boolean buttonStateUp = LOW;              
boolean lastButtonStateUp = LOW;                
boolean currentButtonStateUp = LOW;

boolean buttonStateDown = LOW;            
boolean lastButtonStateDown = LOW;                
boolean currentButtonStateDown = LOW; 

unsigned long lastDebounceTime = 0;       
unsigned long debounceDelay = 50;        


void updateDisplayAllModes(){
  display.clearDisplay();
  display.display();
  if(mindMode){
    updateMindDisplay();
  }
  else if(punchMode){
    updatePunchDisplay();
  }
  else if(timeMode){
    updateTimeDisplay();
  }
}

void Fire(int flameTime){
  if(mindMode && !mindChargesLoaded){
    return;
  }
  if(valveOn){
    digitalWrite(SolenoidPin, HIGH);
  }
  if(sparkOn){
    digitalWrite(ArcLighterPin, LOW);
  }
  delay(flameTime);
  digitalWrite(SolenoidPin, LOW);
  digitalWrite(ArcLighterPin, HIGH);
  if(mindMode){
    mindChargesLoaded -=1;
  }
  delay(flameTime*2);
 updateDisplayAllModes();
}

void updateMindDisplay(){
  display.clearDisplay();
  display.setCursor(0,0);
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1.5);
  display.setTextWrap(false);
  display.print("Mind");

  display.setCursor(0,20);
  display.print("Valve:");
  if(valveOn){
    display.setCursor(40,20);
    display.print("On");
  }
  else{
    display.setCursor(40,20);
    display.print("Off");
  }

  display.setCursor(0,40);
  display.print("Spark:");
  if(sparkOn){
    display.setCursor(40,40);
    display.print("On");
  }
  else{
    display.setCursor(40,40);
    display.print("Off");
  }
  display.setCursor(80,0);
  display.setTextSize(8);
    display.print(String(mindChargesLoaded));
  display.display();
}
void updatePunchDisplay(){
  display.clearDisplay();
 display.setCursor(0,0);
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1.5);
  display.setTextWrap(false);
  display.print("Punch");

  display.setCursor(0,20);
  display.print("Valve:");
  if(valveOn){
    display.setCursor(40,20);
    display.print("On");
  }
  else{
    display.setCursor(40,20);
    display.print("Off");
  }

  display.setCursor(0,40);
  display.print("Spark:");
  if(sparkOn){
    display.setCursor(40,40);
    display.print("On");
  }
  else{
    display.setCursor(40,40);
    display.print("Off");
  }
  display.setCursor(80,0);
  display.setTextSize(8);
  display.print("P");
  display.display();
  
}

void updateTimeDisplay(){
  display.clearDisplay();
  display.setCursor(40,0);
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.print("Time");

  int16_t x1, y1;
  uint16_t w, h;
  
  display.setTextSize(4);
  display.getTextBounds(String(flameTime), 0, 0, &x1, &y1, &w, &h);
  display.setCursor(64 -(w/2) ,32);
  display.setTextColor(SSD1306_WHITE);
  display.print(String(flameTime));
  //display.drawLine(64,0,64,64,SSD1306_WHITE);
  display.display();
}
void upButtonPress(){
  if(mindMode){
    if(mindChargesLoaded<10){
      mindChargesLoaded +=1;
    }
    updateDisplayAllModes();
    delay(1000);
  }
  else if(punchMode){
  }
  else if(timeMode){
    if(flameTime<1000){
      flameTime +=10;
    }
    updateDisplayAllModes();
    
  }

}
void downButtonPress(){
  if(mindMode){
    if(mindChargesLoaded>0){
      mindChargesLoaded -=1;
    }
  }
  else if(punchMode){
  }
  else if(timeMode){
    if(flameTime>10){
      flameTime -=10;
    }
    
  }
  updateDisplayAllModes();
}
void leftButtonPress(){
  if(mindMode || punchMode){
    if(valveOn && sparkOn){
      sparkOn = 0;
      valveOn = 1;
    }
    else if(!valveOn && !sparkOn){
      valveOn =0;
      sparkOn =1;
    }
    else if(valveOn){
      valveOn = 0;
      sparkOn = 0;
    }
    else if(sparkOn){
      valveOn = 1;
      sparkOn = 1;
    }
    updateDisplayAllModes();
  }
  
  
}
void rightButtonPress(){
    if(mindMode){
      mindMode = 0;
      punchMode = 1;
      timeMode = 0;
      updateDisplayAllModes();
    }
    else if(punchMode){
      mindMode = 0;
      punchMode = 0;
      timeMode = 1;
      updateDisplayAllModes();
    }
    else if(timeMode){
      mindMode = 1;
      punchMode = 0;
      timeMode = 0;
      updateDisplayAllModes();
    }
  }
void setup(void) {
  //Test to see if accelerometer is communicating
  Serial.begin(9600);
  Serial.println("LIS3DH test!");  
  if (! lis.begin(0x18) ) {   // change this to 0x19 for alternative i2c address
    Serial.println("Couldnt start");
    while (1);
  }
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }

  //display.clearDisplay();
  //display.display();
  Serial.println("LIS3DH found!");

 
  lis.setRange(LIS3DH_RANGE_16_G);   //+-16G range for good punch detection
  Serial.print("Range = "); Serial.print(2 << lis.getRange());  
  Serial.println("G");
  
  
  
  pinMode(SolenoidPin, OUTPUT);
  pinMode(ArcLighterPin, OUTPUT);



  pinMode(leftButtonPin, INPUT_PULLUP);    
  pinMode(rightButtonPin, INPUT_PULLUP);   
  pinMode(upButtonPin, INPUT_PULLUP);     
  pinMode(downButtonPin, INPUT_PULLUP);    

  pinMode(mindInputPin, INPUT);
  
  digitalWrite(SolenoidPin, LOW);
  digitalWrite(ArcLighterPin, HIGH);
  
  
  lastTimeAccelMeasured = millis();
  updateDisplayAllModes();
  delay(500);
}

void loop() {
  Serial.println(digitalRead(mindInputPin)); 
  if(mindMode){
    if(digitalRead(mindInputPin) && mindChargesLoaded){
      Serial.println((String)"Punch:" +(String)flameTime);
      Fire(flameTime);
    }
  }
  else if(punchMode){
    
    lis.read();
    sensors_event_t event; 
    lis.getEvent(&event);

 //look for punch
    unsigned long currentMillis = millis();
    float currentAccel = event.acceleration.x;
 

     if (event.acceleration.y > punchAccel){
       Serial.println(event.acceleration.y);
        
        Serial.println((String)"Punch:" +(String)flameTime);
        Fire(flameTime);
    }
  }
  else if(timeMode){
    
  }


  currentButtonStateLeft = digitalRead(leftButtonPin);          
  currentButtonStateRight = digitalRead(rightButtonPin); 
  currentButtonStateUp = digitalRead(upButtonPin);          
  currentButtonStateDown = digitalRead(downButtonPin);      
  
  if (currentButtonStateLeft != lastButtonStateLeft || currentButtonStateRight != lastButtonStateRight || 
  currentButtonStateUp != lastButtonStateUp || currentButtonStateDown != lastButtonStateDown)        
 
  {
  lastDebounceTime = millis();      
  }  
  
  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (currentButtonStateLeft != buttonStateLeft)       
    { 
    buttonStateLeft = currentButtonStateLeft;  
      Serial.println("left okay");          
      if (buttonStateLeft == LOW)                        
      {                                                 
        leftButtonPress();
      }
           
    }
    if (currentButtonStateRight != buttonStateRight)       
    { 
    buttonStateRight = currentButtonStateRight;  
                 
      if (buttonStateRight == LOW)                        
      {                                                 
        rightButtonPress();
      }
           
    }
    if (currentButtonStateUp != buttonStateUp)       
    { 
    buttonStateUp = currentButtonStateUp;  
                 
      if (buttonStateUp == LOW)                        
      {                                                 
        upButtonPress();
      }
           
    }
    if (currentButtonStateDown != buttonStateDown)       
    { 
    buttonStateDown = currentButtonStateDown;  
                 
      if (buttonStateDown == LOW)                        
      {                                                 
        downButtonPress();
      }
           
    }
      
  }
     lastButtonStateLeft = currentButtonStateLeft;       
      lastButtonStateRight = currentButtonStateRight;     
      lastButtonStateUp = currentButtonStateUp;           
      lastButtonStateDown = currentButtonStateDown;       
  

  
  }

import sys
import serial
import time
import numpy as np
import tflite_runtime.interpreter as lite
from pathlib import Path
#import pyeeg
import RPi.GPIO as GPIO


ser = serial.Serial('/dev/ttyS0', 57600)

samplingRate = 512

bands = [4, 7, 12, 30, 100]


EEGVALUES = []


rawData = []

windowLength = 256

maxPacketLength = 169
GPIO.setmode(GPIO.BOARD)
GPIO.setup(32, GPIO.OUT)

interpreter = lite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

print(input_details)

print(output_details)

POOR_SIGNAL = 0


def updateRaw(raw):
    global rawData
    global bands
    global samplingRate

    if (float(raw) > 1000.0):
        rawData.append(1.0)
    elif (float(raw) < -1000.0):
        rawData.append(-1.0)
    else:
        rawData.append(float(raw)/1000)

    if(len(rawData) >= windowLength):
        ser.reset_input_buffer()
        rawData = np.reshape(np.array(rawData, dtype=np.float32), (1, 256, 1))

       # fft = pyeeg.bin_power(rawData, bands, samplingRate)[0]/20000
        interpreter.set_tensor(input_details[0]['index'], rawData)
        interpreter.invoke()
        output_data = interpreter.get_tensor(output_details[0]['index'])
        if(output_data[0][1] > 0.7):

            GPIO.output(32, GPIO.HIGH)

            print("fire")
        else:
            GPIO.output(32, GPIO.LOW)
        rawData = []
        ser.reset_input_buffer()


callback = updateRaw


def setCallback(callbackFunction):
    callback = callbackFunction


def parsePacket(packet):
    i = 1
    while i < len(packet) - 1:

        if ord(packet[i]) == 0x02:
            POOR_SIGNAL = ord(packet[i+1])
            # print(POOR_SIGNAL)
            i += 2
        elif ord(packet[i]) == 0x04:
            ATTENTION = ord(packet[i+1])
            i += 2
        elif ord(packet[i]) == 0x05:
            MEDITATION = ord(packet[i+1])
            i += 2
        elif ord(packet[i]) == 0x16:
            BLINK_STRENGTH = ord(packet[i+1])
            i += 2
        elif ord(packet[i]) == 0x83:
            # for c in xrange(i+1, i+25, 3):
            #EEGVALUES.append(ord(packet[c]) << 16 | ord(packet[c+1]) << 8 | ord(packet[c+2]))
            i += 26
        elif ord(packet[i]) == 0x80:
            raw = ord(packet[i+2])*256 + ord(packet[i+3])
            if(raw >= 32768):
                raw = raw - 65536

            callback(raw)

            i += 4

    return True


def reader():
    previousByte = 'c'
    inPacket = False
    packet = []

    while True:

        currentByte = ser.read()

        # print(ord(previousByte))
       # print(ord(currentByte))
        if(not inPacket and ord(previousByte) == 224 and ord(currentByte) == 224):
            bytearay = b'\x00\xF8\x00\x00\x00\xE0'
            ser.write(bytearay)
            time.sleep(1)
            continue
        # checks for start of packet in two syncs
        if (not inPacket and ord(previousByte) == 170 and ord(currentByte) == 170):
            inPacket = True

            packet = []
            continue

        elif inPacket:
            if len(packet) == 0:
                if ord(currentByte) == 170:
                    continue

                # first packet after syncs is packet length
                packetLength = ord(currentByte)
                totalChecksum = 0
                packet = [currentByte]
                if packetLength > maxPacketLength:
                    inPacket = False
                    continue

            elif len(packet) - 1 == packetLength:  # checking to see if at end of packet
                packetChecksum = ord(currentByte)
                inPacket = False
                if (~(totalChecksum & 255) & 255) == packetChecksum:
                    # print("hello")
                    parsePacket(packet)
                # else:
                    #print("bruh error")

            else:
                totalChecksum += ord(currentByte)
                packet.append(currentByte)
        previousByte = currentByte


ser.reset_input_buffer()
reader()

import os
import sys
import serial
import time
import numpy as np
#from biosppy import storage
import datetime

ser = serial.Serial('/dev/ttyS0', 57600)


EEGVALUES = []

rawData = []

maxPacketLength = 169
recordingTime = 1


timeNow = datetime.datetime.now()
timeNow = timeNow.strftime("%m-%d-%Y-%H-%M-%S")

standard = True


POOR_SIGNAL = 0


def updateRaw(raw):
    global recordingTime

    rawData.append([raw])

    print(len(rawData))
    if(len(rawData) > recordingTime*60*512):
        if(standard):
            pathlib = os.path.join(os.path.expanduser("~"), "/data/standard")
            path = os.path.join(pathlib, timeNow + '.txt')
            f = open(path, "w+")
            np.savetxt(f, rawData)
            f.close()
        else:
            pathlib = os.path.join(os.path.expanduser("~"), "/data/fire")
            path = os.path.join(pathlib, timeNow + '.txt')
            f = open(path, "w+")
            np.savetxt(f, rawData)
            f.close()

        sys.exit()


callback = updateRaw


def setCallback(callbackFunction):
    callback = callbackFunction


def parsePacket(packet):
    i = 1
    while i < len(packet) - 1:

        if ord(packet[i]) == 0x02:
            POOR_SIGNAL = ord(packet[i+1])
            print(POOR_SIGNAL)
            i += 2
        elif ord(packet[i]) == 0x04:
            ATTENTION = ord(packet[i+1])
            i += 2
        elif ord(packet[i]) == 0x05:
            MEDITATION = ord(packet[i+1])
            i += 2
        elif ord(packet[i]) == 0x16:
            BLINK_STRENGTH = ord(packet[i+1])
            i += 2
        elif ord(packet[i]) == 0x83:
            # for c in xrange(i+1, i+25, 3):
            #EEGVALUES.append(ord(packet[c]) << 16 | ord(packet[c+1]) << 8 | ord(packet[c+2]))
            i += 26
        elif ord(packet[i]) == 0x80:
            raw = ord(packet[i+2])*256 + ord(packet[i+3])
            if(raw >= 32768):
                raw = raw - 65536

            callback(raw)

            i += 4

    return True


def reader():
    previousByte = 'c'
    inPacket = False
    packet = []

    while True:

        currentByte = ser.read()

        # print(ord(previousByte))
        # print(ord(currentByte))
        if(not inPacket and ord(previousByte) == 224 and ord(currentByte) == 224):
            ser.write("This is a test".encode())
            # time.sleep(1)
            continue
        # checks for start of packet in two syncs
        if (not inPacket and ord(previousByte) == 170 and ord(currentByte) == 170):
            inPacket = True

            packet = []
            continue

        elif inPacket:
            if len(packet) == 0:
                if ord(currentByte) == 170:
                    continue

                # first packet after syncs is packet length
                packetLength = ord(currentByte)
                totalChecksum = 0
                packet = [currentByte]
                if packetLength > maxPacketLength:
                    inPacket = False
                    continue

            elif len(packet) - 1 == packetLength:  # checking to see if at end of packet
                packetChecksum = ord(currentByte)
                inPacket = False
                if (~(totalChecksum & 255) & 255) == packetChecksum:
                    # print("hello")
                    parsePacket(packet)
                else:
                    print("callback error")

            else:
                totalChecksum += ord(currentByte)
                packet.append(currentByte)
        previousByte = currentByte


print("type f for fire or s for standard")
x = input()
if(x == 'f'):
    print("doing fire")
    standard = False
elif(x == 's'):
    standard = True
    print("doing standard")

print("type number of minutes wanted")

x = input()

recordingTime = float(x)
ser.reset_input_buffer()
reader()

Credits

Nathaniel Felleke

5 projects • 36 followers

Developer always trying to make new things. MIT Class of 2026.

Using Machine Learning To Mind Control A Flamethrower

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Mind Control

Building a Flamethrower

Custom parts and enclosures

RPI Mount

RPI Mount Cover

Flamethrower Mount

Flamethrower Mount Cover

Code

brainfire.ino

mind.py

data.py

0x02.ino

Jupyter Lab

Credits

Nathaniel Felleke

Comments

Embed the widget on your own site

Using Machine Learning To Mind Control A Flamethrower

Using Machine Learning To Mind Control A Flamethrower

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Mind Control

Building a Flamethrower

Custom parts and enclosures

RPI Mount

RPI Mount Cover

Flamethrower Mount

Flamethrower Mount Cover

Code

brainfire.ino

mind.py

data.py

0x02.ino

Jupyter Lab

Credits

Nathaniel Felleke

Comments

Related channels and tags