GSR_debugging.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import serial\n",
    "import struct\n",
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "GET_SAMPLING_RATE_COMMAND = 0x03\n",
    "SAMPLING_RATE_RESPONSE = 0x04\n",
    "ACK_COMMAND_PROCESSED = 0xFF\n",
    "STOP_STREAMING_COMMAND = 0x20\n",
    "START_STREAMING_COMMAND = 0x07"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For every packet that the Shimmer3 receives, it sends an acknowledgement message\n",
    "# (ACK_COMMAND_PROCESSED) back to the host, to acknowledge receipt of the command.\n",
    "def wait_for_ack():\n",
    "    \"\"\"Wait for acknowledgement bit from device.\n",
    "\n",
    "    Keyword arguments:\n",
    "    ser -- serial port\n",
    "    \"\"\"\n",
    "    ddata = \"\"\n",
    "    ack = struct.pack('B', ACK_COMMAND_PROCESSED) # pack the given Python values according to the given format. 'B' means unsigned byte, the value passed to struct.pack() should be interpreted as an unsigned byte (8bits)\n",
    "    # it packs the hexadeicmal value '0xff' into an unsigned btyes.\n",
    "    while ddata != ack:\n",
    "        ddata = ser.read(1)\n",
    "        print((\"received [%s]\" % struct.unpack('B', ddata)))\n",
    "        return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def accel_calc(data):\n",
    "    \"\"\"Calculate m/s^2 values of accelerometer from raw output.\n",
    "\n",
    "    Keyword arguments:\n",
    "    data -- raw data from device\n",
    "    \"\"\"\n",
    "    value = (data - 2047) * float(1) / float(830) * float(9.80665)\n",
    "    return value\n",
    "\n",
    "def gyro_calc(data):\n",
    "    \"\"\"Calculate deg/s values of gyroscope from raw output.\n",
    "\n",
    "    Keyword arguments:\n",
    "    data -- raw data from device\n",
    "    \"\"\"\n",
    "    value = data / float(65.5)\n",
    "    return value\n",
    "\n",
    "def mag_calc_xy(data):\n",
    "    \"\"\"Calculate gauss values of magnometer from raw output, X and Y.\n",
    "\n",
    "    Keyword arguments:\n",
    "    data -- raw data from device\n",
    "    \"\"\"\n",
    "    value = data / float(1100)\n",
    "    return value\n",
    "\n",
    "def mag_calc_z(data):\n",
    "    \"\"\"Calculate gauss values of magnometer from raw output, Z.\n",
    "\n",
    "    Keyword arguments:\n",
    "    data -- raw data from device\n",
    "    \"\"\"\n",
    "    value = data / float(980)\n",
    "    return value\n",
    "\n",
    "def gsr_calc(data):\n",
    "    \"\"\"Calculate gsr value.\n",
    "\n",
    "    Keyword arguments:\n",
    "    data -- raw data from device\n",
    "    \"\"\"\n",
    "    if (gsr.gsrrange == 0):\n",
    "        p1 = 0.0363\n",
    "        p2 = -24.8617\n",
    "    if (gsr.gsrrange == 1):\n",
    "        p1 = 0.0051\n",
    "        p2 = -3.8357\n",
    "    if (gsr.gsrrange == 2):\n",
    "        p1 = 0.0015\n",
    "        p2 = -1.0067\n",
    "    if (gsr.gsrrange == 3):\n",
    "        p1 = 4.4513e-04\n",
    "        p2 = -0.3193\n",
    "    value = (float(p1) * data) + float(p2)\n",
    "    return value\n",
    "\n",
    "\n",
    "def ppg_calc(data):\n",
    "    \"\"\"PLACEHOLDER.\"\"\"\n",
    "    value = data * float(0.00024414062)\n",
    "    return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open Serial Port\n",
    "ser = serial.Serial('/dev/rfcomm3', 115200)\n",
    "ser.flushInput()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stop Streaming\n",
    "ser.write(struct.pack('B', STOP_STREAMING_COMMAND))\n",
    "wait_for_ack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get Sampling Rate\n",
    "# when the Shimmer3 receives the GET_SAMPLING_RATE_COMMAND, it must send the\n",
    "# current value of the sampling rate back to the host; \n",
    "# the response packet will contain two bytes: the first byte will be the SAMPLING_RATE_REPONSE identifier\n",
    "# and the second byte will be the sampling\n",
    "# rate value. \n",
    "ser.write(struct.pack('B', GET_SAMPLING_RATE_COMMAND))\n",
    "wait_for_ack()\n",
    "ddata = ser.read(3)\n",
    "ddata = struct.unpack('<BH', ddata)\n",
    "print('Sampling Rate is: %f' % (32768 / ddata[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start Streaming\n",
    "ser.write(struct.pack('B', 0x07))\n",
    "wait_for_ack()\n",
    "numbytes = 0\n",
    "ddata = b''\n",
    "framesize = 1 + 3 + 2*3 + 2*3 + 2*3 + 7\n",
    "while True:\n",
    "    while numbytes < framesize:\n",
    "        ddata += ser.read(framesize)\n",
    "        numbytes = len(ddata)\n",
    "\n",
    "    data = ddata[0:framesize]\n",
    "    numbytes = 0\n",
    "    ddata = b''\n",
    "\n",
    "    (packettype) = struct.unpack('B', data[0:1]) #[0]\n",
    "\n",
    "    (lin_acc_raw_x, lin_acc_raw_y, lin_acc_raw_z) = struct.unpack('HHH', data[4:10])\n",
    "    lin_acc_cal_x = accel_calc(lin_acc_raw_x)\n",
    "    lin_acc_cal_y = accel_calc(lin_acc_raw_y)\n",
    "    lin_acc_cal_z = accel_calc(lin_acc_raw_z)\n",
    "    \n",
    "    (ang_vel_raw_x, ang_vel_raw_y, ang_vel_raw_z) = struct.unpack('>hhh', data[10:16])\n",
    "    ang_vel_cal_x = gyro_calc(ang_vel_raw_x)\n",
    "    ang_vel_cal_y = gyro_calc(ang_vel_raw_y)\n",
    "    ang_vel_cal_z = gyro_calc(ang_vel_raw_z)\n",
    "\n",
    "    (mag_fld_raw_x, mag_fld_raw_z, mag_fld_raw_y) = struct.unpack('>hhh', data[16:22])\n",
    "    mag_fld_cal_x = mag_calc_xy(mag_fld_raw_x)\n",
    "    mag_fld_cal_y = mag_calc_xy(mag_fld_raw_y)\n",
    "    mag_fld_cal_z = mag_calc_z(mag_fld_raw_z)\n",
    "\n",
    "    emg_ch1_raw = struct.unpack('>i', (data[23:26] + b'\\0'))[0] >> 8\n",
    "    emg_ch2_raw = struct.unpack('>i', (data[26:29] + b'\\0'))[0] >> 8\n",
    "\n",
    "    emg_ch1_cal = emg_calc(emg_ch1_raw)\n",
    "    emg_ch2_cal = emg_calc(emg_ch2_raw)  \n",
    "\n",
    "    print(lin_acc_cal_x)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#framesize = 1 + 3 + 3 * 2\n",
    "\n",
    "#prev_time = datetime.datetime.now()\n",
    "#while True:\n",
    "#    ddata = b''\n",
    "#    numbytes = 0\n",
    "#    read = True\n",
    "#    while read == True:\n",
    "#        flag = ser.read(1)\n",
    "#        flag = struct.unpack('B', flag)\n",
    "#        if flag[0] == 0:\n",
    "#            ddata += ser.read(framesize-1)\n",
    "##            read = False\n",
    "#    current_time = datetime.datetime.now()\n",
    "#    print(current_time - prev_time)\n",
    "#    prev_time = current_time\n",
    "    # (accel_x, accel_y, accel_z) = struct.unpack('HHH', ddata[3:9])\n",
    "    # accel_y_cal = accel_calc(accel_y)\n",
    "    # print(accel_y_cal)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}