def read_special_function_2_pulse_frequency_counter_with_debounce( self, timer): """ Reads module's settings and constructs a human readable string containing the settings read. :param timer: timer to be read, integer. :return: string """ response = self.read_registers({0: 1100, 1: 1200}[timer], 12) pulse_count = utils.int16_to_int32(response[4:6]) frequency = utils.int16_to_int32(response[6:8]) return { "Function": "2 = Pulse/Frequency Counter w/ Debounce".format( response, pulse_count, frequency), "Arm/Disarm": "{0[1]}".format(response, pulse_count, frequency), "Function Status": "{0[2]}".format(response, pulse_count, frequency), "Alarm Status": "{0[3]}".format(response, pulse_count, frequency), "Pulse Count": "{1}".format(response, pulse_count, frequency), "Frequency": "{2}".format(response, pulse_count, frequency), "Internal Trigger": "{0[8]}".format(response, pulse_count, frequency), "Debounce Output Enable": "{0[9]}".format(response, pulse_count, frequency), "Low Time (x 100us)": "{0[10]}".format(response, pulse_count, frequency), "High Time (x 100us)": "{0[11]}".format(response, pulse_count, frequency) }
def read_special_function_1_pulse_frequency_counter(self, timer): """ Reads module's settings and constructs a human readable string containing the settings read. :param timer: timer to be read, integer. :return: string """ response = self.read_registers({0: 1100, 1: 1200}[timer], 13) pulse_count = utils.int16_to_int32(response[4:6]) frequency = utils.int16_to_int32(response[6:8]) return { "Function": "1 = Pulse/Frequency Counter".format(response, pulse_count, frequency), "Arm/Disarm": "{0[1]}".format(response, pulse_count, frequency), "Function Status": "{0[2]}".format(response, pulse_count, frequency), "Alarm_Status": "{0[3]}".format(response, pulse_count, frequency), "Pulse_Count": "{1}".format(response, pulse_count, frequency), "Frequency": "{2}".format(response, pulse_count, frequency), "RPM": "{0[8]}".format(response, pulse_count, frequency), "Pulses Per Revolution": "{0[9]}".format(response, pulse_count, frequency), "Internal Trigger": "{0[10]}".format(response, pulse_count, frequency), "External Enable": "{0[11]}".format(response, pulse_count, frequency), "External Enable Status": "{0[12]}".format(response, pulse_count, frequency) }
def read_special_function_6_pwm_generator(self, timer): """ Reads module's settings and constructs a human readable string containing the settings read. :param timer: timer to be read, integer. :return: string """ response = self.read_registers({0: 1100, 1: 1200}[timer], 12) period = utils.int16_to_int32(response[6:8]) output_1_low_time = utils.int16_to_int32(response[8:10]) output_2_low_time = utils.int16_to_int32(response[10:12]) return "Function : 6 = PWM Generator\n" \ "Arm/Disarm : {0[1]}\n" \ "Timebase : {0[3]}\n" \ "Output 2 Enable : {0[4]}\n" \ "Period : {1}\n" \ "Output 1 Low Time: {2}\n" \ "Output 2 Low Time: {3}\n".format(response, period, output_1_low_time, output_2_low_time)
def read_special_function_4_time_between_events(self, timer): """ Reads module's settings and constructs a human readable string containing the settings read. :param timer: timer to be read, integer. :return: string """ response = self.read_registers({0: 1100, 1: 1200}[timer], 22) events_measured = utils.int16_to_int32(response[4:6]) frequency = utils.int16_to_int32(response[6:8]) time_between_events_curr = utils.int16_to_int32(response[8:10]) time_between_events_max = utils.int16_to_int32(response[10:12]) time_between_events_min = utils.int16_to_int32(response[12:14]) time_between_events_average = utils.int16_to_int32(response[14:16]) events_to_measure = utils.int16_to_int32(response[20:22]) return "Function : 4 = Time Between Events\n" \ "Arm/Disarm : {0[1]}\n" \ "Function Status : {0[2]}\n" \ "Alarm Status : {0[3]}\n" \ "Events Measured : {1}\n" \ "Frequency : {2}\n" \ "Time Between Events, current: {3}\n" \ "Time Between Events, max : {4}\n" \ "Time Between Events, min : {5}\n" \ "Time Between Events, average: {6}\n" \ "Timebase : {0[16]}\n" \ "Event 1 Internal Trigger : {0[17]}\n" \ "Event 2 Internal Trigger : {0[18]}\n" \ "Average Weight : {0[19]}\n" \ "Events to measure : {7}\n".format(response, events_measured, frequency, time_between_events_curr, time_between_events_max, time_between_events_min, time_between_events_average, events_to_measure)
def read_special_function_5_frequency_generator(self, timer): """ Reads module's settings and constructs a human readable string containing the settings read. :param timer: timer to be read, integer. :return: string """ response = self.read_registers({0: 1100, 1: 1200}[timer], 22) frequency = utils.int16_to_int32(response[4:6]) return "Function : 5 = Frequency Generator\n" \ "Arm/Disarm : {0[1]}\n" \ "Frequency : {1}\n".format(response, frequency)
def read_special_function_7_one_shot_pulse_generator(self, timer): """ Reads module's settings and constructs a human readable string containing the settings read. :param timer: timer to be read, integer. :return: string """ response = self.read_registers({0: 1100, 1: 1200}[timer], 16) pulse_count = utils.int16_to_int32(response[4:6]) pulse_count_limit = utils.int16_to_int32(response[6:8]) pulse_width = utils.int16_to_int32(response[10:12]) pre_delay = utils.int16_to_int32(response[12:14]) post_delay = utils.int16_to_int32(response[14:16]) return "Function : 7 = One-Shot Pulse Generator\n" \ "Arm/Disarm : {0[1]}\n" \ "Timebase : {0[3]}\n" \ "Pulse Count : {1}\n" \ "Pulse Count Limit : {2}\n" \ "Output Pulse Polarity: {0[8]}\n" \ "Trigger : {0[9]}\n" \ "Pulse Width : {3}\n" \ "Pre-delay : {4}\n" \ "Post-delay : {5}\n".format(response, pulse_count, pulse_count_limit, pulse_width, pre_delay, post_delay)
""" Example of how to use the utilities module in the MAQ20 API when reading and writing directly to registers. """ from maq20 import MAQ20 import maq20.utilities as utils maq20 = MAQ20(ip_address="192.168.128.100", port=502) com = maq20.get_com() # get a reference to the COM module in the MAQ20 system # The name of a module is stored in the first 15 registers name_raw = com.read_registers(0, 15) name = utils.response_to_string( com.read_registers(address=0, number_of_registers=11)) print('Raw name: {}'.format(name_raw)) print('utils.response_to_string(name_raw) : {}'.format(name)) print('') # new line # Writing a number bigger than 16 bits: 2^16-1 = 65535 com.write_registers(address=1368, values=utils.int32_to_int16s(987134)) # Reading a number bigger than 16 bits: read_back = utils.int16_to_int32( com.read_registers(address=1368, number_of_registers=2)) print('Wrote 32 bit number 987134 and we read: {}'.format(read_back))
def read_special_function_3_waveform_measurement(self, timer): """ Reads module's settings and constructs a human readable string containing the settings read. :param timer: timer to be read, integer. :return: string """ response = self.read_registers({0: 1100, 1: 1200}[timer], 35) events_measured = utils.int16_to_int32(response[4:6]) frequency = utils.int16_to_int32(response[6:8]) period = utils.int16_to_int32(response[10:12]) low_time = utils.int16_to_int32(response[12:14]) high_time = utils.int16_to_int32(response[14:16]) avg_low_time = utils.int16_to_int32(response[16:18]) avg_high_time = utils.int16_to_int32(response[18:20]) max_low_time = utils.int16_to_int32(response[20:22]) min_low_time = utils.int16_to_int32(response[22:24]) max_high_time = utils.int16_to_int32(response[24:26]) min_high_time = utils.int16_to_int32(response[26:28]) events_to_measure = utils.int16_to_int32(response[32:34]) return "Function : 3 = Waveform Measurement\n" \ "Arm/Disarm : {0[1]}\n" \ "Function Status : {0[2]}\n" \ "Alarm Status : {0[3]}\n" \ "Events Measured : {1}\n" \ "Frequency : {2}\n" \ "Duty Cycle : {0[8]}\n" \ "Period : {3}\n" \ "Low Time : {4}\n" \ "High Time : {5}\n" \ "Avg Low Time : {6}\n" \ "Avg High Time : {7}\n" \ "Max Low Time : {8}\n" \ "Min Low Time : {9}\n" \ "Max High Time : {10}\n" \ "Min High Time : {11}\n" \ "Timebase : {0[30]}\n" \ "Internal Trigger : {0[31]}\n" \ "Events To Measure: {12}\n" \ "Average Weight : {0[34]}\n".format(response, events_measured, frequency, period, low_time, high_time, avg_low_time, avg_high_time, max_low_time, min_low_time, max_high_time, min_high_time, events_to_measure)
def load_ranges_information(self): """ Loads a module's ranges information into RAM. Ranges are stored in a list of dictionaries that has the keys: "Engineering-FS" "Engineering+FS" "EngineeringUnits" "CountValue-FS" "CountValue+FS" """ # self._load_number_of_ranges() # Ask module how many ranges it has if self._number_of_ranges > 0: try: self._ranges_information = [] for range_num in range(self._number_of_ranges): range_info = self.read_range(range_num) # type: list self._ranges_information.append({ "Engineering-FS": range_info[0] * 10**range_info[4], "Engineering+FS": range_info[2] * 10**range_info[4], "EngineeringUnits": str(chr(range_info[5])) + str(chr(range_info[6])), "CountValue-FS": utils.int16_to_int32(range_info[7:9]), "CountValue+FS": utils.int16_to_int32(range_info[9:11]), }) check = self._ranges_information[-1] passed = self._check_range_validity(check) if not passed: if range_num == 1: # May be Old Module """ Old modules Contain the range information right next to the previous one instead of skipping to 1710+(i*20), where i is the range number. """ del self._ranges_information[-1] for a_range in range(1, self._number_of_ranges): range_info = self.read_registers( 1710 + (a_range * 11), 11) self._ranges_information.append({ "Engineering-FS": range_info[0] * 10**range_info[4], "Engineering+FS": range_info[2] * 10**range_info[4], "EngineeringUnits": str(chr(range_info[5])) + str(chr(range_info[6])), "CountValue-FS": utils.int16_to_int32(range_info[7:9]), "CountValue+FS": utils.int16_to_int32(range_info[9:11]), }) check = self._ranges_information[-1] passed = self._check_range_validity(check) if not passed: break if not passed: raise TypeError("Invalid Range Value") break except Exception as e: pass else: self._number_of_ranges = None self._ranges_information = None # type: list(dict) self._channel_active_ranges = None # type: list