Hi,

Maybe you can consider setting the available pins through a tango property and then create pin attribute dynamically.

Dynamic attributes are created through initialize_dynamic_attributes function. This function is call after the init_device method.

Here a small example (not tested):

      pins = device_property(dtype=(int,)) 
                                                               
      def initialize_dynamic_attributes(self):                                     
          for pin_number in self.pins:                                             
              # Create attribute name                                              
              voltage_attrname = "pin{}_voltage".format(pin_number)                
              output_attrname = "pin{}_output".format(pin_number)                  
              # Get tango type                                                     
              tango_type = tango.CmdArgType.DevBoolean                             
              # Create attributes                                                  
              voltage_attr = tango.Attr(voltage_attrname,                          
                                        tango_type, tango.READ_WRITE)              
              output_attr = tango.Attr(output_attrname,                            
                                       tango_type, tango.READ_WRITE)               
              # Add attribute and setup read/write/allowed method                  
              self.add_attribute(                                                  
                  voltage_attr,                                                    
                  r_meth=self.read_pin_voltage,                                    
                  w_meth=self.write_pin_voltage,                                   
                  is_allo_meth=self.is_voltage_allowed)                            
              self.add_attribute(                                                  
                  output_attr,                                                     
                  r_meth=self.read_pin_output,                                     
                  w_meth=self.write_pin_output,                                    
                  is_allo_meth=self.is_output_allowed)                             
              # If event needed, setup change event                                
              self.set_change_event(voltage_attrname, True, True)                  
              self.set_change_event(output_attrname, True, True)                   
                                                                                   
      # Voltage                                                                    
                                                                                   
      @catch_connection_error                                                      
      def read_pin_voltage(self, attr):                                            
          attr_name = attr.get_name()                                              
          pin_number = int(filter(str.isdigit, attr_name))                         
          value = self.raspberry.readvoltage(pin_number)                           
          setattr(self, "__pin{}_voltage".format(pin_number), value)               
          attr.set_value(value)                                                    
                                                                                   
      @catch_connection_error                                                      
      def write_pin_voltage(self, attr):                                           
          w_value = attr.get_write_value()                                         
          attr_name = attr.get_name()                                              
          pin_number = int(filter(str.isdigit, attr_name))                         
          python_attr = "__pin_{}_voltage".format(pin_number)                      
          self.set_voltage(w_value, pin_number, getattr(self, python_attr))        
          setattr(self, "_{}".format(attr_name), w_value)                          
                                                                                   
      # Ouptut                                                                     
                                                                                   
      @catch_connection_error                                                      
      def read_pin_output(self, attr):                                             
          attr_name = attr.get_name()                                              
          pin_number = int(filter(str.isdigit, attr_name))                         
          value = self.raspberry.readoutput(pin_number)                            
          setattr(self, "__pin{}_output".format(pin_number), value)                
          attr.set_value(value)                                                    
                                                                                   
      @catch_connection_error                                                      
      def write_pin_output(self, attr):                                            
          w_value = attr.get_write_value()                                         
          attr_name = attr.get_name()                                              
          pin_number = int(filter(str.isdigit, attr_name))                         
          self.raspberry.setoutput(pin_number, w_value)

You can notice that the write methods are slightly different. As attributes are created dynamically, you can not profit of the PyTango hight level API wrapping and you have to set yourself the attribute value (same to get the write value).

Cheers,
/Antoine

More pins for I/O #1

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions