FFI Lib module not found



  • Hi, I'm looking for a library.
    Name: ffi.lib

    for an i2c script I need the module:
    import fcntl # used to access I2C parameters like addresses

    I found this module. but missing if I want to load this ffi

    it always comes the error message the module ffi can not be found.

    I have already installed ffilib. but without success.

    import uio # used to create file streams
    import fcntl # used to access I2C parameters like addresses
    import time # used for sleep delay and timestamps
    import string # helps parse strings

    Traceback (most recent call last):
    File "<stdin>", line 2, in <module>
    ImportError: no module named 'ffi'



  • Thank you for the answer. I want to adapt this raspberrypi script to my Pycom WiPy. but I stuck ... :-(

    #!/usr/bin/python
    
    import io         # used to create file streams
    import fcntl      # used to access I2C parameters like addresses
    
    import time       # used for sleep delay and timestamps
    import string     # helps parse strings
    
    
    class AtlasI2C:
    	long_timeout = 1.5         	# the timeout needed to query readings and calibrations
    	short_timeout = .5         	# timeout for regular commands
    	default_bus = 1         	# the default bus for I2C on the newer Raspberry Pis, certain older boards use bus 0
    	default_address = 98     	# the default address for the sensor
    	current_addr = default_address
    
    	def __init__(self, address=default_address, bus=default_bus):
    		# open two file streams, one for reading and one for writing
    		# the specific I2C channel is selected with bus
    		# it is usually 1, except for older revisions where its 0
    		# wb and rb indicate binary read and write
    		self.file_read = io.open("/dev/i2c-"+str(bus), "rb", buffering=0)
    		self.file_write = io.open("/dev/i2c-"+str(bus), "wb", buffering=0)
    
    		# initializes I2C to either a user specified or default address
    		self.set_i2c_address(address)
    
    	def set_i2c_address(self, addr):
    		# set the I2C communications to the slave specified by the address
    		# The commands for I2C dev using the ioctl functions are specified in
    		# the i2c-dev.h file from i2c-tools
    		I2C_SLAVE = 0x703
    		fcntl.ioctl(self.file_read, I2C_SLAVE, addr)
    		fcntl.ioctl(self.file_write, I2C_SLAVE, addr)
    		self.current_addr = addr
    
    	def write(self, cmd):
    		# appends the null character and sends the string over I2C
    		cmd += "\00"
    		self.file_write.write(cmd)
    
    	def read(self, num_of_bytes=31):
    		# reads a specified number of bytes from I2C, then parses and displays the result
    		res = self.file_read.read(num_of_bytes)         # read from the board
    		response = filter(lambda x: x != '\x00', res)     # remove the null characters to get the response
    		if ord(response[0]) == 1:             # if the response isn't an error
    			# change MSB to 0 for all received characters except the first and get a list of characters
    			char_list = map(lambda x: chr(ord(x) & ~0x80), list(response[1:]))
    			# NOTE: having to change the MSB to 0 is a glitch in the raspberry pi, and you shouldn't have to do this!
    			return "Command succeeded " + ''.join(char_list)     # convert the char list to a string and returns it
    		else:
    			return "Error " + str(ord(response[0]))
    
    	def query(self, string):
    		# write a command to the board, wait the correct timeout, and read the response
    		self.write(string)
    
    		# the read and calibration commands require a longer timeout
    		if((string.upper().startswith("R")) or
    			(string.upper().startswith("CAL"))):
    			time.sleep(self.long_timeout)
    		elif string.upper().startswith("SLEEP"):
    			return "sleep mode"
    		else:
    			time.sleep(self.short_timeout)
    
    		return self.read()
    
    	def close(self):
    		self.file_read.close()
    		self.file_write.close()
    
    	def list_i2c_devices(self):
    		prev_addr = self.current_addr # save the current address so we can restore it after
    		i2c_devices = []
    		for i in range (0,128):
    			try:
    				self.set_i2c_address(i)
    				self.read()
    				i2c_devices.append(i)
    			except IOError:
    				pass
    		self.set_i2c_address(prev_addr) # restore the address we were using
    		return i2c_devices
    
    		
    def main():
    	device = AtlasI2C() 	# creates the I2C port object, specify the address or bus if necessary
    
    	print(">> Atlas Scientific sample code")
    	print(">> Any commands entered are passed to the board via I2C except:")
    	print(">>   List_addr lists the available I2C addresses.")
    	print(">>   Address,xx changes the I2C address the Raspberry Pi communicates with.")
    	print(">>   Poll,xx.x command continuously polls the board every xx.x seconds")
    	print(" where xx.x is longer than the %0.2f second timeout." % AtlasI2C.long_timeout)
    	print(">> Pressing ctrl-c will stop the polling")
    	
    	# main loop
    	while True:
    		input = raw_input("Enter command: ")
    
    		if input.upper().startswith("LIST_ADDR"):
    			devices = device.list_i2c_devices()
    			for i in range(len (devices)):
    				print devices[i]
    
    		# address command lets you change which address the Raspberry Pi will poll
    		elif input.upper().startswith("ADDRESS"):
    			addr = int(string.split(input, ',')[1])
    			device.set_i2c_address(addr)
    			print("I2C address set to " + str(addr))
    
    		# continuous polling command automatically polls the board
    		elif input.upper().startswith("POLL"):
    			delaytime = float(string.split(input, ',')[1])
    
    			# check for polling time being too short, change it to the minimum timeout if too short
    			if delaytime < AtlasI2C.long_timeout:
    				print("Polling time is shorter than timeout, setting polling time to %0.2f" % AtlasI2C.long_timeout)
    				delaytime = AtlasI2C.long_timeout
    
    			# get the information of the board you're polling
    			info = string.split(device.query("I"), ",")[1]
    			print("Polling %s sensor every %0.2f seconds, press ctrl-c to stop polling" % (info, delaytime))
    
    			try:
    				while True:
    					print(device.query("R"))
    					time.sleep(delaytime - AtlasI2C.long_timeout)
    			except KeyboardInterrupt: 		# catches the ctrl-c command, which breaks the loop above
    				print("Continuous polling stopped")
    
    		# if not a special keyword, pass commands straight to board
    		else:
    			if len(input) == 0:
    				print "Please input valid command."
    			else:
    				try:
    					print(device.query(input))
    				except IOError:
    					print("Query failed \n - Address may be invalid, use List_addr command to see available addresses")
    
    
    if __name__ == '__main__':
    	main()
    


  • @svonbentzel ffi is only need on a PC as link between the Python modules and C-lib code. For python scripts on a Pycom module, this is not available and not required. You have to adapt you initial scripts to deal directly with the PyCom hardware, using e.g. the machine.I2C lib for I2C.


 

Hello World?

Pylife on Kickstarter - November 2018








Back Us On Kickstarter >

Pycom on Twitter