Team 4:

•

Isaac Polson

Published November 22, 2022 © MIT

Variable Runner Length Dyno Data Acquisition Unit

To acquire data and determine the most optimized intake runner length for 49ers Racing's FSAE car.

AdvancedFull instructions providedOver 2 days409

Variable Runner Length Dyno Data Acquisition Unit

Things used in this project

Hardware components

Particle Argon

Adafruit Standard LCD - 16x2 White on Blue

Rotary Encoder with Push-Button

Li-Ion Battery 1000mAh

SparkFun Serial Basic Breakout - CH340C and USB-C

Slide Switch

Rocker Switch, Non Illuminated

Adafruit USB Li Ion Battery Charger

SparkFun Step-Up Voltage Regulator - 3.3V

SparkFun Snappable Protoboard

Female Header 8 Position 1 Row (0.1")

Circular Connector, Panel Mount Plug

SparkFun Dual H-Bridge motor drivers L298

DC/DC Converter, Buck Regulator

DC Power Connector, Straight

LED (generic)

Jumper wires (generic)

Super Flow CFM Sensor

150mm Linear Actuator

Hand tools and fabrication machines

3D Printer (generic)

Soldering iron (generic)

Solder Wire, Lead Free

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Story

Introduction

The challenge that a lot of Formula SAE teams encounter when designing their intakes is how long they should make their runner. A runner is the actual tube that connects the intake (plenum) and the intake ports. Theoretically the longer the runner is the more power the engine will make at lower rpms. Whereas, the shorter length runner will make more power at a higher rpm. However, we would like to find a middle ground between these to get the best power we can at high and low rpms. In order to test this we have decided to make a Variable Runner Length Data Acquisition Unit That will be used in conjecture with our Eddy Current Dynamometer and KTM 450cc engine.

We split the project into two main circuits. The first circuit was a Wireless meant to allow whoever is controlling the dyno to adjust the runner length without going into the same room as the engine while its running. The circuit will then be connected to a second circuit known as the Data Acquisition Unit. The Data Acquisition Unit's main purpose is to control the actuator and collect data.

The circuits used in the Wireless Controller, and the Data Acquisition Unit are shown in the Schematics section of the project.

Wireless Controller

Figure 1: Completed Wireless Controller

The components used in the Wireless Controller's circuit includes:

potentiometer
Rotary encoder
LCD display
battery for remote power
Adafruit USB Li-Ion Battery Charger
2 on/off switches
Particle argon.

The Circuit for the Wireless Controller was built on a custom protoboard and was sized to fit our custom 3D printed enclosure (Figure 1). The first on/off switch turns on the power from the battery and runs to the argon and LCD display. Once turned on the LCD display will display what length the runner is actually set at. The value can be adjusted through the rotary encoder that will send a signal through the particle argon and into the cloud to the Data Acquisition Unit to tell it to adjust the length and when it sends a signal back it will then change the LCD's value. There is also a switch to allow us to turn on/off the data logging program, as well as a custom Li-Po circuit that allows us to charge the battery while everything is plugged in.

Data Acquisition Unit

Figure 2: Data Acquisition Unit

The components used in the Data Acquisition Unit includes:

RPM Sensor
Superflow Volumetric Flow Sensor (CFM)
150mm Linear Actuator with Position Sensor
H-bridge Motor Controller
DC Buck Converter
DC Power Switch
DC Barrel Connector
3x LED lights
Particle Argon

Just like in our wireless controller the Data Acquisition Units circuit was created on its own custom protoboard and enclosed in a custom 3D printed enclosure. The Data Acquisition Unit houses most of the sensors for the project. The three main sensors that we used for the project are a RPM Sensor, Linear Actuator with Position Sensor, and a Volumetric Flow Sensor. The RPM Sensor (Figure 3) gets its signal from the KTM 450's crank position sensor. The signal is then sent to our custom MATLAB script where it is analyzed to allow us to calculate the theoretical Mass Air Flow of the project.

Figure 3: RPM Sensor

The second sensor that we used in our project was the Volumetric Flow Sensor made by Superflow (Figure 4). This sensor is used to record CFM data that will be used to calculate our actual Mass Air Flow. Using the MATLAB script we can then use the actual and theoretical Mass Air Flow to get our volumetric efficiency throughout the RPM range.

Figure 4: Superflow Volumetric Flow Sensor

The final and most important sensor that we used in our project was a 150mm Linear actuator with a position sensor (Figure 5). The actuator works in conjunction with the Wireless Controller to adjust the Variable Runner Length. The runner receives a signal from the the Rotary Encoder that is apart of the Wireless Controller and adjusts its length based off of that signal. It then sends another signal back to the Wireless Controller to update the LCD display with the new dimension.

Figure 5: 150mm Linear Actuator with Position Sensor

Custom Variable Intake

Figure 6: Custom Variable Runner intake for Dyno Testing

Figure 3 shows a CAD render of what the custom 3D printed variable runner intake that was designed to work with the linear actuator to allow us to fully demonstrate and test for the optimal runner length for a 450cc engine.

Communication

Figure 7: Particle Argon communication Flow Chart

Data Logging

In order to to calculate the most optimized runner length. We take the CFM data from the Volumetric Flow sensor, the RPM data from the RPM Sensor, and the Actuator's current length data (Figure 8). This data was recorded in the Data Acquisition Unit after which it can be opened in MATLAB where our code will Calculate Theoretical Air Mass Flow from the RPM data, and Actual Air Mass Flow from the CFM data. It is then put together to calculate the overall Volumetric Efficiency at each runner length and RPM. It is then plotted on the graph shown in Figure 9.

Figure 8: starting Runner Length, CFM Data, and RPM being calculated

Figure 9: Volumetric Efficiency at each length and RPM.

Video Submission

Dyno Room Demonstration

Conclusion

Our overall goal of creating a Variable Runner Length Dyno Data Acquisition Unit that will allow us to find the most optimized runner length to achieve the largest Volumetric Efficiency value for 49ers Racing's FSAE car was accomplished through this project. In our video submission above we demonstrate how the dyno user can remotely adjust the intakes runner length from the control room without having to go into the dyno room, and what it looks like when data is being collected from the RPM sensor, Linear actuator, and Volumetric flow sensor live from the engine and how it is converted to Volumetric efficiency in MATLAB, and finally plotted into a graph.

Schematics

Code

// Pin Map
int FORWARD = D3;   //forward enable pin on motor controller
int REVERSE = D2;   //reverse enable pin on the motor controller
int ENCODER = A0;   //potentiometer connected to analog pin A1
int GREEN = D10; 
int RED = D11;
int YELLOW = D9;

int IntData = 0;
int dataLit = D7;
int dataPin = D6;

//#include <time.h>
unsigned long myTime;

// Here is where we will save the temp, current, cfm vars
double cfm = 0;
double runLen = 0;
double RPM = 0;

int CFMPin = A1; //input for cfm meter
int RPMPin= A3;

void setup()
{
    pinMode(FORWARD, OUTPUT);    // sets pin as output
    pinMode(REVERSE, OUTPUT);    // sets pin as output
    pinMode(GREEN, OUTPUT);     // sets pin as output
    pinMode(RED, OUTPUT);     // sets pin as output
    pinMode(YELLOW, OUTPUT);     // sets pin as output
    Particle.subscribe("Runner_Length", adjustrunner);
    Particle.subscribe("Data Logger", datalogger);
    
  // Set the port speed for serial window messages
  Serial.begin(9600);
  Serial.println("TimeStamp, Runner Length, RPM, CFM");
}


// handles to inputs from the wireless controller
void adjustrunner(const char *event, const char *data)
{
    String myData = data;
    IntData =   myData.toInt();
    IntData = IntData*693.42/10;
}

// handles to inputs from the wireless controller
void datalogger(const char *event, const char *data)
{
    if(strcmp(data, "Door Open") == 0){
        digitalWrite(dataPin, HIGH);
        digitalWrite(dataLit, HIGH);
    }else if (strcmp(data, "Door Closed") == 0){
        digitalWrite(dataPin, LOW);
        digitalWrite(dataLit, LOW);
    }
}


void loop()
{
   if (analogRead(ENCODER)!= (IntData)) {
        if (analogRead(ENCODER) > (IntData) + 40 ) {
            digitalWrite(REVERSE, HIGH);
            digitalWrite(FORWARD, LOW);
            digitalWrite(GREEN, LOW);
            digitalWrite(RED, HIGH);
            digitalWrite(YELLOW, LOW);
        }
        else if (analogRead(ENCODER) < (IntData) - 40) {
            digitalWrite(REVERSE, LOW);
            digitalWrite(FORWARD, HIGH);
            digitalWrite(GREEN, LOW);
            digitalWrite(RED, LOW);
            digitalWrite(YELLOW, HIGH);
        }
        else {
            digitalWrite(REVERSE, LOW);
            digitalWrite(FORWARD, LOW);
            digitalWrite(GREEN, HIGH);
            digitalWrite(RED, LOW);
            digitalWrite(YELLOW, LOW);
        }
    }
    Particle.publish("Runner", String(encoderPos), PUBLIC); 
    
  //char charRead'
  myTime = millis();
  char dataStr[100] = "";
  char buffer[7];

  dtostrf(myTime, 1, 0, buffer);
  strcat(dataStr, buffer);
  strcat(dataStr, ",");

  runLen = analogRead(ENCODER);
  runLen = runLen/126.5;
  dtostrf(runLen, 2, 1, buffer);
  strcat(dataStr, buffer);
  strcat(dataStr, ",");

  RPM = readRPM();
  dtostrf(RPM, 2, 1, buffer);
  strcat(dataStr, buffer);
  strcat(dataStr, ",");
  
  cfm = readCFM();
  dtostrf(cfm, 2, 1, buffer);
  strcat(dataStr, buffer);
  strcat(dataStr, ",");
  strcat(dataStr, 0); //terminate correctly 

  Serial.println(dataStr);  
}

double readRPM(){
  int counter = 0;
  double sensorReading = 0;
  double priorReading = 0;
  double RPm = 0;


  int starttime = millis();
  int endtime = starttime;
  while ((endtime - starttime) <=100){
    sensorReading = analogRead(RPMPin);
    //count rotations per second based on voltage flips
    if ((sensorReading > 800 && priorReading < 200) || (sensorReading < 200 && priorReading > 800)){
      counter += 1;
    }
    priorReading = sensorReading;
    endtime = millis();
  }
  
  RPM = counter / 2*60*10;
  
  return RPM;
}

double readCFM(){
  int counter = 0;
  double sensorReading = 0;
  double priorReading = 0;
  double cfm = 0;


  int starttime = millis();
  int endtime = starttime;
  while ((endtime - starttime) <=100){
    sensorReading = analogRead(CFMPin);
    //count rotations per second based on voltage flips
    if ((sensorReading > 800 && priorReading < 200) || (sensorReading < 200 && priorReading > 800)){
      counter += 1;
    }
    priorReading = sensorReading;
    endtime = millis();
  }
  
  counter = counter / 2*10;

  // calc cfm for 4 inch turbine
  cfm = 0.2378*counter + 2.9045;
  
  return cfm;
}

// This #include statement was automatically added by the Particle IDE.
#include <LiquidCrystal.h>
LiquidCrystal lcd(5, 4, 3, 2, 1, 0);

void doEncoderA();
void doEncoderB();

int encoderA = D10;
int encoderB = D11;
int switchPin = D13;
//int switchPin = D13;
int ledPin = D7;

volatile bool A_set = false;
volatile bool B_set = false;
volatile int encoderPos = 0;

// variables will change:
int prevPos = 0;
int value = 0;
int switchVal;
int IntData = 0;
int oldVal = LOW;

// The following line is optional, but recommended in most firmware. It
// allows your code to run before the cloud is connected. In this case,
// it will begin blinking almost immediately instead of waiting until
// breathing cyan,
//SYSTEM_THREAD(ENABLED);

void setup() {
    // Setup LCD
    lcd.begin(16,2);
    lcd.print("Runner Length:");
    lcd.setCursor(0,1);
    lcd.print(0.00);
    lcd.setCursor(4,1);
    lcd.print("in");
    pinMode(encoderA, INPUT_PULLUP);
    pinMode(encoderB, INPUT_PULLUP);
    pinMode(ledPin, OUTPUT);
    pinMode(switchPin, INPUT);
    attachInterrupt(encoderA, doEncoderA, CHANGE);
    attachInterrupt(encoderB, doEncoderB, CHANGE);
    Serial.begin(9600);
    Particle.subscribe("Runner", printdata);
}

void loop() {
    //Read encoder value
    if (prevPos != encoderPos) {
        prevPos = encoderPos;
        lcd.setCursor(0,1);
        lcd.print(encoderPos*0.1);
        Particle.publish("Runner_Length", String(encoderPos), PUBLIC); 
    }
    
    switchVal = digitalRead(switchPin);
    if ((switchVal == HIGH)&& (oldVal == LOW)){
        digitalWrite(ledPin, HIGH);
        Particle.publish("Data Logger", "Door Open", PUBLIC);
        oldVal = HIGH;
    }
    else if ((switchVal == LOW)&& (oldVal == HIGH)){
        digitalWrite(ledPin, LOW);
        Particle.publish("Data Logger", "Door Closed", PUBLIC);
        oldVal = LOW;
    }
}

// handles to inputs from the wireless controller
void print data(const char *event, const char *data)
{
    lcd.setCursor(8,1);
    lcd.print(data);
    lcd.setCursor(12,1);
    lcd.print("in");
}

//----------------------------------------------------------------
void doEncoderA(){
    if( digitalRead(encoderA) != A_set ) {  // debounce once more
        A_set = !A_set;
        // adjust counter + if A leads B
        if ( A_set && !B_set ) 
            if (encoderPos < (150/25.4/0.1)-0.1)
            {
                encoderPos += 1;
        }
    }
}

// Interrupt on B changing state, same as A above
void doEncoderB(){
   if( digitalRead(encoderB) != B_set ) {
    B_set = !B_set;
    //  adjust counter - 1 if B leads A
    if( B_set && !A_set ) 
        if (encoderPos > 0)
        {
            encoderPos -= 1;
        }
  }
}

%% This programs RPM versus Volumetric Efficiency to determine optimal Runner Length

%By: Joseph Cranfill
% Date: 11/08/2022

clear
clc
close all

%% Inputs
% log file from arduino
data = readtable('datalog.log');

% Manifold absolute pressure
MAP = 101.325; % KPa

% Intake air temperature of Rankine
IAT  = 22; % deg C

% Engine displacment in CC
DIS = 450; % CC

% Dyno Air Density
AirDen = 0.072; % lb/ft^3

% Turn on or off best fit lines
fit = false;

% Polynomial Degree
deg = 12;

%% Constants
% Linear Actuator
minPos = 0; %in
maxPos = 5.9; %in
resolution = 0.1; %in

%% --------------------- DO NOT EDIT BELOW THIS LINE ---------------------
% Pulls CFM, RMP and Runner Length from the data log
data = table2array(data);
MAFmeasured = data(:,4);
RPM = data(:,3);

%% Conversions
% CC to cubic inches
DIS = DIS/16.387;

% Celsius to Rankine
IAT = IAT * (9/5) + 491.67;

% KPa to PSI
MAP = MAP / 6.895;

% Converts CFM to lb/min
MAFmeasured = MAFmeasured*AirDen;

%% Calculations
% Calculates the theroretical Mass AirFlow in lb/min
MAFtheoretical = ((DIS*(RPM./2))/12^3)*(2.7*(MAP/IAT));

% calculates volumetric efficiency
VE=MAFmeasured./MAFtheoretical*100;

%% Compile data into one matrix
% Timestamp, runner length, rpm, MAF Measured, MAF Theoretical, Volumetric
% Efficiency
data = cat(2,data,MAFmeasured, MAFtheoretical, VE);
% clears matrixes used for calculations
clear RPM
clear MAFtheoretical
clear MAFmeasured
clear VE
data(:,1) = [];
data(:,3) = [];
data(:,3) = [];
data(:,3) = [];

% Seperates all the data based on runner length
for i = (minPos +1):((maxPos/resolution)+1)
    Length{i}=[data(data(:,1) == (i-1)*resolution,2),data(data(:,1)== (i-1)*resolution,3),data(data(:,1)== (i-1)*resolution,1)];
end

%% Graph
% Calculates the max RPM from the collected data
maxRPM = 0;
for row = 1:size(data,1)
    if abs(data(row,2)) > abs(maxRPM)
        maxRPM = abs(data(row,2));
    end
end

x = 0:1:maxRPM;

for j = (minPos +1):((maxPos/resolution)+1)
    str=sprintf('L = %2.2f in',((j-1)*resolution));
    if fit == 1
        matrix = isempty(Length{j});
        plot(Length{j}(:,1),Length{j}(:,2),'.','HandleVisibility','off')
        hold on
        if matrix == 0
            p{j} = polyfit(Length{j}(:,1),Length{j}(:,2),deg);
            y{j} = polyval(p{j},x);
            plot(x,y{j},'DisplayName',str)
            hold on
        end
    else
        plot(Length{j}(:,1),Length{j}(:,2),'.','DisplayName',str)
        hold on
    end
end

grid on
set(gca, 'fontsize', 14)
xlabel ('Engine Speed(RPM)')
ylabel ('Volumetric Efficiency(%)')
title ('Volumetric Efficiency with Varying Runner Lengths')
legend
legend('Location','eastoutside')

Credits

Joseph Cranfill

1 project • 2 followers

Contact

Variable Runner Length Dyno Data Acquisition Unit

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

Custom parts and enclosures

Wireless Controller Clear Lid

Wireless Controller Housing

Wireless Controller Knob

Data Acquisition Unit Lid

Data Acquisition Unit Box

Schematics

Wireless Controller

Data Acquisition Unit Control Box

Code

Data Acquisition Unit Control Box

Wireless Controller

Analysis Code

Credits

Joseph Cranfill

Isaac Polson

Comments

Embed the widget on your own site

Variable Runner Length Dyno Data Acquisition Unit

Variable Runner Length Dyno Data Acquisition Unit

Things used in this project

Hardware components

Hand tools and fabrication machines

Story

Custom parts and enclosures

Wireless Controller Clear Lid

Wireless Controller Housing

Wireless Controller Knob

Data Acquisition Unit Lid

Data Acquisition Unit Box

Schematics

Wireless Controller

Data Acquisition Unit Control Box

Code

Data Acquisition Unit Control Box

Wireless Controller

Analysis Code

Credits

Joseph Cranfill

Isaac Polson

Comments

Related channels and tags