Neeuro: NeeuroOS SenzeBand SDK (1.0.0)

An SDK (Software Development Kit) is a set of platform-specific building tools for developers. The NeeuroOS SDK allows you to access the SenzeBand 2 and develop your own applications using the Neeuro SenzeBand's EEG technology.

Each package will have a platform specific sample project with code with comments on how to use the SDK.

In the Neeuro SenzeBand SDK Standard version, the SDK will analyze the data recieved from the SenzeBand and provide the following output for use in your application:

1. Mental state - attention classification
2. Mental state - relaxation classification
3. Mental state - workload classification
4. Oxygen level (SPO2) and heart rate
5. Accelerometer values - X, Y, Z axes (9-axis motion sensor readings)
6. Battery level
7. Channel signal status - (T/F) strong EEG signal detected on 4 channels
8. Signal ready status - (T/F) sufficient strong EEG signal received for signal processing for Mental States
9. Connection status - (T/F) Good connection on BLE, no data lost
10. Frequency band readings
11. Raw and filtered EEG (electroencephalogram) data
12. Raw PPG (photoplethysmography) data

General requirements

Bluetooth requirements:

• SenzeBand 1 - Bluetooth 4.0
• SenzeBand 2 - Bluetooth 5.0

Native Android requirements

Minimum device Android:

• Android 8

Native iOS requirements

Minimum device iOS:

• iOS 11.0 Minimum Xcode version:
• Xcode 14

Native Windows requirements

• Bluetooth connection capability (can use Bluetooth dongle)

Unity requirements

Minimum device OS:

• Android 5.0 (Lollipop, API level 21)
• iOS 8

Minimum Unity version:

• Unity 2022.2.4f1

Additional requirements for Android build

• Android SDK at least API level 26 (preferably latest version)
• Gradle 7.5.1 or later

Additional requirements for iOS build

• Xcode 14 or later

Additional requirements for Windows build

• Bluetooth connection capability (can use Bluetooth dongle)

Unsupported devices:

• iPad 2
• Samsung Tab A (2016) 7-inch
• Some computers' Bluetooth hardware may not be able to support the data transfer rate
• Refer to Device Compatibility for more information

Language	Platform and Operating systems
Java	Native Android
Objective C	Native iOS
C#	Native Windows, Unity on Android, iOS, Windows

Thank you for your interest. To get started ensure that you have SenzeBand 2. Then, fill up this form. We will provide you with a developer's code and access to the NeeuroOS.

Your Developer Code is a unique ID that is given when you register as a Developer with Neeuro. Please contact support@neeuro.com if you have not received your Developer Code.

In order to use the SENZEBAND-SDK-STANDARD functions, the app has to use the Developer Code to authenticate with Neeuro's servers. Internet connection is needed. Every successful authentication will give a period of time for the app to use the SDK functions.

Depending on which platform your SDK package is for, navigate to that section and follow the instructions on setting up and building the NeeuroOS SDK. Then, use that platform's quick-start guide to begin development.

Is there a trial period for NeeuroOS?

We offer 1 month free trial for NeeuroOS. Licensing Fee is chargeable after the trial period. To find out more, please contact us at contact@neeuro.com.

Can the SenzeBand 2 be incorporated in a cap or headgear like protective helmets or ARs/VRs?

Yes, the SenzeBand 2 is designed to be flexible and worn with headgears. However, it will still depend on the design of the headgear and whether the SenzeBand can fit properly. For more information, please contact us at contact@neeuro.com.

---

• SenzeBand information: MAC address
• Check the connectivity of the electrodes and head
• Battery level and charging status
• Event Evoke to send marker into EEG data package
  • This is to provide synchronization for SB2 and software during data recording.
  • The behavioural experiment software can be programmed to send command into SB2 through BT5.0 connection every time you need to mark something relevant in your experiment (like the subject being asked to close his/her eyes, the presentation of an image or a sound, etc.). The EEG data package will have synchronous samples of the EEG signal from the electrodes and the recorded event marker log (elapsed time) so they are perfectly aligned.

EEG Frequency Bands

Frequency Band	Frequency Range	Brain States
Delta	1-4 Hz	Sleep, repair, unawareness, deep-unconsciousness
Theta	4-8 Hz	Creativity, intuition, daydreaming
Alpha Lower Alpha Higher Alpha	8-12 Hz 8-10 Hz 10-12 Hz	Alertness and peacefulness, readiness, meditation, deep relaxation
Beta Lower Beta Higher Beta	12-30 Hz 12-20 Hz 20-30 Hz	Focus, thinking, sustained attention, alertness, excitement
Gamma	30-40 Hz	Learning, cognitive processing, problem solving tasks

