[update] publish data

EliteEIS_parameter_table

@@ -1,9 +0,0 @@
-DC Voltage DC_BIAS
-AC Amplitude AC_AMP
-Frequency Range Max FREQ_START
-Frequency Range Min FREQ_STOP
-Points Per Decades PPD
-Point Spacing SCALE
-Delay DELAY
-Average AVERAGE_NUM
-Current Range RTIA

db_test.py

@@ -0,0 +1,88 @@
+import psycopg2
+import matplotlib.pyplot as plt 
+from scipy import signal
+import numpy as np
+
+# data_spin_histogram
+def histogram_slope(x_data, y_data, slope =0, bins =0, plot =True):
+  if len(x_data)!=len(y_data):
+    print('Scale of x_data and y_data are different.')
+    return False
+  elif bins == 0:
+    bins = round(len(x_data)/2)
+  arr_list = [y_data[i] - slope*x_data[i] for i in range(len(x_data))]
+  cons_max = max(arr_list)
+  cons_min = min(arr_list)
+  hist_range = np.linspace(cons_min, cons_max, bins+1)
+  hist_range_mid = [(hist_range[i]+hist_range[i+1])/2 for i in range(len(hist_range)-1)]
+  hist_range[-1] = hist_range[-1]+1
+  hist_list = [len([j for j in arr_list if j>=hist_range[i] and j<hist_range[i+1]]) for i in range(len(hist_range)-1)]
+  peek_temp_list,_ = signal.find_peaks(hist_list)
+  peek_temp_list = list(peek_temp_list)
+  print(peek_temp_list)
+  # peek_temp_list[0] = list(peek_temp_list[0])
+  if np.sign(np.diff(hist_list))[0] < 0:
+    # print( np.sign(np.diff(hist_list))[0])
+    peek_temp_list = [0] + peek_temp_list
+  if np.sign(np.diff(hist_list))[-1] > 0:
+    # print(np.sign(np.diff(hist_list))[-1])
+    peek_temp_list = peek_temp_list+[len(hist_list)-1]
+    print(peek_temp_list)
+  
+  peek_list = [i for i in peek_temp_list if hist_list[i] >= len(x_data)/bins*3]
+  print(peek_list)
+  results_half = signal.peak_widths(hist_list,peek_list, rel_height=0.8)
+  peak_min,peak_max = [cons_min + (cons_max-cons_min)/bins*j for j in results_half[2]],[cons_min + (cons_max-cons_min)/bins*j for j in results_half[3]]
+  print(peak_min,peak_max)
+  peak_80=[]
+  for i in range(len(peak_min)):
+    peak_filt_list = [j for j in arr_list if j>=peak_min[i] and j<=peak_max[i]]
+    print(np.mean(peak_filt_list))
+    print(len(peak_filt_list))
+    peak_80.append(np.mean(peak_filt_list))
+  
+  print(results_half[2])
+ 
+  print(results_half)
+  plt.plot(peak_80, [hist_list[j] for j in peek_list], "y")
+  if plot:
+    plt.hist(arr_list, bins)
+    plt.plot([hist_range_mid[i] for i in peek_list], [hist_list[j] for j in peek_list], "xb")
+    plt.plot(peak_80, [hist_list[j] for j in peek_list], "xr")
+    # plt.hlines(results_half[1],[ hist_list[int(j)] for j in results_half[2]],[ hist_list[int(j)] for j in results_half[2]], color="g")
+    plt.savefig("histogrim.png")
+  return hist_list, hist_range_mid, peek_list
+
+def run():
+    conn = psycopg2.connect(database="postgres", user="biopro", password="BioProControlBox", host="127.0.0.1", port="5432")
+    cur = conn.cursor()
+    id = 14304
+
+    sql_str = f'select "raw_data" from "recording_data_metas" WHERE id = {id}'
+    cur.execute(sql_str)
+    data = cur.fetchall()[0][0]
+    channel_data = []
+    for i in ['1','2']:
+        channel_data_temp = []
+        for j in data[i]:
+            # print(j)
+            sql_str = f'select "data" from "{i}_recording_data_raws" WHERE id = {j}'
+            cur.execute(sql_str)
+            raw_data = cur.fetchall()[0][0]
+            raw_data = raw_data.replace('"***"',' ').split(" ")
+            channel_data_temp =channel_data_temp + [int(raw_data[k]) for k in range(len(raw_data)) if k%2]
+            # print(len(channel_data_temp))
+        channel_data.append(channel_data_temp)
+    # print(channel_data[1][-1])
+    # print(channel_data[0][:500])
+    plt.plot(channel_data[0],channel_data[1],'o',markersize=2)
+    plt.hlines(1e6,2.4e6,2.6e6,color='g')
+    plt.savefig('test.png')
+    plt.close()
+
+    x_data, y_data ,peek_list = histogram_slope(channel_data[0],channel_data[1],bins = 200)
+    print([y_data[i] for i in peek_list])
+    print(peek_list, channel_data)
+    return channel_data, peek_list
+    # print([y_data])
+

main.py

@@ -5,43 +5,21 @@ import time
 import sys
 import json
 
-from deviceManager import DeviceManager
-from requests import Requests
+# from deviceManager import DeviceManager
+# from requests import Requests
 from mqtt import MqttThread
+from db_test import run 
 
 class Main():
-  def __init__(self, controller_id = 'b8:27:eb:0c:d3:11', mqtt_ip = '192.168.5.53') -> None:
-      self._deviceManager = DeviceManager()
+  def __init__(self, controller_id = 'b8:27:eb:18:f8:cc', mqtt_ip = '192.168.2.1') -> None:
+      # setup mqtt thread
       self._mqttThread = MqttThread(self, controller_id, mqtt_ip, 1883, 'test')
       self._mqttThread.run()
-      
-      self._mqttRequest = Requests(self._mqttThread)
-      self._mqttRequest.get_device()
   
-  def get_device_info_all(self, device: str) -> str:
-    deviceDict = json.loads(device)
-    # until get device info
-    self._deviceManager.set_device(deviceDict)
-
-    # instruction example 1
-    # self._mqttRequest.device_parameter_array_set(self._deviceManager.get_mac_address(), 'BLE_WRITE', '040005')
-    # self._mqttRequest.device_instruction_send(self._deviceManager.get_mac_address(), 'ble_instru_send')
-
-    # instruction example 2
-    # self._mqttRequest.device_parameter_array_set(self._deviceManager.get_mac_address(), 'BLE_WRITE', '01')
-    # self._mqttRequest.device_instruction_send(self._deviceManager.get_mac_address(), 'ble_instru_send')
-    # self._mqttRequest.device_parameter_get(self._deviceManager.get_mac_address(), 'ADC_VALUE_I')
-
-    #instruction example 3
-    self._mqttRequest.device_parameter_set(self._deviceManager.get_mac_address(), 'MODE', 4)
-    self._mqttRequest.device_instruction_send(self._deviceManager.get_mac_address(), 'start')
-  
-  def device_parameter_value(self, data: str) -> None:
-    dataDict = json.loads(data)
-    print(dataDict)
-    if dataDict['data'].get('ADC_VALUE_I') is not None:
-      value = format(dataDict['data']['ADC_VALUE_I'], '040x')
-      print(value)
+  def get_analysis_data(self, input:str):
+      raw_data, peek_list = run()
+      self._mqttThread.publish(raw_data)
+     
 
 if __name__ == '__main__':
     # if len(sys.argv) < 3:

mqtt.py

@@ -50,9 +50,9 @@ class MqttThread():
       self._mqtt_client.loop_start()
 
   def on_connect(self, client: mqtt.Client, user_data, flags, rc: int):
-    topic = self.__controller_ID + '_user'
-    self._mqtt_client.subscribe(self.__controller_ID + '/+/+') 
-    self._mqtt_client.subscribe(self.__controller_ID + '/data_server/device_data_stream/+/+')
+    topic = f'{self.__controller_ID }_data_analysis/#'
+    print('subscribe topic', topic)
+    self._mqtt_client.subscribe(topic)
     self._connected = True
 
   def on_disconnect(self, client: mqtt.Client, user_data, rc):
@@ -63,18 +63,24 @@ class MqttThread():
 
   def publish(self, payload: str, wait_for_ack = False) -> int:
     QoS = 2 if wait_for_ack else 0
-    message_info = self._mqtt_client.publish(self.__controller_ID + '_user', json.dumps(payload), QoS)
-    print(self.__controller_ID + '_user',  payload)
+    topic = f'{self.__controller_ID}/data_analysis'
+    message =  json.dumps(payload)
+    print('publish', topic, message)
+    message_info = self._mqtt_client.publish(topic, message, QoS)
+
     if wait_for_ack:
         print(" > awaiting ACK for {}".format(message_info.mid))
         message_info.wait_for_publish()
         print(" < received ACK for {}".format(message_info.mid))
 
   def on_message(self, client: mqtt.Client, user_data, message):
+      print('on_message', message.topic, message.payload)
       topic = message.topic.split('/')[1]
+      payload = None
+
       try:
         payload = message.payload.decode('utf-8')
-        print(message.topic, payload)
+        # print('callback from', topic, message.topic, payload)
       except:
         print('error')
 

requests.py

@@ -8,8 +8,8 @@ class Requests():
   def get_device(self) -> None:
     self._mqtt_client.publish({ 
       'header': 'get_device_info_all/0' 
-    }, True)
-    return 
+    })
+    return
 
   def device_parameter_array_set(self, device: str, name: str, data: str) -> None:
     dataArray = [0 for i in range(16)]
@@ -51,4 +51,27 @@ class Requests():
       self._mqtt_client.publish({
         'header': 'device_instruction/0',
         'device': device,
-      })
+      })
+    
+  def hardware_scan(self) -> None:
+      self._mqtt_client.publish({
+        'header': 'hardware_scan/0',
+      })
+  
+  def hardware_device(self) -> None:
+    self._mqtt_client.publish({
+      'header': 'hardware_device/0',
+    })
+  
+  def hardware_device_connect(self, device_name, device_address, serial_number) -> None:
+    self._mqtt_client.publish({
+      'header': 'hardware_device_connect/0',
+      'content': {
+        'device_name': device_name,
+        'device_address': self.mac_tuple_to_str(device_address),
+        'serial_number': serial_number
+      }
+    })
+  
+  def mac_tuple_to_str(self, mac_array):
+    return ':'.join('{:02x}'.format(b) for b in mac_array)