• A 9-axis IMU (inertial measurement unit) adds information from a 3-axis magnetometer to the gyroscope and accelerometer. The magnetometer measures magnetic fields, delivering a fixed point of reference (Earth's magnetic field). This data can be fused with the gyroscope and accelerometer data to deliver absolute heading: Not only how many degrees heading have changed, but its relation to magnetic north. In the same way, 9-axis devices also measure attitude (yaw, pitch, roll), or absolute orientation against a frame of reference.
• Drones, for example, can orient themselves to travel in a certain cardinal direction to follow the sun over the hills, or search an area more effectively.
• The accelerometer values come at 1Hz, ie. 1 sample in data packet every second.

The activity LED indicator is programmable using the NeeuroOS with the following programmable colours.

• Colour: Red, Blue, Green, Yellow, Magenta and Cyan
• Frequency time range to ON/OFF the LED light: 0 to 60000ms (60secs)

---

1. Unzip the SDK folder and make sure all these files are inside.

2. Open the Android project in Android Studio to run the application.

3. Input your Developer Code in the initializeSenzeBandStandard function.

4. Then, run the app.

---

This section will walk you through how to develop your own app using the Neeuro SenzeBand (NSB) Android Standard SDK.

Development using the Neeuro SenzeBand (NSB) Android Standard SDK can be done in the following stages:

1. Initialisation
2. Scanning
3. Connecting
4. Authenticating
5. Impedance Check and Calibration
6. Using the SenzeBand
7. Disconnecting
8. Writing to Files

1. Having set up and built the NeeuroOS SDK, MainActivity.java will be the main script for working with the SDK.
2. Add the following line to start of the file MainActivity.java. This class contains the commands required to scan for and connect to SenzeBands.

  import com.neeuro.NativeNSBPlugin.NativeNSBInterface;

3. Enter Developer Code in initializeSenzeBandStandard()

  public void initializeSenzeBandStandard() {
    //Key in DeveloperCode here!
    context_wr = new WeakReference<Context>(this);
    String developerCode = "";
    NativeNSBInterface.getInstance().initializeNSB(context_wr, nsbFunctionsCB, scanCB, connectionCB, sbDelegate, authenticationCB, developerCode);
  }

1. In order to scan for the SenzeBand, use function startStopScanning to start the scan.
2. deviceFoundCB from scanCallBack logs any SenzeBands in the vicinity, and adds a button to the SDK indicating the device that has been found

1. There are three callbacks that will trigger once you attempt to connect to a SenzeBand device. This is called implement the connectionCallBackInterface.
   • connectionSucceed - this is triggered the moment the plugin confirms that SenzeBand connection is successful.
   • connectionBroken - this is triggered when SenzeBand connection is broken or disconnected either via switching OFF the SenzeBand device, switching OFF Bluetooth, or when disconnectBT() is called.
   • connectionFail - this is triggered when the app fails to connect successfully to the SenzeBand.
2. To connect to a SenzeBand device, call connectBT(String) passing the address String of a given scanned device
3. Once the SenzeBand has been successfully connected, connectionSucceed will be called.

1. For the Standard SDK, you'll need an internet connection to Authenticate your developer code with Neeuro's servers. Call authenticateUser() to attempt authentication.
2. Once authentication is done, two functions are called via callbacks:
   • getAuthenticationStatus() - sends back authentication status from SenzeBand plugin. The moment authentication result returns success/verified, a countdown will start for the validity period of authentication.
   • getAuthenticationResult() - sends back authentication result(success or fail) from
3. getAuthenticationValidityPeriod sends back the validity period of the authentication
4. Note that if authentication fails, you will not be able to receive any data from the SenzeBand.

1. Impedance Check helps to verify if the signal quality from the 4 contact points/electrodes are good. Example, if there is makeup or some other impurities on the skin, the impedance values will be much higher due to the contribution of more resistance between the electrodes and skin surface, the EEG signals will not be good/accurate. Good impedance range is below 800k Ohms.
2. We recommend to do an Impedance Check/Signal Quality Check after SenzeBand connection before using the SenzeBand.
3. To do impedance check, call acLeadoff in your program. Switching to AC mode will stop SenzeBand from receiving EEG and start on checking signal quality. Advise the user to adjust SenzeBand and wipe off residue on skin to get better contact until all channel signals are green. Once done, switch back to DC mode by calling dcLeadoff. By default, SenzeBand is in DC mode after a successful connection.
4. Switching AC mode and DC mode can take a moment before plugin can verify and actually switch modes.
5. If user thinks that the Acceleration and Orientation data is not accurate, we can perform calibration to improve the accuracy. To initiate calibration, call startCal. To stop calibration, call stopCal.

1. After you've connected the SenzeBand, you need to first enable it. You can do this by calling start() for EEG data or startPPG() for PPG data. This allows data from the SenzeBand to be sent over to the app.
2. There are several different types of data you can grab from the SenzeBand. For each type of data, there is a callback that comes with it with a respective interface, such as NSBFunctionsCallBackInterface, or EEGStandardDelegateInterface.
3. You can call stop() for EEG data or stopPPG() for PPG data to stop the SenzeBand from sending data.

1. Call disconnectBT to disconnect the SenzeBand.
2. The callback connectionBroken will be called.

1. To start writing to files, open the sample project in Android Studio.

2. Observe that the CSV or EDF writer code is accessible in MainActivity.java as this will be used to write to files.

3. If not present, implement the above as follows:

4. Now, open the SDK and press the Start button to start recording.
   

5. The Stop button stops recording, saving data automatically to a CSV or EDF file at a default location, stated when saving is complete.

6. View the file by accessing the location necessary in the Files app.

The NativeNSBInterface has functions built into it that you can call in your application.

---

  void authenticateUser ()

Name: authenticateUser

Parameters: None

Output: None

Definition: Authenticate SDK with developer code provided in initializeNSB method call

---

  void cancelConnection (String address)

Name: cancelConnection

Parameters: String representing hardware address of BluetoothDevice.

Output: None

Definition: Cancel connect Bluetooth Device

---

  void connectBT (String address)

Name: connectBT

Parameters: String representing hardware address of BluetoothDevice.

Output: None

Definition: Connect Bluetooth Device

---

  void connection_ReturnInUIThread (boolean returnInUIThreadIn)

Name: connection_ReturnInUIThread

Parameters: Boolean representing flag to set for returning connection data in the UI Thread.

Output: None

Definition: If this is set to false, once connection data has been received, you will immediately receive it via {NativeNSBInterface$connectionCallBackInterface}. If this is set to true, once connection data has been received, you will receive it via {NativeNSBInterface$connectionCallBackInterface} on the UI thread.

---

  void disconnectBT (String address)

Name: disconnectBT

Parameters: String representing hardware address of BluetoothDevice.

Output: None

Definition: Disconnect Bluetooth Device

---

  long getAuthenticationValidityPeriod ()

Name: getAuthenticationValidityPeriod

Parameters: None

Output: None

Definition: Returns authentication validity period in milliseconds

---

  void grabInputCommand (String command)

Name: grabInputCommand

Parameters: String representing a command

Output: None

Definition: Processes a command

Only the following are command Strings:

• COMMAND_AC_LEADOFF
• COMMAND_DC_LEADOFF
• COMMAND_LIGHT_RED
• COMMAND_LIGHT_GREEN
• COMMAND_LIGHT_BLUE
• COMMAND_LIGHT_CYAN
• COMMAND_LIGHT_MAGENTA
• COMMAND_LIGHT_YELLOW
• COMMAND_STOP_RGB
• COMMAND_CMD_FA - Evoke event
• COMMAND_FW_VER - Get firmware version
• COMMAND_CAL_START - Calibration start
• COMMAND_CAL_STOP - Calibration stop
• COMMAND_START start - Sending eeg data
• COMMAND_STOP stop - Sending eeg data
• COMMAND_PPG_START - Start sending ppg data
• COMMAND_PPG_STOP - Stop sending ppg data

---

To reduce the need of typing out NativeNSBInterface.getInstance().grabInputCommand(command), the following functions have also been defined respectively:

  public void dcLeadoff(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_DC_LEADOFF");
  }
  public void acLeadoff(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_AC_LEADOFF");
  }

  public void startCal(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_CAL_START");
  }
  public void stopCal(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_CAL_STOP");
  }

  public void startPPG(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_PPG_START");
  }
  public void stopPPG(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_PPG_STOP");
  }
  public void start(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_START");
      startRecording();
  }
  public void stop(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_STOP");
      stopRecording();
  }

  public void fa(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_CMD_FA");
  }
  public void fwVer(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_FW_VER");
  }

  public void lightRed(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_LIGHT_RED");
  }
  public void lightGreen(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_LIGHT_GREEN");
  }
  public void lightBlue(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_LIGHT_BLUE");
  }
  public void lightCyan(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_LIGHT_CYAN");
  }
  public void lightMagenta(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_LIGHT_MAGENTA");
  }
  public void lightYellow(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_LIGHT_YELLOW");
  }
  public void stopRGB(View view)
  {
      NativeNSBInterface.getInstance().grabInputCommand("COMMAND_STOP_RGB");
  }

---

  void initializeNSB (WeakReference <Context> app, NSBFunctionsCallBackInterface nsbInterfaceIn, scanCallBackInterface scanInterfaceIn, connectionCallBackInterface connectionInterfaceIn, EEGDelegateInterface senzeBandInterfaceIn, deviceAuthenticationInterface authenInterfaceIn, String developerCode)

Name: initializeNSB

Parameters:

• app: Android Activity or Service
• nsbInterfaceIn: Interface that handles initialization and any change of state with bluetooth
• scanInterfaceIn: Interface that handles scanning
• connectionInterfaceIn: Interface to handle connection
• senzeBandInterfaceIn: Interface to handle data received from the SenzeBand
• authenInterfaceIn: Interface to handle authentication
• developerCode: Developer Code

Output: None

Definition: Initialises the SDK

---

  void startStopEEG ()

Name: startStopEEG

Parameters: Boolean representing whether to start receiving data

Output: None

Definition: Start or stop receiving EEG data

---

  void startStopScanning ()

Name: startStopScanning

Parameters: Boolean representing whether to start receiving data

Output: None

Definition: Start or stop receiving Bluetooth scanning

---

The following interfaces need to be implemented and passed in to recieve event data from the SDK:

• EEGStandardDelegateInterface
• connectionCallBackInterface
• scanCallBackInterface
• NSBFunctionsCallBackInterface
• deviceAuthenticationInterface

---

---

  @Override
  public void EEG_GetFWVER(String s) {
      Log.i("EEG", "EEG_GetFWVER - " + s);
  }

Name: EEG_GetFWVER

Parameters: String representing the firmware version

Output: None

Definition: Logs the EEG's firmware version

---

  @Override
  public void EEG_GetEvoke(int i) {
      Log.i(TAG, "EEG_GetEvoke: " + i);
  }

Name: EEG_GetEvoke

Parameters: Int representing time in milliseconds of last event from first eeg data transmission.

Output: None

Definition: Logs the event evoke

---

  @Override
  public void EEG_GetRawDataFloat(readFloatArray readFloatArray) {
  }

Name: EEG_GetRawDataFloat

Parameters: readFloatArray representing raw EEG data

Output: None

Definition: Retrieves raw EEG data from a readFloatArray

---

  @Override
  public void EEG_GetRawDataFloat(float[] floats) {
  }

Name: EEG_GetRawDataFloat

Parameters: Array of Float values representing raw EEG data

Output: None

Definition: Retrieves raw EEG data from an Array of Float values

---

  @Override
  public void EEG_GetFilteredData(readFloatArray readFloatArray) {
  }

Name: EEG_GetFilteredData

Parameters: readFloatArray representing filtered EEG data

Output: None

Definition: Retrieves filtered EEG data from a readFloatArray

---

  @Override
  public void EEG_GetFilteredData(float[] floats) {
  }

Name: EEG_GetFilteredData

Parameters: Array of Float values representing filtered EEG data

Output: None

Definition: Retrieves filtered EEG data from an Array of Float values

---

  @Override
  public void PPG_GetRawData(readIntArray readIntArray) {
      PPG_GetRawData(readIntArray.data);
  }

Name: PPG_GetRawData

Parameters: readIntArray representing raw PPG data

Output: None

Definition: Retrieves raw PPG data from a readIntArray

---

  @Override
  public void PPG_GetRawData(int[] ints) {
      String ppg = "";
      if(ints.length > 0) ppg += "IR:" + ints[0];
      if(ints.length > 1) ppg += " RED:" + ints[1];
      Log.i("PPG", "Received PPGData - " + ppg);
  }

Name: PPG_GetRawData

Parameters: Array of Int values representing raw PPG data

Output: None

Definition: Retrieves raw PPG data from an Array of Int values

---

  private String printArray(int[] array){
      StringBuffer result = new StringBuffer();
      for (int i = 0; i < array.length; i++) {
          if(i > 0)
              result.append(" ");
          result.append(array[i]);
      }
      return result.toString();
  }

Name: printArray

Parameters: Array of Int values

Output: String representing the input array

Definition: Prints an Array of Int values as a String

---

  @Override
  public void EEG_GetImpedance(readFloatArray readFloatArray) {
  }

Name: EEG_GetImpedance

Parameters: readFloatArray representing impedance values of each channel in kOhms

Output: None

Definition: Retrieves impedance of SenzeBand from a readFloatArray

---

  @Override
  public void EEG_GetImpedance(float[] floats) {
  }

Name: EEG_GetImpedance

Parameters: Array of Float values representing impedance values of each channel in kOhms

Output: None

Definition: Retrieves impedance of SenzeBand from an Array of Float values

---

  @Override
  public void EEG_GetDirection(String s) {
      Log.i("EEG", "EEG_GetDirection - " + s);
  }

Name: EEG_GetDirection

Parameters: String representing direction of SenzeBand

Output: None

Definition: Logs current direction of SenzeBand

---

  @Override
  public void GetSPO2AndHeartRate(readIntArray readIntArray) {
      GetSPO2AndHeartRate(readIntArray.data);
  }

Name: GetSPO2AndHeartRate

Parameters: readIntArray representing SPO2 and heart rate

Output: None

Definition: Retrieves SPO2 and heart rate of SenzeBand from a readIntArray

---

  @Override
  public void GetSPO2AndHeartRate(int[] ints) {

      String result = "";
      if(ints.length > 0) result += "SPO2:" + ints[0];
      if(ints.length > 1) result += " HeartRate:" + ints[1];
      if(ints.length > 2) result += " HeartRateDetect:" + ints[2];
      Log.i("EEG", "GetSPO2AndHeartRate - " + result);

  }

Name: GetSPO2AndHeartRate

Parameters: Array of Int values representing SPO2 and heart rate

Output: None

Definition: Retrieves SPO2 and heart rate of SenzeBand from an Array of Int values

---

  @Override
  public void EEG_GetCalibrationParameters(readFloatArray readFloatArray) {
      EEG_GetCalibrationParameters(readFloatArray.data);
  }

Name: EEG_GetCalibrationParameters

Parameters: readFloatArray representing calibration parameters

Output: None

Definition: Retrieves calibration parameters of SenzeBand from a readFloatArray

---

  @Override
  public void EEG_GetCalibrationParameters(float[] floats) {
      Log.i("EEG", "EEG_GetCalibrationParameters - xGain:" + floats[0] + " yGain:" + floats[1] + " zGain" + floats[2]);
  }

Name: EEG_GetCalibrationParameters

Parameters: Array of Float values representing calibration parameters

Output: None

Definition: Logs calibration parameters of SenzeBand from an Array of Float values

---

  @Override
  public void GetSenzeBandVersion(String s) {
      Log.i("EEG", "GetSenzeBandVersion: " + s);
  }

Name: GetSenzeBandVersion

Parameters: String representing SenzeBand version

Output: None

Definition: Logs version of SenzeBand

---

  public void EEG_GetAttention(float result) {
      Attention = (TextView) findViewById(R.id.Attn);
      Attention.setText("Attention: " + clamp(result, 0.0f, 1.0f));
  }

Name: EEG_GetAttention

Parameters: Float representing attention level detected by SenzeBand

Output: None

Definition: Sets Attention to the attention level detected by SenzeBand

---

  public void EEG_GetRelaxation(float result) {
      Relaxation = (TextView) findViewById(R.id.Rlxt);
      Relaxation.setText("Relaxation: " + clamp(result, 0.0f, 1.0f));
  }

Name: EEG_GetRelaxation

Parameters: Float representing relaxation level detected by SenzeBand

Output: None

Definition: Sets Relaxation to the relaxation level detected by SenzeBand

---

  public void EEG_GetMentalWorkload(float result) {
      MentalWorkload = (TextView) findViewById(R.id.Mworkload);
      MentalWorkload.setText("Mental Workload: " + clamp(result, 0.0f, 1.0f));
  }

Name: EEG_GetMentalWorkload

Parameters: Float representing mental workload level detected by SenzeBand

Output: None

Definition: Sets MentalWorkload to the mental workload level detected by SenzeBand

---

  public void EEG_GetRawData(int[] data) {
      if (data.length == EEGSIZEPERSAMPLE)
          System.arraycopy(data, 0, rawEEG, 0, EEGSIZEPERSAMPLE);
  }

Name: EEG_GetRawData

Parameters: Array of Int values representing raw EEG data

Output: None

Definition: Callback where raw EEG data is retrieved from an Array of Int values

---

  public void EEG_GetRawData(readIntArray result) {
      String eeg = "";
      for (int i : result.data) {
          eeg += i + " ";
      }
      Log.i("EEG", "Received EEGData: " + eeg);
  }

Name: EEG_GetRawData

Parameters: readIntArray representing raw EEG data

Output: None

Definition: Callback where raw EEG data is retrieved from readIntArray

---

  public void EEG_GetEnvironmentData(String data) {
  }

Name: EEG_GetEnvironmentData

Parameters: String representing EEG environment data

Output: None

Definition: Retrieves EEG environment data from readIntArray

---

  private void printABDT(float[][] floats){
      for (int i = 0; i < 4; i++) {
          String row = "";
          for (int j = 0; j < 9; j++) {
              row += floats[i][j] + " ";
          }
          Log.i("EEG", "Channel " + (i+1) + ": " + row);
      }

  }

Name: printABDT

Parameters: 2D Array of Float values representing Alpha, LowAlpha, HighAlpha, Beta, LowBeta, HighBeta Delta, Theta, Gamma values

Output: None

Definition: Logs ABDT values

---

  @Override
  public void EEG_GetABDTRaw(float[][] floats) {

      updateABDTView(floats, 10000000);
      Log.i("EEG", "EEG_GetABDTRaw");
      printABDT(floats);

  }

Name: EEG_GetABDTRaw

Parameters: 2D Array of Float values representing raw Alpha, LowAlpha, HighAlpha, Beta, LowBeta, HighBeta Delta, Theta, Gamma values

Output: None

Definition: Logs raw ABDT values

---

  private String formatABDTValue(float n){
      if(n < -0.001){
          return String.format("%7.3E", n);
      } else {
          return String.format("%.3f", n);
      }
  }

Name: formatABDTValue

Parameters: Float representing an Alpha, LowAlpha, HighAlpha, Beta, LowBeta, HighBeta Delta, Theta,or Gamma value

Output: String representing formatted ABDT value

Definition: Formats ABDT value

---

  private void updateABDTView(float[][] result, float max){
      Delta = (TextView) findViewById(R.id.eeg_delta);
      Delta.setText("Delta: " + formatABDTValue(clamp(result[2][0], 0.0f, max)));
      Theta = (TextView) findViewById(R.id.eeg_theta);
      Theta.setText("Theta: " + formatABDTValue(clamp(result[2][1], 0.0f, max)));
      Alpha = (TextView) findViewById(R.id.eeg_alpha);
      Alpha.setText("Alpha: " + formatABDTValue(clamp(result[2][2], 0.0f, max)));
      Beta = (TextView) findViewById(R.id.eeg_beta);
      Beta.setText("Beta: " + formatABDTValue(clamp(result[2][3], 0.0f, max)));
      Gamma = (TextView) findViewById(R.id.eeg_gamma);
      Gamma.setText("Gamma: " + formatABDTValue(clamp(result[2][4], 0.0f, max)));

      LowAlpha = (TextView) findViewById(R.id.eeg_low_alpha);
      LowAlpha.setText("LowAlpha: " + formatABDTValue(clamp(result[2][5], 0.0f, max)));
      HighAlpha = (TextView) findViewById(R.id.eeg_high_alpha);
      HighAlpha.setText("HighAlpha: " + formatABDTValue(clamp(result[2][6], 0.0f, max)));
      LowBeta = (TextView) findViewById(R.id.eeg_low_beta);
      LowBeta.setText("LowBeta: " + formatABDTValue(clamp(result[2][7], 0.0f, max)));
      HighBeta = (TextView) findViewById(R.id.eeg_high_beta);
      HighBeta.setText("HighBeta: " + formatABDTValue(clamp(result[2][8], 0.0f, max)));
  }

Name: updateABDTView

Parameters: 2D Array of Float values representing ABDT values, Float representing maximum ABDT value

Output: None

Definition: Sets the values of Alpha, LowAlpha, HighAlpha, Beta, LowBeta, HighBeta Delta, Theta, Gamma

---

  @Override
  public void EEG_GetABDTRaw(readFloatArray readFloatArray) {
  }

Name: EEG_GetABDTRaw

Parameters: readFloatArray representing raw ABDT values

Output: None

Definition: Retrieves raw ABDT values

---

  @Override
  public void EEG_GetABDTNorm(float[][] result) {
      updateABDTView(result, 1);
  }

Name: EEG_GetABDTNorm

Parameters: 2D Array of Float values representing normalised ABDT values

Output: None

Definition: Updates ABDT values based on input 2D Array of Float values

---

  @Override
  public void EEG_GetABDTNorm(readFloatArray readFloatArray) {
  }

Name: EEG_GetABDTNorm

Parameters: readFloatArray representing normalised ABDT values

Output: None

Definition: Retrieves normalised ABDT values

---

  @Override
  public void EEG_GetABDT(float[][] result) {
  }

Name: EEG_GetABDT

Parameters: 2D Array of Float values representing ABDT values

Output: None

Definition: Retrieves ABDT values from 2D Array of Float values

---

  public void EEG_GetABDT(readFloatArray result) {
  }

Name: EEG_GetABDT

Parameters: readFloatArray representing ABDT values

Output: None

Definition: Retrieves ABDT values from readFloatArray

---

  public void EEG_GetSignalReadyStatus(boolean result) {
  }

Name: EEG_GetSignalReadyStatus

Parameters: Boolean representing whether SenzeBand is ready to accept input signals

Output: None

Definition: Determines whether SenzeBand is ready to accept input signals

---

  public void EEG_GetBattery(String result) {
      String[] tmpdataList = result.split(">");
      if(tmpdataList.length > 1){
          if(tmpdataList[1].equals("00000001"))
          {
              batteryText.setText("Battery: " + tmpdataList[0]);
          }
          else if(tmpdataList[1].equals("00010000"))
          {
              batteryText.setText("Battery: " + "Charging");
          }
          else if (tmpdataList[1].equals("00010001"))
          {
              batteryText.setText("Battery: " + "Full");
          }
      }else{
          batteryText.setText("Battery left: " + result);
      }
  }

Name: EEG_GetBattery

Parameters: String representing battery level

Output: None

Definition: Sets batteryText to current battery level

---

  @Override 
  public void EEG_ChannelStatus(boolean[] b) {
      EEG_1 = (TextView) findViewById(R.id.EEG1);
      EEG_1.setText(String.format("Channel 1: %b", b[0]));
      EEG_2 = (TextView) findViewById(R.id.EEG2);
      EEG_2.setText(String.format("Channel 2: %b", b[1]));
      EEG_3 = (TextView) findViewById(R.id.EEG3);
      EEG_3.setText(String.format("Channel 3: %b", b[2]));
      EEG_4 = (TextView) findViewById(R.id.EEG4);
      EEG_4.setText(String.format("Channel 4: %b", b[3]));
  }

Name: EEG_ChannelStatus

Parameters: Array of Boolean values representing status of each EEG channel

Output: None

Definition: Sets each EEG channel to their current status from Array of Boolean values

---

  @Override
  public void EEG_ChannelStatus(readBoolArray res) {
      EEG_1 = (TextView) findViewById(R.id.EEG1);
      EEG_1.setText(String.format("Channel 1: %b", res.data[0]));
      EEG_2 = (TextView) findViewById(R.id.EEG2);
      EEG_2.setText(String.format("Channel 2: %b", res.data[1]));
      EEG_3 = (TextView) findViewById(R.id.EEG3);
      EEG_3.setText(String.format("Channel 3: %b", res.data[2]));
      EEG_4 = (TextView) findViewById(R.id.EEG4);
      EEG_4.setText(String.format("Channel 4: %b", res.data[3]));
  }

Name: EEG_ChannelStatus

Parameters: readBoolArray representing status of each EEG channel

Output: None

Definition: Sets each EEG channel to their current status from readBoolArray

---

  public void EEG_GetMCUID(final String result) {
      TimerTask tasknew = new TimerTask() {
          @Override
          public void run() {
              if (mcuIDText != null) {

                  runOnUiThread(new Runnable() {
                      @Override
                      public void run() {
                          mcuIDText.setText("MCUID: " + result);
                      }
                  });
              }
          }
      };
      Timer timer = new Timer();

      // scheduling the task at interval
      timer.schedule(tasknew, 3000);
  }

Name: EEG_GetMCUID

Parameters: String representing MCUID of SenzeBand

Output: None

Definition: Sets MCUID of SenzeBand and sets a timer to schedule a new task

---

  public void EEG_GetAccXYZ(float[] result) {
      Log.i(TAG, "NativeNSBInterface EEG_GetAccXYZ result.length="+result.length+" :" + result[0] + " " + result[1] + " " + result[2] + " "  + result[3] + " " + result[4] + " " + result[5]);
      Xacc = (TextView) findViewById(R.id.Xvalue);
      Xacc.setText("Acc X: " + result[0]);
      Yacc = (TextView) findViewById(R.id.Yvalue);
      Yacc.setText("Acc Y: " + result[1]);
      Zacc = (TextView) findViewById(R.id.Zvalue);
      Zacc.setText("Acc Z: " + result[2]);
  }

Name: EEG_GetAccXYZ

Parameters: Array of Float values representing acceleration of SenzeBand

Output: None

Definition: Sets Xacc, Yacc and Zacc to the current acceleration of the SenzeBand from an Array of Float values

---

  public void EEG_GetAccXYZ(readFloatArray result) {
      Log.i(TAG, "NativeNSBInterface EEG_GetAccXYZ readFloatArray");
  }

Name: EEG_GetAccXYZ

Parameters: readFloatArray representing acceleration of SenzeBand

Output: None

Definition: Logs acceleration of SenzeBand

---

  public void EEG_GetConnectionStatus(boolean result) {
      Log.i(TAG, "Get connection status " + result);
  }

Name: EEG_GetConnectionStatus

Parameters: Boolean representing EEG connection status

Output: None

Definition: Logs EEG connection status of SenzeBand

---

  public void pumpMcuIDTextView(TextView tv) {
      mcuIDText = tv;
  }

Name: pumpMcuIDTextView

Parameters: TextView representing MCUID

Output: None

Definition: Sets mcuIDText to MCUID of SenzeBand

---

  public void pumpBatteryTextView(TextView tv) {
      batteryText = tv;
  }

Name: pumpMcuIDTextView

Parameters: TextView representing battery level

Output: None

Definition: Sets batteryText to battery level of SenzeBand

---

---

   public void connectionSucceed(String address) {
      Log.e(TAG, "Connection succeed!");

      createLayout(address);
      offSB.setTag(address);

      TimerTask tasknew = new TimerTask() {
          @Override
          public void run() {
              NativeNSBInterface.getInstance().startStopEEG(true);
          }
      };
      Timer timer = new Timer();

      // scheduling the task at interval
      timer.schedule(tasknew,3000);
  }

Name: connectionSucceed

Parameters: String representing the address of the Neeuro device

Output: None

Definition: Creates a timer and runs it while EEG signals are being recorded

---

   public void connectionFail(String s, String s1) {
      Log.e(TAG, "Connection fail! " + s1);
  }

Name: connectionFail

Parameters: String, String representing why the connection failed

Output: None

Definition: Logs the connection failure and its reason

---

   public void connectionBroken(String s) {
      Log.e(TAG, "connection broken " + s);

      clearLayout();
  }

Name: connectionBroken

Parameters: String representing why the connection broke

Output: None

Definition: Logs the connection breakage and its reason

---

   public void errorLog(String s) {
      Log.e(TAG, "connectionCB error Log " + s);
  }

Name: errorLog

Parameters: String representing the error produced

Output: None

Definition: Logs the errors that have occurred

---

---

   public void deviceFoundCB(String address, String name) {
      Log.i(TAG, "One Neeuro device found! address=" + address + " name=" + name);
      addButton(address + " " + name);
  }

Name: deviceFoundCB

Parameters: String representing the address of the Neeuro device, and String representing the name of the device

Output: None

Definition: Logs the address and name of a scanned Neeuro device

---

  public void scanReset() {
      Log.i(TAG, "Scan reset ");
      clearAllButtons();
  }

Name: scanReset

Parameters: None

Output: None

Definition: Resets the scanner by clearing all previously scanned devices from its list

---

  public void errorLog(String s) {
      Log.e(TAG, "Scan errorLog " + s);
  }

Name: errorLog

Parameters: String representing the error produced

Output: None

Definition: Logs the errors that have occurred

---

---

  public void initializedFinished() {
      Log.e(TAG, "Initialized Finished!");

      NativeNSBInterface.getInstance().connection_ReturnInUIThread(true);
      NativeNSBInterface.getInstance().EEG_ReturnInUIThread(true);
      NativeNSBInterface.getInstance().EEG_ReturnRawDataInUIThread(false);
  }

Name: initializedFinished

Parameters: None

Output: None

Definition: Logs the fact that initialisation is complete

---

  public void bluetoothStatusCallBack(boolean btStatus) {
      Log.i(TAG, "Bluetooth status is " + btStatus);
  }

Name: bluetoothStatusCallBack

Parameters: Boolean representing the Bluetooth status

Output: None

Definition: Logs the Bluetooth status of the currently connected SenzeBand

---

  public void errorLog(String s) {
      Log.e(TAG, "NSBCB errorLog " + s);
  }

Name: errorLog

Parameters: String representing the error produced

Output: None

Definition: Logs the errors that have occurred

---

---

  @Override
  public void getAuthenticationResult(boolean result) {
      valid = result;
      //if(authenticationText != null)
      //    authenticationText.setText("Auth status: " + status + " " + valid);

      TextView authText = findViewById(R.id.authValid);
      authText.setText("Auth valid: " + (result ? "True" : "False"));
  }

Name: getAuthenticationResult

Parameters: Boolean representing the result of authentication

Output: None

Definition: Sets the value of authText to display whether authentication is successful

---

  @Override
  public void getAuthenticationStatus(String var1) {
      status = var1;
      //if(authenticationText != null)
      //    authenticationText.setText("Auth status: " + status);

      final long duration = NativeNSBInterface.getInstance().getAuthenticationValidityPeriod();

      authStatus.setText("Auth status: " + var1);
      authTime.setText("Auth Time: " + duration / 1000);

      if (authCheck == null)
          authCheck = new CountDownTimer(duration, 1000) {
              @Override
              public void onTick(long l) {
                  runOnUiThread(new Runnable() {
                      @Override
                      public void run() {
                          authTime.setText("Auth Time: " + NativeNSBInterface.getInstance().getAuthenticationValidityPeriod() / 1000);

                      }
                  });
              }

              @Override
              public void onFinish() {
                  NativeNSBInterface.getInstance().authenticateUser();
                  authCheck = null;
              }
          };

      authCheck.start();
  }

Name: getAuthenticationStatus

Parameters: String representing the authentication status

Output: None

Definition: Sets the value of authStatus to display the current authentication status, and the value of authTime to display the remaining time for the current authentication period

---

  public void pumpAuthenticationTextView(TextView tv) {
      authenticationText = tv;
  }

Name: pumpAuthenticationTextView

Parameters: TextView representing the authentication text

Output: None

Definition: Sets the value of authenticationText to be the current authentication text

---

Using the NeeuroOS SDK App

---

1. Unzip the SDK folder and make sure all these files are inside.

2. Testing.xcodeproj is a sample Xcode project. It contains a SenzeBand control panel scene to show what the Neeuro SenzeBand can do. It contains code with comments on how to use the SDK.

3. Open your Xcode project. This can be an existing one, or the sample one we provide.

4. Under General > Frameworks, Libraries and Embedded Content, add in the framework IOSNativeFramework.framework

5. Under Info.plist, ensure that the following key value pair is added: "NSBluetoothAlwaysUsageDescription" or "Privacy - Bluetooth Always Usage Description" - "For SenzeBand Connections"

6. Under Build Settings, search for "Bitcode" > User-Defined> Enable Bitcode = "No"

7. Under Build Settings > Architectures, Set "Standard architectures" or "arm64 armv7" by default.

8. Under Build Settings -> Valid Architectures, make sure these "arm64 armv7 armv7s arm64e" architectures are there.

9. In the parent View Controller's implementation, (ViewController.m), enter your developer code.

10. Build and Run on Xcode, and the connected iOS devices.

---

This section will walk you through how to develop your own app using the Neeuro SenzeBand (NSB) iOS Standard SDK. It makes use of the commands in the IOSSDK command glossary.

1. Having set up and built the NeeuroOS SDK, ViewController.m will be the main script for working with the SDK. It can be found in the 'Testing' folder.
2. In the ViewController header file, ViewController.h, add the following line of code:

  #import <IOSNativeFramework/IOSSDK.h>

3. To implement IOSDelegate protocol, add the following line of code to ViewController.h:

  @interface ViewController : UIViewController <IOSDelegate> ;

4. In the ViewController implementation file, ViewController.m, implement the delegate methods appropriately by editing their code.

  @implementation ViewController
  //Example
  - (void) BT_BTStatus:(bool) BTStatus
  {
  //Add in function code here
  } 

Examples of possible definitions for the methods can be viewed under the Protocol Glossary

Development using the Neeuro SenzeBand (NSB) iOS Standard SDK can be done in the following stages:

1. Initialisation
2. Scanning
3. Connecting
4. Authenticating
5. Impedance Check and Calibration
6. Using the SenzeBand
7. Disconnecting
8. Writing to Files

1. ViewController.m is our main control script for accessing and implementing the delegate methods.
2. Use nitializeBT is with your developr code to start initialisation.
3. Once initialisation has been completed, you are now free to use the functions inside ViewController.m.

1. To scan for the SenzeBand, make use of startStopScanning to start the scan.
2. Then, use initializeBT with your developer code to use Bluetooth to find the respective SenzeBand.
3. The list of all scanned SenzeBands in the vicinity can be found in the list DisplayBTScanList.m.

1. To connect to a SenzeBand, ConnectDevice connects the Neeuro device with the bluetoothID to the app.
2. Once the SenzeBand has been successfully connected, you are able to use your SenzeBand with the app.
3. Similarly, to disconnect from the SenzeBand, the use the DisconnectDevice method.

1. A SenzeBand needs to be authenticated to be used with the SDK.
2. authenticateUser authenticates the user via the developer code that is passed in from initialize.
3. To display the valid time left for the authentication, you can make use of the function getAuthenticationValidityInMilliseconds.
4. Note that if authentication fails, you will not be able to receive any data from the SenzeBand.

1. Impedance Check helps to verify if the signal quality from the 4 contact points/electrodes are good. Example, if there is makeup or some other impurities on the skin, the impedance values will be much higher due to the contribution of more resistance between the electrodes and skin surface, the EEG signals will not be good/accurate. Good impedance range is below 800k Ohms.
2. We recommend to do an Impedance Check/Signal Quality Check after SenzeBand connection before using the SenzeBand.
3. Impedance check can be done through running the function SB_EEG_GetImpedance.
4. If there is high impedance between the SenzeBand and the subject, readings may not be accurate, so a wet towel can be used to increase lubrication between the two surfaces.

1. After you've connected the SenzeBand, you need to first enable it. You can do this by calling EEG_Start, allowing data from the SenzeBand to be sent over to your app.
2. There are several different types of data you can grab from the SenzeBand. To stop collecting the data, EEG_Stop can be run, which stops the app from grabbing data from the SenzeBand.
3. To start data analysis with the data collected, make use of the function StartStopAnalyze in ViewController.m.

1. Call DisconnectDevice with the BluetoothID of the currently connected SenzeBand to disconnect it.
2. Actions can be done based on connection of the SenzeBand through the application of if statements.

1. To start writing to files, open the SDK and press the Start button to start recording.

2. The Stop button stops recording, saving data automatically to a CSV or EDF file at a default location, stated when saving is complete.

3. View the file by accessing the location necessary in the Files app.

---

---

  - (void) initializeBT:(NSString *) developerCode;

Name: initializeBT

Parameters: String representing your developerCode

Output: None

Definition: Initialises the SDK

---

  - (void) startStopScanning: (bool) toStart;

Name: GetEnvironmentData

Parameters: Boolean representing a flag to start or stop the scanning.

Output: None

Definition: Sets the scanning mode

---

  - (void) ClearDeviceList;

Name: GetEnvironmentData

Parameters: None

Output: None

Definition: Clears the list of discovered Neeuro devices. Clears the list of discovered Neeuro devices.

---

  - (void) DisconnectDevice:(NSString*) deviceAddress;

Name: DisconnectDevice

Parameters: String representing the BluetoothID of the device to disconnect

Output: None

Definition: Disconnects the Neeuro device with the same bluetoothID as the deviceName

---

  - (void) ConnectDevice:(NSString*) deviceAddress;

Name: ConnectDevice

Parameters: String representing the BluetoothID of the device to connect to

Output: None

Definition: Connects the Neeuro device with the bluetoothID to the app. Only one device can connect at any point of time.

---

---

  - (void) authenticateUser;

Name: authenticateUser

Parameters: None

Output: None

Definition: Authenticates the user via the developer code that is passed in from initialize.

---

  - (long) getAuthenticationValidityInMilliseconds;

Name: getAuthenticationValidityInMilliseconds

Parameters: None

Output: None

Definition: Returns the authentication validity period remaining

---

---

  /*!
  Send command to SenzeBand
  
  @param command A command String
      COMMAND_AC_LEADOFF
      COMMAND_DC_LEADOFF
      COMMAND_LIGHT_RED
      COMMAND_LIGHT_GREEN
      COMMAND_LIGHT_BLUE
      COMMAND_LIGHT_CYAN
      COMMAND_LIGHT_MAGENTA
      COMMAND_LIGHT_YELLOW
      COMMAND_STOP_RGB
      COMMAND_CMD_FA - Evoke event
      COMMAND_FW_VER - Get firmware version
      COMMAND_CAL_START - Calibration start
      COMMAND_CAL_STOP - Calibration stop
      COMMAND_START start - Sending eeg data
      COMMAND_STOP stop - Sending eeg data
      COMMAND_PPG_START - Start sending ppg data
      COMMAND_PPG_STOP - Stop sending ppg data
  */
  - (void) grabInputCommand:(NSString *) command;

Name: grabInputCommand

Parameters: String representing a command, one of the above

Output: None

Definition: Sends a command to the SenzeBand

---

---

  - (void) EEG_Start;

Name: EEG_Start

Parameters: None

Output: None

Definition: Starts the EEG to grab the data from the SenzeBand device

---

  - (void) EEG_Stop;

Name: EEG_Stop

Parameters: None

Output: None

Definition: Stops the EEG to grab the data from the SenzeBand device

---

  - (void) StartStopAnalyze;

Name: StartStopAnalyze

Parameters: None

Output: None

Definition: Toggles processing of EEG data

---

  - (void) SetEnvironmentThreshold: (NSString*) envThreshold;

Name: SetEnvironmentThreshold

Parameters: String consisting of normalised gamma and 50-60Hz threshold values separated by spaces

Output: None

Definition: Sets gamma and 5060Hz threshold for useful data

---

---

  (NSString *) getVersion;

Name: getVersion;

Parameters: None

Output: String representing SDK version

Definition: Returns current SDK version

---

  - (void) DisplayBTStatus:(bool) BTStatus;

Name: DisplayBTStatus;

Parameters: Boolean representing Bluetooth status

Output: None

Definition: Displays Bluetooth status

---

  - (void) DisplayBTScanList:(NSMutableArray*) NameList;

Name: DisplayBTScanList;

Parameters: Mutable array representing SenzeBands found from scanning

Output: None

Definition: Displays the list of available SenzeBand devices found from scanning

---

  - (void) DisplayBTConnectedList:(NSString *) NameList;

Name: DisplayBTConnectedList;

Parameters: Mutable array representing connected SenzeBands

Output: None

Definition: Displays the list of connected SenzeBands

---

  - (void) DisplayBTConnectionStatus:(bool) NameList;

Name: DisplayBTConnectionStatus;

Parameters: Boolean representing strength of connection of SenzeBand

Output: None

Definition: Displays whether the user's SenzeBand is worn properly

---

  - (void) DisplaySB_EEG_GetAttention:(float) Value;

Name: DisplaySB_EEG_GetAttention;

Parameters: Float representing level of attention

Output: None

Definition: Displays whether the user's attention level

---

  - (void) DisplaySB_EEG_GetRelaxation:(float) Value;

Name: DisplaySB_EEG_GetRelaxation;

Parameters: Float representing level of relaxation

Output: None

Definition: Displays whether the user's relaxation level

---

  - (void) DisplaySB_batteryLevelUpdate:(NSString *) NameList;

Name: DisplaySB_batteryLevelUpdate;

Parameters: String representing new battery level

Output: None

Definition: Displays the SenzeBand's current battery level

---

  - (void) DisplaySB_EEG_GetAccXYZ:(float[]) XYZ;

Name: DisplaySB_EEG_GetAccXYZ;

Parameters: Array of Float values representing accelerometer force values, 3 floats for SenzeBand V1 and 6 floats for SenzeBandV2

Output: None

Definition: Displays the accelerometer force values

---

  - (void) DisplaySB_EEG_GetDirection:(NSString*) direction;

Name: DisplaySB_EEG_GetDirection;

Parameters: String representing direction SenzeBand is facing, e.g "", "N", "E", "S", "W", "NE", "SE", "NW", "SW"

Output: None

Definition: Displays the direction SenzeBand is facing

---

  - (void) DisplaySB_EEG_grabSenzeBandMCUID:(NSString *) NameList;

Name: DisplaySB_EEG_grabSenzeBandMCUID;

Parameters: String representing MCUID of currently connected SenzeBand

Output: None

Definition: Displays the SenzeBand's MCUID value

---

  - (void) DisplaySB_EEG_GetChannelStatus:(bool[4]) Value;

Name: DisplaySB_EEG_GetChannelStatus;

Parameters: Array of Boolean values representing the status of each SenzeBand electrode

Output: None

Definition: Displays the channel status of the SenzeBand

---

  - (void) DisplaySB_EEG_GoodConnectionCheck:(bool) Value;

Name: DisplaySB_EEG_GoodConnectionCheck;

Parameters: Boolean representing the status of the EEG Bluetooth connection

Output: None

Definition: Displays the Bluetooth connection value as True if connection is good, False if the connection is bad

---

  - (void) DisplaySB_EEG_GetMentalWorkload:(float) Value;

Name: DisplaySB_EEG_GetMentalWorkload;

Parameters: Float representing the mental workload level value, range of 0 (not taxing) - 1 (very taxing)

Output: None

Definition: Displays the mental workload level value

---

  - (void) DisplaySB_EEG_GetABDT:(float[20]) Value;

Name: DisplaySB_EEG_GetABDT

Parameters: Array of Float values representing the Delta, Theta, Alpha, Beta, Gamma values in each of the 4 electrode channels

Output: None

Definition: Displays the Delta, Theta, Alpha, Beta, and Gamma values for each of the 4 electrode channels.

---

  - (void) DisplaySB_EEG_GetABDTRaw:(float[36]) Value;

Name: DisplaySB_EEG_GetABDTRaw

Parameters: Array of Float values representing the raw Delta, Theta, Alpha, Beta, Gamma, LowAlpha, HighAlpha, LowBeta, HighBeta values in each of the 4 electrode channels

Output: None

Definition: Displays the raw Delta, Theta, Alpha, Beta, and Gamma values for each of the 4 electrode channels.

---

   - (void) DisplaySB_EEG_GetABDTNorm:(float[36]) Value;

Name: DisplaySB_EEG_GetABDTNorm

Parameters: Array of Float values representing the normalised Delta, Theta, Alpha, Beta, Gamma, LowAlpha, HighAlpha, LowBeta, HighBeta values in each of the 4 electrode channels

Output: None

Definition: Displays the normalised Delta, Theta, Alpha, Beta, and Gamma values for each of the 4 electrode channels.

---

   - (void) DisplaySB_EEG_GetABDTNorm:(float[36]) Value;

Name: DisplaySB_EEG_GetABDTNorm

Parameters: Array of Float values representing the normalised Delta, Theta, Alpha, Beta, Gamma, LowAlpha, HighAlpha, LowBeta, HighBeta values in each of the 4 electrode channels

Output: None

Definition: Displays the normalised Delta, Theta, Alpha, Beta, and Gamma values for each of the 4 electrode channels.

---

  - (void) DisplaySB_EEG_GetRawData:(int[1000]) Value;

Name: DisplaySB_EEG_GetRawData

Parameters: Array of Int values representing the EEG data, 250 Ints for each channel, with each Int value ranges from -2048 to 2047

Output: None

Definition: Displays raw EEG data from the SenzeBand, with each unit representing 0.61 microvolts

---

  - (void) DisplaySB_EEG_GetRawDataFloat:(float[1000]) Value;

Name: DisplaySB_EEG_GetRawDataFloat

Parameters: Array of Float values representing the EEG data, 250 Floats for each channel, with each Float value ranges from -2048 to 2047

Output: None

Definition: Displays raw EEG data from the SenzeBand, with each unit representing 0.61 microvolts

---

  - (void) DisplaySB_EEG_GetRawDataFiltered:(float[1000]) Value;

Name: DisplaySB_EEG_GetRawDataFiltered

Parameters: Array of Float values representing the EEG data, 250 Floats for each channel, with each Float value ranges from -2048 to 2047

Output: None

Definition: Displays filtered EEG data, with each unit representing 0.61 microvolts

---

  - (void) DisplaySB_EEG_Get5060Hz:(float[4]) Value;

Name: DisplaySB_EEG_Get5060Hz

Parameters: Array of Float values representing the 50-60Hz values for each electrode

Output: None

Definition: Displays the 50-60Hz value, with one float for each channel

---

  - (void) DisplayDA_AuthenticationStatus:(NSString *) status;

Name: DisplayDA_AuthenticationStatus

Parameters: String representing the authentication status from SenzeBand plugin, can be either "True" or "False"

Output: None

Definition: Displays authentication status of SenzeBand

---

  - (void) DisplayDA_AuthenticationStatusCode:(NSString *) statusCode;

Name: DisplayDA_AuthenticationStatusCode

Parameters: String representing the authentication status code from SenzeBand plugin, can be either "True" or "False"

Output: None

Definition: Displays authentication HTTP response

---

  - (void) SB_commandACK:(NSString*) ack;

Name: SB_commandACK

Parameters: String representing acknowledgement

Definition: Displays an acknowledgement of a given command

---

The following properties and their respective functions are in ViewController.m and are related to data receieved and processed from the SenzeBand. They can be used in your app to handle the data from the SenzeBand. This protocol glossary includes sample implementations of these methods, using interface declaration to receive EEG data via callbacks from SenzeBand framework.

---

---

Related properties include:

• bluetoothstatus
• ScanlistSB
• ConnectedList
• ConnectionStatus
• Batt

---

  - (void) BT_BTStatus:(bool) devicebtStatus
  {
      BTStatus = devicebtStatus;
      
      if(BTStatus == true)
      {
          [self activateScanButton];
          bluetoothstatus.text = @"";
          [self.startscan setEnabled:true];
      }
      else
      {
          startscanning = true;
          [self activateScanButton];
          [self.startscan setEnabled:false];
          bluetoothstatus.text = @"Please Check:\nDevice's Bluetooth is Off";
      }
  }

Name: BT_BTStatus

Parameters: Boolean representing the device's new Bluetooth status

Output: None

Definition: Called when the Bluetooth status has changed, starts scanning if Bluetooth is on

---

  - (void) BT_ScanList:(NSMutableArray*) NameList
  {
      ScanlistSB.text = [NSString StringWithFormat:@"%@",NameList];
      int indexno = (int)[NameList count] - 1;
      [self CreateButton:[NSString StringWithFormat:@"%@",[NameList objectAtIndex :indexno]]: indexno];
      bluetoothstatus.text = @"";
  } 

Name: BT_ScanList

Parameters: Mutable array of names of Bluetooth devices available

Output: None

Definition: Receives scanned devices

---

  - (void) BT_ConnectedList:(NSString *) NameList
  {
      NSLog(@"BT_ConnectedList=%@",NameList);

      DeviceConnected = NameList;
      ConnectedList.text = [NSString StringWithFormat:@"%@",NameList];
      
      if(![NameList isEqualToString:@""])
      {
          [self createdisconnectbtn];
      }
  }

Name: BT_ConnectedList

Parameters: Mutable array of names of currently connected Bluetooth devices

Output: None

Definition: Receives connected devices

---

  - (void) BT_ConnectionStatus:(bool) NameList
  {
      
      connectbuttonpressed = 0;
      if(NameList == false)
      {
          if ([disconnectConnectedSB count] != 0)
          {
              [[disconnectConnectedSB objectAtIndex:0] removeFromSuperview];
              [disconnectConnectedSB removeAllObjects];
              [self ClearList];
          }
          
          for (int i=0; i <[buttonsToRemove count]; i++)
          {
              [[buttonsToRemove objectAtIndex:i]removeFromSuperview];
          }
          [buttonsToRemove removeAllObjects];
          scancount = -1;
          
          ConnectionStatus.text = @"Not Connected";
          [[IOSSDK IOSSDK]startStopScanning:true];
      }
      else
      {
          ConnectionStatus.text = @"Connected";
      }
  }

Name: BT_ConnectionStatus

Parameters: Boolean representing status of currently connected SenzeBand

Output: None

Definition: Can be used to determine if the SenzeBand has been worn properly or whether the user is using it properly based on signal strength. If the sensor is not in contact with the skin, the signal will generally be weak and constitute mostly of just background electrical noise.

---

  - (void) DisconnectDevice:(NSString*) deviceAddress;

Name: DisconnectDevice

Parameters: String representing the BluetoothID of the device to disconnect

Output: None

Definition: Disconnects the Neeuro device with the same bluetoothID as the deviceName

---

  - (void) ConnectDevice:(NSString*) deviceAddress;

Name: ConnectDevice

Parameters: String representing the BluetoothID of the device to connect to

Output: None

Definition: Connects the Neeuro device with the bluetoothID to the app. Only one device can connect at any point of time.

---

  - (void) SB_batteryLevelUpdate:(NSString *) NameList ;
  {
      Batt.text = [NSString StringWithFormat:@"%@",NameList];
  }

Name: SB_batteryLevelUpdate

Parameters: String representing the percentage of battery of the currently connected SenzeBand

Output: None

Definition: Sets property Batt with the percentage of battery left

---

---

Related properties include:

• AuthenStatus
• AuthenStatusCode

---

  - (void) DA_AuthenticationStatus:(NSString *) status;
  {
      
      if(Status !=NULL)
          AuthenStatus.text = Status;
  }

Name: DA_AuthenticationStatus

Parameters: String representing the authentication status from SenzeBand plugin, can be either "True" or "False"

Output: None

Definition: Receives authentication status from SenzeBand plugin and sets the value of property AuthenStatus. A "True" value is required to receive data from the SenzeBand. Requires internet connection.

---

  NSTimer *AuthCheckTimer;
  - (void) DA_AuthenticationStatusCode:(NSString *) statusCode;
  {
      if(StatusCode !=NULL)
          AuthenStatusCode.text = StatusCode;

      if([StatusCode isEqualToString:@"Successful"])
      {
          if(AuthCheckTimer != nil)
          {
              [AuthCheckTimer invalidate];
              AuthCheckTimer = nil;
          }
          
          [self GetAuthenticationValidityPeriod];
      }
  }

Name: DA_AuthenticationStatusCode

Parameters: String representing the authentication status code from SenzeBand plugin, can be either "True" or "False"

Output: None

Definition: Receives authentication HTTP response and sets the value of property AuthenStatusCode

---

  - (void) initializeBT:(NSString *) developerCode;

Name: initializeBT

Parameters: String representing your developerCode

Output: None

Definition: Initialises the SDK

---

  - (void) authenticateUser;

Name: authenticateUser

Parameters: None

Output: None

Definition: Authenticates the user via the developer code that is passed in from initialize.

---

  - (long) getAuthenticationValidityInMilliseconds;

Name: getAuthenticationValidityInMilliseconds

Parameters: None

Output: None

Definition: Returns the authentication validity period remaining

---

---

  /*!
  Send command to SenzeBand
  
  @param command A command String
      COMMAND_AC_LEADOFF
      COMMAND_DC_LEADOFF
      COMMAND_LIGHT_RED
      COMMAND_LIGHT_GREEN
      COMMAND_LIGHT_BLUE
      COMMAND_LIGHT_CYAN
      COMMAND_LIGHT_MAGENTA
      COMMAND_LIGHT_YELLOW
      COMMAND_STOP_RGB
      COMMAND_CMD_FA - Evoke event
      COMMAND_FW_VER - Get firmware version
      COMMAND_CAL_START - Calibration start
      COMMAND_CAL_STOP - Calibration stop
      COMMAND_START start - Sending eeg data
      COMMAND_STOP stop - Sending eeg data
      COMMAND_PPG_START - Start sending ppg data
      COMMAND_PPG_STOP - Stop sending ppg data
  */
  - (void) grabInputCommand:(NSString *) command;

Name: grabInputCommand

Parameters: String representing a command, one of the above

Output: None

Definition: Sends a command to the SenzeBand

---

---

Related properties include:

• Attention
• Relaxation
• MentalWorkload
• AccX
• AccY
• AccZ
• MCUIDNo
• Channel1
• Channel2
• Channel3
• Channel4
• GoodConnectionCheck
• C1Delta
• C1Theta
• C1Alpha
• C1Beta
• C1Gamma
• C15060Hz

---

  - (void) SB_EEG_GetAttention:(float) Value;
  {
      Attention.text = [NSString StringWithFormat:@"%f",CLAMP(Value, 0.0f, 1.0f)];
  }

Name: SB_EEG_GetAttention

Parameters: Float representing the attention level value, range of 0 (low attention) - 1 (high attention)

Output: None

Definition: Sets the value of property Attention

---

  - (void) SB_EEG_GetRelaxation:(float) Value
  {
      Relaxation.text = [NSString StringWithFormat:@"%f",CLAMP(Value, 0.0f, 1.0f)];
  }

Name: SB_EEG_GetRelaxation

Parameters: Float representing the relaxation level value, range of 0 (very tensed) - 1 (very relaxed)

Output: None

Definition: Sets the value of property Relaxation, calculated from the latest set of EEG data received from the SenzeBand device.

---

  - (void) SB_EEG_GetMentalWorkload:(float) Value
  {
      MentalWorkload.text = [NSString StringWithFormat:@"%f",CLAMP(Value, 0.0f, 1.0f)];

  }

Name: SB_EEG_GetMentalWorkload

Parameters: Float representing the mental workload level value, range of 0 (not taxing) - 1 (very taxing)

Output: None

Definition: Sets the value of property MentalWorkload, calculated from the latest set of EEG data received from the SenzeBand device.

---

  - (void) SB_EEG_GetAccXYZ:(float[]) XYZ;
  {
      NSString * _Nonnull accX = [NSString StringWithFormat:@"%.2f",XYZ[0]];
      NSString * _Nonnull accY = [NSString StringWithFormat:@"%.2f",XYZ[1]];
      NSString * _Nonnull accZ = [NSString StringWithFormat:@"%.2f",XYZ[2]];
      
      NSLog(@"ViewController SB_EEG_GetAccXYZ accX=%@ accY=%@ accZ=%@", accX, accY, accZ);
      NSLog(@"ViewController SB_EEG_GetAccXYZ XYZ[3]=%@ XYZ[4]=%@ XYZ[5]=%@", [NSString StringWithFormat:@"%.2f",XYZ[3]], [NSString StringWithFormat:@"%.2f",XYZ[4]], [NSString StringWithFormat:@"%.2f",XYZ[5]]);
      NSLog(@"ViewController SB_EEG_GetAccXYZ XYZ[6]=%@ XYZ[7]=%@ XYZ[8]=%@", [NSString StringWithFormat:@"%.2f",XYZ[6]], [NSString StringWithFormat:@"%.2f",XYZ[7]], [NSString StringWithFormat:@"%.2f",XYZ[8]]);
      
      
      AccX.text = accX;
      AccY.text = accY;
      AccZ.text = accZ;
  }

Name: SB_EEG_GetAccXYZ

Parameters: Array of Float values representing accelerometer force values, 3 floats for SenzeBand V1 and 6 floats for SenzeBandV2

Output: None

Definition: Sets the accelerometer values. The first 3 floats hold X,Y,Z components of the force received by the accelerometer, ranging from -2048 to 2048. When the device is stationary, the XYZ components will provide the direction of gravity. For SenzeBand V2 the last 3 floats hold X,Y,Z components of orientation.

---

  - (void) SB_EEG_GetDirection:(NSString *) direction;{
      
      NSLog(@"ViewController SB_EEG_GetDirection direction=%@", direction);
  }

Name: SB_EEG_GetDirection

Parameters: String representing direction SenzeBand is facing, e.g "", "N", "E", "S", "W", "NE", "SE", "NW", "SW"

Output: None

Definition: Logs the direction SenzeBand is facing

---

  - (void) SB_GetSPO2AndHeartRate:(int[]) Value
  {
      NSLog(@"ViewController SB_GetSPO2AndHeartRate SPO2=%d HeartRate=%d HeartRateDetected=%d", Value[0], Value[1], Value[2]);
  }

Name: SB_GetSPO2AndHeartRate

Parameters: Array of Int values representing SPO2, heart rate and heart rate detected value

Output: None

Definition: Logs the SPO2, heart rate and heart rate detected value. Heart rate detected value is either 0 (sensor is not touched) or 1 (sensor is touched).

---

  - (void) SB_EEG_GetEvoke:(int) Value
  {
      NSLog(@"ViewController SB_EEG_GetEvoke %d", Value);
  }

Name: SB_EEG_GetEvoke

Parameters: Int representing the time in milliseconds

Output: None

Definition: Logs the time in milliseconds of last event from first EEG data transmission

---

  - (void) SB_EEG_GetImpedance:(float[4]) Value
  {
      NSLog(@"ViewController SB_EEG_GetImpedance ch1=%f ch2=%f ch3=%f ch4=%f", Value[0], Value[1], Value[2], Value[3]);
  }

Name: SB_EEG_GetImpedance

Parameters: Array of Float values representing impedance of each EEG channel

Output: None

Definition: Logs the impedance of each EEG channel in kOhms

---

  - (void) SB_EEG_GetFWVER:(NSString *) Value
  {
      NSLog(@"ViewController SB_EEG_GetFWVER %@", Value);
  }

Name: SB_EEG_GetFWVER

Parameters: String value representing firmware version of currently connected SenzeBand

Output: None

Definition: Logs the firmware version of the SenzeBand

---

  - (void) SB_EEG_GetCalibrationParameters:(float[3]) Value
  {
      NSLog(@"ViewController SB_EEG_GetCalibrationParameters Xgain=%f Ygain=%f ZGain=%f", Value[0], Value[1], Value[2]);
  }

Name: SB_EEG_GetCalibrationParameters

Parameters: Array of Float values representing calibration parameters of currently connected SenzeBand

Output: None

Definition: Logs the calibration parameters: xGain, yGain and zGain

---

  - (void) SB_EEG_grabSenzeBandMCUID:(NSString *) NameList;
  {
      MCUIDNo = NameList;
  }

Name: SB_EEG_grabSenzeBandMCUID

Parameters: String representing MCUID of currently connected SenzeBand

Output: None

Definition: Sets the MCUID value. This can be retrieved only after connection. A MCUID is a 24 character String unique to every SenzeBand device.

---

  - (void) SB_EEG_GetChannelStatus:(bool[4]) NameList;
  {
      Channel1.text = (NameList[0])? @"true":@"false";
      Channel2.text = (NameList[1])? @"true":@"false";
      Channel3.text = (NameList[2])? @"true":@"false";
      Channel4.text = (NameList[3])? @"true":@"false";
  }

Name: SB_EEG_GetChannelStatus

Parameters: Array of Boolean values representing the status of each SenzeBand electrode

Output: None

Definition: Sets the channel status values. Each channel may get a strong signal if the sensor is in contact with the forehead. If the channel gets a weak signal, it may be the sensor is not in good contact with the forehead. With the power button facing left, channel 1 is the rightmost sensor.

---

  - (void) SB_EEG_GoodConnectionCheck:(bool) Value;
  {
      if (Value ==true)
      {
          GoodConnectionCheck.text = @"Good Signal";
      }
      else
      {
          GoodConnectionCheck.text = @"Poor Signal";
      }
  }

Name: SB_EEG_GoodConnectionCheck

Parameters: Boolean representing the status of the EEG Bluetooth connection

Output: None

Definition: Sets the Bluetooth connection value as True if connection is good. Interference from other Bluetooth signal emitters can lead to data loss.

---

  - (void) SB_EEG_GetABDT:(float[20]) Value
  {
      C1Delta.text = [NSString StringWithFormat:@"%f",CLAMP(Value[2*5+0], 0.0f, 1.0f)];
      C1Theta.text = [NSString StringWithFormat:@"%f",CLAMP(Value[2*5+1], 0.0f, 1.0f)];
      C1Alpha.text = [NSString StringWithFormat:@"%f",CLAMP(Value[2*5+2], 0.0f, 1.0f)];
      C1Beta.text  = [NSString StringWithFormat:@"%f",CLAMP(Value[2*5+3], 0.0f, 1.0f)];
      C1Gamma.text = [NSString StringWithFormat:@"%f",CLAMP(Value[2*5+4], 0.0f, 1.0f)];
  }

Name: SB_EEG_GetABDT

Parameters: Array of Float values representing the Delta, Theta, Alpha, Beta, Gamma values in each of the 4 electrode channels

Output: None

Definition: Sets the Delta, Theta, Alpha, Beta, and Gamma values for each of the 4 electrode channels. The size of input is an array of [4*5]. There are 4 channels and 5 frequency types, ie. Delta, Theta, Alpha, Beta, Gamma. The values are of Frequency Band Power Spectral Density; where the 5 frequency types' values add up to 1.

---

  - (void) SB_EEG_GetABDTRaw:(float[36]) Value
  {
      for(int i = 0;i < 4;i++){
          NSLog(@"ViewController SB_EEG_GetABDTRaw Channel [%d] Delta=%.3f Theta=%.3f Alpha=%.3f Beta=%.3f Gamma=%.3f LowAlpha=%.3f HighAlpha=%.3f LowBeta=%.3f HighBeta=%.3f",i, Value[i*9+0], Value[i*9+1], Value[i*9+2], Value[i*9+3], Value[i*9+4], Value[i*9+5], Value[i*9+6], Value[i*9+7], Value[i*9+8]);
      }
  }

Name: SB_EEG_GetABDTRaw

Parameters: Array of Float values representing the raw Delta, Theta, Alpha, Beta, Gamma, LowAlpha, HighAlpha, LowBeta, HighBeta values in each of the 4 electrode channels

Output: None

Definition: Logs the raw Delta, Theta, Alpha, Beta, and Gamma values for each of the 4 electrode channels. The size of input is an array of [4*9]. There are 4 channels and 9 frequency types, ie. Delta, Theta, Alpha, Beta, Gamma, LowAlpha, HighAlpha, LowBeta, HighBeta. The values are of Frequency Band Power Spectral Density; where the 5 frequency types' values add up to 1.

---

   - (void) SB_EEG_GetABDTNorm:(float[36]) Value
      {
          for(int i = 0;i < 4;i++){
              NSLog(@"ViewController SB_EEG_GetABDTNorm Channel [%d] Delta=%.3f Theta=%.3f Alpha=%.3f Beta=%.3f Gamma=%.3f LowAlpha=%.3f HighAlpha=%.3f LowBeta=%.3f HighBeta=%.3f",i, Value[i*9+0], Value[i*9+1], Value[i*9+2], Value[i*9+3], Value[i*9+4], Value[i*9+5], Value[i*9+6], Value[i*9+7], Value[i*9+8]);
          }
      }

Name: SB_EEG_GetABDTNorm

Parameters: Array of Float values representing the normalised Delta, Theta, Alpha, Beta, Gamma, LowAlpha, HighAlpha, LowBeta, HighBeta values in each of the 4 electrode channels

Output: None

Definition: Logs the normalised Delta, Theta, Alpha, Beta, and Gamma values for each of the 4 electrode channels. The size of input is an array of [4*9]. There are 4 channels and 9 frequency types, ie. Delta, Theta, Alpha, Beta, Gamma, LowAlpha, HighAlpha, LowBeta, HighBeta. The values are of Frequency Band Power Spectral Density; where the 5 frequency types' values add up to 1.

---

  - (void) SB_EEG_GetRawData:(int[1000]) Value
  {
      printf("SB_EEG_GetRawData= ");
      for (int i=0; i < 1000; i++)
      {
          printf("%d ",Value[i]);

      }
      printf("\n");
  }

Name: SB_EEG_GetRawData

Parameters: Array of Int values representing the EEG data, 250 Ints for each channel, with each Int value ranges from -2048 to 2047

Output: None

Definition: Prints raw EEG data from the SenzeBand, with each unit representing 0.61 microvolts

---

  - (void) SB_EEG_GetRawDataFloat:(float[1000]) Value
  {
      printf("SB_EEG_GetRawDataFloat= ");
      for (int i=0; i < 1000; i++)
      {
          printf("%d ",Value[i]);

      }
      printf("\n");
  }

Name: SB_EEG_GetRawDataFloat

Parameters: Array of Float values representing the EEG data, 250 Floats for each channel, with each Float value ranges from -2048 to 2047

Output: None

Definition: Prints raw EEG data from the SenzeBand, with each unit representing 0.61 microvolts

---

  - (void) SB_EEG_GetRawDataFiltered:(float[1000]) Value
  {
      printf("SB_EEG_GetRawDataFiltered= ");
      for (int i=0; i < 1000; i++)
      {
          printf("%d ",Value[i]);

      }
      printf("\n");
  }

Name: SB_EEG_GetRawDataFiltered

Parameters: Array of Float values representing the EEG data, 250 Floats for each channel, with each Float value ranges from -2048 to 2047

Output: None

Definition: Prints filtered EEG data, with each unit representing 0.61 microvolts

---

  - (void) EEG_Start;

Name: EEG_Start

Parameters: None

Output: None

Definition: Starts the EEG to grab the data from the SenzeBand device

---

  - (void) EEG_Stop;

Name: EEG_Stop

Parameters: None

Output: None

Definition: Stops the EEG to grab the data from the SenzeBand device

---

  - (void) StartStopAnalyze;

Name: StartStopAnalyze

Parameters: None

Output: None

Definition: Toggles processing of EEG data

---

  - (void) SB_EEG_Get5060Hz:(float[4]) Value
  {
      C15060Hz.text =[NSString StringWithFormat:@"%.2f  %.2f  %.2f  %.2f", Value[0], Value[1], Value[2], Value[3]];
  }

Name: SB_EEG_Get5060Hz

Parameters: Array of Float values representing the 50-60Hz values for each electrode

Output: None

Definition: Sets the 50-60Hz value, with one float for each channel

---

---

  - (void) SB_PPG_GetRawData:(int[]) Value
  {
      NSLog(@"ViewController SB_PPG_GetRawData IR=%d RED=%d", Value[0], Value[1]);
  }

Name: SB_PPG_GetRawData

Parameters: Array of Int values representing PPG data, with the first element as the IR (blue light) and the second as RED (red light)

Output: None

Definition: Logs the raw PPG data

---

---

  - (NSString*) GetEnvironmentData:(int) index;

Name: GetEnvironmentData

Parameters: None

Output: None

Definition: Returns current environment values

---

  - (NSString*) GetEnvironmentData:(int) index;

Name: GetEnvironmentData

Parameters: Int

Output: None

Definition: Returns current environment values

---

  - (void) startStopScanning: (bool) toStart;

Name: GetEnvironmentData

Parameters: Boolean representing a flag to start or stop the scanning.

Output: None

Definition: Sets the scanning mode

---

  - (void) ClearDeviceList;

Name: GetEnvironmentData

Parameters: None

Output: None

Definition: Clears the list of discovered Neeuro devices. Clears the list of discovered Neeuro devices.

---

  - (void) SetEnvironmentThreshold: (NSString*) envThreshold;

Name: SetEnvironmentThreshold

Parameters: String consisting of normalised gamma and 50-60Hz threshold values separated by spaces

Output: None

Definition: Sets gamma and 5060Hz threshold for useful data

---

  (NSString *) getVersion;

Name: getVersion

Parameters: None

Output: String representing SDK version

Definition: Returns current SDK version

---

  - (void) SB_commandACK:(NSString*) ack;

Name: SB_commandACK

Parameters: String representing acknowledgement

Definition: Recieves an acknowledgement of a given command

---

Using the NeeuroOS SDK App

---

1. Ensure Bluetooth is turned on for your Windows device

2. Unzip the zip folder and make sure all these files are inside

3. Double click on “NeeuroSenzeBandSDKClient.sln” to run the application.

---

This section will walk you through how to develop your own app using the Neeuro SenzeBand (NSB) Windows Standard SDK.

Development using the Neeuro SenzeBand (NSB) Windows Standard SDK can be done in the following stages:

1. Initialisation
2. Scanning
3. Connecting
4. Authenticating
5. Impedance Check and Calibration
6. Using the SenzeBand
7. Disconnecting
8. Writing to Files

1. Reference the dll: SenzeBandWindowsIPC_ClientDLL.
2. Ensure that win_res is in the executable folder. It is required for SenzeBand communication.
3. Having set up and built the NeeuroOS SDK, NSB_SDK_WINDOWS.cs will be the main control script for accessing SenzeBand functions.
4. Run NSB_SDK to initialise the SDK.

1. Call button_startScanButton to start scanning. It is automatically switched ON at Initialization. However, in the case when SetScanning was switched to OFF, you can switch it ON manually by calling the button_startScanButton function.
2. When scanning is enabled, there are three possible callbacks.
   • receiveScanResult() - Callback for detecting a Neeuro SenzeBand added or removed in the scan list
   • `updateScanResult() - Callback when a property change is detected in the scan list (eg. when a SenzeBand becomes connected)
   • enumerationComplete() - Callback when the scanning process is completed
3. To stop the scan, run button_stopScanButton.

1. There are two callbacks that will trigger once you attempt to connect to a SenzeBand device.
   • connectedCallback - this is triggered the moment the plugin confirms that SenzeBand connection is successful.
   • connectFailCallBack - this is triggered when the app fails to connect successfully to the SenzeBand.
2. To connect to a SenzeBand device, select one device in the list of scanned SenzeBands and call ConnectDevice(String) with its device id. This automatically causes the scan to stop.
3. Once the SenzeBand has been successfully connected, connectedCallback will be called.

1. For the Standard SDK, you'll need an internet connection to Authenticate your developer code with Neeuro's servers. Call authButton_Click to attempt authentication.
2. Authentication is automatically done when a SenzeBand is connected. However, in the case when authentication fails, you can authenticate manually by calling authButton_Click.
3. Note that if authentication fails, you will not be able to receive any data from the SenzeBand.

1. Impedance Check helps to verify if the signal quality from the 4 contact points/electrodes are good. Example, if there is makeup or some other impurities on the skin, the impedance values will be much higher due to the contribution of more resistance between the electrodes and skin surface, the EEG signals will not be good/accurate. Good impedance range is below 800k Ohms.
2. We recommend to do an Impedance Check/Signal Quality Check after SenzeBand connection before using the SenzeBand.
3. To do impedance check, call ACbutton_Click in your program. Switching to AC mode will stop SenzeBand from receiving EEG and start on checking signal quality. Advise the user to adjust SenzeBand and wipe off residue on skin to get better contact until all channel signals are green. Once done, switch back to DC mode by calling DCButton_Click. By default, SenzeBand is in DC mode after a successful connection.
4. Switching AC mode and DC mode can take a moment before plugin can verify and actually switch modes.
5. If user thinks that the Acceleration and Orientation data is not accurate, we can perform calibration to improve the accuracy. To initiate calibration, call CalStartButton_Click. To stop calibration, call CalStopButton_Click.

1. After you've connected the SenzeBand, you need to first enable it. You can do this by calling StartButton_Click for EEG data or PPGStartButton_Click for PPG data. This allows data from the SenzeBand to be sent over to the app.
2. There are several different types of data you can grab from the SenzeBand. For each type of data, there is a callback that comes with it with a respective interface, such as scanCallBack, or authenticationCallBack.
3. You can call StopButton_Click for EEG data or PPGStopButton_Click for PPG data to stop the SenzeBand from sending data.

1. Call button_DisconnectDevice to disconnect the SenzeBand.

1. To start writing to files, open the SDK and press the Start button to start recording.

2. The Stop button stops recording, saving data automatically to a CSV or EDF file at a default location, stated when saving is complete.

3. View the file by accessing the location necessary in the Files app.

---

---

  void assignAccDelegate(FloatArrayRVoid accDelegateIn);

Name: assignAccDelegate

Parameters: FloatArrayRVoid representing the accelerometer values

Output: None

Definition: Binds the data delegate for accelerometer data. The result is an array of 3 floats for SenzeBand V1 and 6 floats for SenzeBandV2. The first 3 floats hold X,Y,Z components of the force received by the accelerometer. When the device is stationary, the XYZ components will provide the direction of gravity. For SenzeBand V1, each X, Y, Z value range from -2048 to 2048 For SenzeBand V2 the last 3 floats hold X,Y,Z components of orientation.

---

  void assignCalParamsDelegate(FloatArrayRVoid delegateIn);

Name: assignCalParamsDelegate

Parameters: FloatArrayRVoid representing calibration parameters: xGain, yGain and zGain

Output: None

Definition: Binds the data delegate for calibration parameters data.

---

  void assignChannelDelegate(BoolArrayRVoid channelDelegateIn);

Name: assignChannelDelegate

Parameters: BoolArrayRVoid representing 4 channel status boolean data

Output: None

Definition: Binds the data delegate for channel data. Each boolean represents a channel. Each channel may get a strong signal if the sensor is in contact with the forehead. If the channel gets a weak signal, it may be the sensor is not in good contact with the forehead. With the power button facing left, channel 1 is the rightmost sensor.

---

  void assignDirectionDelegate(StringRVoid delegateIn);

Name: assignDirectionDelegate

Parameters: StringRVoid representing the receiver delegate

Output: None

Definition: Binds the data delegate for directon data: String value, e.g "", "N", "E", "S", "W", "NE", "SE", "NW", "SW"

---

  void assignEvokeDelegate(IntRVoid delegateIn);

Name: assignEvokeDelegate

Parameters: IntRVoid representing the receiver delegate

Output: None

Definition: Binds the data delegate for time in milliseconds of last evoke event from first EEG data transmission

---

  void assignFilteredDataDelegate(FloatArrayRVoid delegateIn);

Name: assignFilteredDataDelegate

Parameters: FloatArrayRVoid representing the delegate to receive filtered EEG data (1000 ints)

Output: None

Definition: Binds the data delegate for filtered EEG data

---

  void assignImpedanceDelegate(FloatArrayRVoid delegateIn);

Name: assignImpedanceDelegate

Parameters: FloatArrayRVoid representing the delegate to receive array of 4 impedance value in kOhms

Output: None

Definition: Binds the data delegate for 4 channel impedance data

---

  void assignPPGDataDelegate(IntArrayRVoid delegateIn);

Name: assignPPGDataDelegate

Parameters: IntArrayRVoid representing the delegate to receive PPG data. The 1st element is IR and the 2nd element is RED

Output: None

Definition: Binds the data delegate for PPG data

---

  void assignRawData200msDelegate(FloatArrayRVoid delegateIn);

Name: assignRawData200msDelegate

Parameters: FloatArrayRVoid representing the delegate to receive raw EEG data (200 floats), 50 floats for each channel.

Output: None

Definition: Binds the data delegate for raw EEG data 200ms

---

---

  void assignRawDataDelegate(IntArrayRVoid delegateIn);

Name: assignRawDataDelegate

Parameters: IntArrayRVoid representing the delegate to receive raw EEG data (1000 ints), 250 ints for each channel. Each int value ranges from -2048 to 2047. Every 1 unit represents 0.61 microvolt.

Output: None

Definition: Binds the data delegate for raw EEG data

---

---

  void assignSPO2HeartRateDelegate(IntArrayRVoid delegateIn);

Name: assignSPO2HeartRateDelegate

Parameters: IntArrayRVoid representing the delegate to receive int array in form of [SPO2, HeartRate, HeartRateValue].

Output: None

Definition: Binds the data delegate for SPO2, heart rate and heart rate detected value. Heart rate detected value is either 0 (sensor is not touched) or 1 (sensor is touched).

---

---

  void getAuthenticationResult(String address, String result, String message)

Name: getAuthenticationResult

Parameters:

• String representing the address of the device authenticated
• String representing the http status of the authentication
• String representing the message of the authentication 200 : Success. 404 : Developer code is not found

Output: None

Definition: A callback that sends in the authentication result, called when {NativeNSBInterface::authenticateUser} has been called.

---

  void timeUp(Object obj)

Name: timeUp

Parameters: Object representing object being authenticated

Output: None

Definition: A callback that returns when the time given to use the SenzeBand is up. Generally, authentication is done automatically. However, due to factors such as unstable/no Internet connection or an unlikely network error, establishing connection to Neeuro's server may fail. In that case, the time allocated to use the SenzeBand will end. This method will be called once the time frame for authentication is up. To continue using the SenzeBand, you should call {NativeNSBInterface::authenticateUser}.

---

  void initializeSBWI(StringStringBoolRVoid connectedCallBackFunction, StringRVoid setBluetoothDeviceNotConnectFunction, String developerCode, VoidRVoid completedCB = null, StringRVoid errorLog = null)

Name: initializeSBWI

Parameters:

• connectedCallBack: Callback function when a Neeuro SenzeBand connection is completed. The callback will receive: bluetooth address string, mac address string and a boolean hasExistingConnection
• connectFailCallBack: Callback function when the connection fails to succeed. The callback will receive: bluetooth address string
• developerCode: Required for authentication
• completedInitialization: Callback function when the setup (of initialisation) is completed
• errorLog: Callback function when there is an internal system error logged. The callback will receive: log message string

Output: None

Definition: Initialises systems

---

  bool sendCommand(String command)

Name: sendCommand

Parameters: String representing the command to send

Possible String commands include:

• COMMAND_START - for starting EEG
• COMMAND_STOP - for stopping EEG
• COMMAND_PPG_START - start sending ppg data
• COMMAND_PPG_STOP - stop sending ppg data
• COMMAND_AC_LEADOFF - for turning ON impedance check mode
• COMMAND_DC_LEADOFF - for turning OFF impedance check mode
• COMMAND_LIGHT_RED - sets SenzeBand device light to red color
• COMMAND_LIGHT_GREEN - sets SenzeBand device light to green color
• COMMAND_LIGHT_BLUE - sets SenzeBand device light to blue color
• COMMAND_LIGHT_CYAN - sets SenzeBand device light to cyan color
• COMMAND_LIGHT_MAGENTA - sets SenzeBand device light to magenta color
• COMMAND_LIGHT_YELLOW - sets SenzeBand device light to yellow color
• COMMAND_STOP_RGB - stops light commands
• COMMAND_FW_VER - command for getting the firmware version of SenzeBand device
• COMMAND_CAL_START - start calibration for acceleration and orientation to improve accuracy
• COMMAND_CAL_STOP - stop calibration
• COMMAND_CMD_FA - evoke event

Output: Boolean representing the success of sending the command

Description: Send command to SenzeBand device

---

  void startScanning(scanCB scanCallBack, updateDeviceCB scannedDeviceUpdateCB, VoidRVoid enumerationCompletedCB)

Name: startScanning

Parameters:

• scanCallBack: Callback for detecting a Neeuro SenzeBand added or removed in the scan list
• scannedDeviceUpdateCB: Callback when a property change is detected in the scan list (eg. when a SenzeBand becomes connected)
• enumerationCompletedCB: Callback when the scanning process is completed

Output: None

Definition: Signal plugin to start scanning for SenzeBands

---

delegate void scanCB (ScannedDeviceClass scanCallBack, bool addDevice)

delegate void updateDeviceCB (ScannedDeviceClass scanCallBack)

delegate void VoidRVoid ()

delegate void StringRVoid (string stringIn)

delegate void IntRVoid (int intIn)

delegate void StringBoolRVoid (string stringIn, bool boolIn)

delegate void StringStringRVoid (string stringIn, string stringIn2)

delegate void StringStringBoolRVoid (string stringIn, string stringIn2, bool boolIn)

delegate void FloatRVoid (float floatIn)

delegate void FloatArrayRVoid (float[] floatArrayIn)

delegate void Float2DArrayRVoid (float[,] float2DArrayIn)

delegate void IntArrayRVoid (int[] floatArrayIn)

delegate void BoolRVoid (bool boolIn)

delegate void BoolArrayRVoid (bool[] boolArrayIn)

---

1. Unzip the SDK folder and make sure all these files are inside. Neeuro_SenzeBand_Example_Project is a sample Unity project that contains a SenzeBand control panel scene to show what the Neeuro SenzeBand can do. Coded with comments on how to use the SDK, using Unity 2022.2.4f1.

2. Start by importing the asset package into your scene.

3. Make sure that the prefabs "NSB_BLE", "NSB_EEG" and "NSB_Manager" are in your scene. The prefabs are in Project window > Assets > NSB_SDK > Prefabs. They have scripts NSB_BLE.cs, NSB_EEG.cs and NSB_Manager.cs respectively. These are required to be able to communicate with the SenzeBand plugin.

4. Check that NSBAndroidStandard.dll, NSBIOSStandard.dll, NSBWindowsStandard.dll and SenzeBandWindowsIPC_ClientDLL.dll are inside folder /Assets/NSB_SDK/DLL.

5. Check that NSBAndroidUnityPlugin-standard-release.aar and AndroidManifest.xml are in folder/Assets/Plugins/Android.

6. Check that IOSBLERobot.framework is in folder /Assets/Plugins/IOS.

7. Check that win_res folder and win_res.zip are in folder /Assets/.

8. Under Unity Editor's Build Settings, switch your platform to Android, iOS or Windows.

9. You can now start developing using the SDK!

The following functions are provided for handling the SenzeBand plugin:

• The ForceAskPermission and PermissionCanvas will be used for triggering permission popups for Android and IOS devices so the app can use Bluetooth services.
• ForceAskPermission will be in charge of enabling the NSB_BLE, NSB_EEG, and NSB_Manager objects after Bluetooth services are allowed for the app.
• Feel free to edit the EnablePermissionsPopup_Android and EnablePermissionsPopup_iOS according to your app design and identification.

The set up instructions below include how to enter the provided Developer Code in the NSB_Manager game object. The AuthenticationResult delegate will receive a True value when authentication succeeds. Please also ensure your device has an internet connection and that all system requirements are met.

1. Select prefab "NSB_Manager" in Project window > Assets > NSB_SDK > Prefab.
2. Look for DEVELOPER_CODE under NSB_Manager (Script) in the inspector window.
3. Set it to your Developer Code.

The following helper functions are also provided for handling the Developer Code:

• In NSB_Manager.cs, GetAuthenticationStatus() will retrieve whether the app is successful with authenticating with Neeuro's Server. Required to have authentication in order to obtain the data from the SenzeBand (EEG data, mental states, frequency bands, and accelerometer values). At every connection to SenzeBand, the app will try to authenticate. Hence, it is necessary to have Internet connection.
• In NSB_Manager.cs, there is a UnityEvent called authenticationUpdated that is triggered when authentication result is sent from SenzeBand to Unity or every second after authentication is successful. In the sample, it is used to show how many seconds left before authentication expires.

1. Use Unity to open the project folder.

2. Open "Demo" scene.

3. The GameObject NSB_Objs contains the required objects to communicate with the plugin.

4. The GameObject NSB_Manager is the main point to control and receive Mental State data. It communicates with the plugin via NSB_EEG and NSB_BLE.

5. Under Unity Editor's Build Settings, switch your platform to Android, iOS or Windows.

6. Follow the next set of instructions for building onto the platforms.

The ForceAskPermission function is what enables Bluetooth services for Android and iOS. It asks for permission from the OS to utilize Bluetooth.

Missing editor version error

Install the missing version of the editor before trying again.

Enter safe mode? The project you are opening contains compilation errors.

Press enter safe mode.

Unity error CS0234: The type or namespace name 'UI' does not exist in the namespace 'UnityEngine' (are you missing an assembly reference?)

Open Package Manager and add the 'Unity UI' Package.

Unity error CS0236:

Ignore this error and exit safe mode.

---

1. Under Build Settings -> Player Settings -> Other Settings -> set Minimum API Level to Android 8.0 'Oreo' (API level 26).

2. Under Build Settings -> Player Settings -> Other Settings -> API Compatibility level -> Make sure that it is at .NET Framework. Set Mute Other Audio Sources to TRUE.

3. Under Build Settings -> Player Settings -> Other Settings -> Scripting Backend -> make sure that it is at IL2CPP. Include ARM64 in Target Architectures.

4. To be able to build, we need to set the Gradle version to 7.5.1. Go to Build Settings -> Player Settings -> Publishing Settings and enable Custom Main Gradle Template and Custom Gradle Properties Template. Go to Player Settings -> Other Settings and set the Target API Level to API Level 34 or higher.

5. Build the Unity project to generate an APK file

6. The APK file can be copied to the Android devices, to install your app project.

1. Under Build Settings > Player Settings > Other Settings > API compatibility Level > Make sure that it is at .NET Framework.

2. Build the Unity project into Xcode project.

3. Open the Xcode project. Connect your iOS device to your Mac via a cable.

4. Select Unity-iPhone in the sidebar. Under General -> Frameworks, Libraries and Embedded Content, click Add (+) -> Add Other... -> Add Files... -> Frameworks -> Plugins -> IOS -> IOSBLERobot.framework.

5. Under General -> Frameworks, Libraries and Embedded Content, ensure that the UnityFramework.framework is added. It can be found by clicking the + button.

6. Under Signing & Capabilities, press the '+ Capability' button and search for 'Background Modes'. Ignore the popup 'Error Loading Capabilities: No development team is set'

7. Add Background Modes to the project and select 'Uses Bluetooth LE accessories'.

8. Under Build Settings, search for "Runpath Search Paths" then change the value to "@executable_path/Frameworks".

9. Under Build Settings, search for 'Bitcode' > Build Options > Enable Bitcode = 'No'. If using Xcode 16 and above, this setting may not be found, skip this step.

10. Under Info > iOS Target Properties, add a property 'Privacy - Bluetooth Always Usage Descriptor', give a value 'For connection with Neeuro SenzeBand'.

11. Under Info > iOS Target Properties, add a property "Privacy - Bluetooth Peripheral Usage Description", give the same value.

12. Under Info > iOS Target Properties, add a property "Privacy - Location When In Use Usage Description", give a value "For detecting nearby SenzeBand devices".

13. If present, remove "libiconv.2.dylib" on the Project panel

14. Under Signing & Capabilities > All - Click Automatically manage signing if you want Xcode to do it automatically and then select a Development Team.

15. Under Build Phases, drag Embed Frameworks to the 3rd position.

16. Build and run on Xcode and the connected iOS devices (not simulated)

17. Change device to iOS and open the app.

1. Under Build Settings > Player Settings > Other Settings > API Compatibility level > Make sure it is at .NET Framework.

2. Ensure that the win_res folder is in the Assets folder and that the program in the .server is able to scan and connect to a SenzeBand.

3. To manually copy the win_res folder to the build, extract the "win_res.zip" file in the "Assets" folder to the same directory.

4. Build the Unity project to output Windows program. Note: WindowsBuild.cs Editor script will automatically copy the win_res folder into the build folder for Bluetooth process handling.

5. From the "/Assets/win_res/" folder, copy the ".server" folder to be in the same folder as the output EXE file. This program is required for Windows Bluetooth connection to Neeuro SenzeBand.

6. Build the Windows app.

Note on C# Exceptions: If Exception handling is used in Unity scripts, "Enable C# Exceptions" must be set to true.

No module loaded in build settings.

Press 'Install with Unity Hub' and select all the platforms you want to build your app for.

After install is complete, if build settings still say there is no module loaded, close and reopen the project.

I can't find .NET Framework in API Compatability level.

Make sure that API Compatibility level is at .NET 4.x or .NET Framework. These are the same, in Unity 2021.2 .NET 4.x was renamed to .NET Framework.

iOS build warning: No Xcode automatically detected to run your project. Please check Xcode is installed and select it manually.

Install Xcode through app store on Mac.

Note: It is not possible to develop an iOS app without a Mac as Xcode is not available for non-Mac users. After install is complete, if build settings still say there is no Xcode detected, close and reopen the project.

iOS build failure: Unity-iPhone requires a provisioning profile. Select a provisioning profile in the Signing & Capabilities editor.

Under Signing & Capabilities > All - Click Automatically manage signing and then select a Development Team. You may need to go to developer.Apple.com and sign up before being able to login to your Apple Account in Xcode preferences.

---