The initial commit of the code.

git-svn-id: https://macquarie-observatory-automation.googlecode.com/svn/trunk@5 ba3ad000-c725-3ee3-f0a2-a6f435c0371d

Author: [email protected]

README

@@ -0,0 +1,6 @@
+First run:
+ ./make_command_list labjack_server.py
+Then run:
+ ./labjack_main
+NB Make sure that /usr/bin/python is the correct version of python, or
+alternatively change labjack_main.

command_list.py

@@ -0,0 +1,49 @@
+# Given a list of functions and a list of strings, this program 
+# is designed to find the function matching a given string.
+# As this has to be done in principle when "compiling", the C way
+# to do this is to have a list of functions and a list of strings.
+#
+# Function lists may have to be imported from many places, but
+# within the same global scope. With the "simple server" mentality, 
+# this can be passed a single object that contains the function 
+# definitions, as a single object should be enough to contain all
+# pieces of hardware (which should be 1).
+#
+# The idea is that a single call to:
+# execute_command(command)
+# ... returns a string for successful execution, or a useful string
+#
+# Try: 
+# ./make_command_list dummy_functions.py 
+# import dummy_functions as d
+# import command_list as cl
+# print cl.execute_command("one",d)
+# print cl.execute_command("help",d)
+# print cl.execute_command("oops",d)
+
+import string
+import pydoc
+
+def execute_command(the_command, m):
+    '''Find the_command amongst the list of commands like cmd_one in module m
+    
+    This returns a string containing the response, or a -1 if a quit is commanded.'''
+    the_functions = dict(humidity=m.cmd_humidity,temperature=m.cmd_temperature,ljtemp=m.cmd_ljtemp,status=m.cmd_status,wheel=m.cmd_wheel)
+    commands = string.split(the_command)
+    if len(commands) == 0:
+        return ""
+    if commands[0] == "help":
+        if (len(commands) == 1):
+            return 'humidity\ntemperature\nljtemp\nstatus\nwheel'
+        elif commands[1] in the_functions:
+            td=pydoc.TextDoc()
+            return td.docroutine(the_functions[commands[1]])
+        else:
+            return "ERROR: "+commands[1]+" is not a valid command."
+    elif commands[0] == 'exit' or commands[0] == 'bye' or commands[0] == 'quit':
+        return -1
+    elif commands[0] in the_functions:
+        return the_functions[commands[0]](the_command)
+    else:
+        return "ERROR: Command not found."
+

dummy_functions.py

@@ -0,0 +1,13 @@
+''' This is a module with dummy functions'''
+
+# The first dummy function
+def cmd_one(the_command):
+    '''The first dummy function. 
+    Some extra text about it.'''
+    return "This is function 1"
+
+# The second dummy function
+def cmd_two(the_command):
+    '''The second dummy function. A really long line with some extra text about it.'''
+    return "This is function 2"
+

labjack_server.py

@@ -0,0 +1,115 @@
+#*********************************************************************#
+#                  Code for the labjack server                        #
+#*********************************************************************#
+
+#*********************************************************************#
+#Code the runs on module import starts here.
+#1) Import all modules that we need. NB ei1050 isn't installed by default,
+#   but is in the "examples" directory of the labjack code.
+import string
+import u3
+import ei1050
+
+#***********************************************************************#
+#2) Set up the labjack. As the LJ and LJPROBE are declared in the global
+#   module scope, lets give them capitals. These are initialized, byt
+#   not written to within our module. Two instances of the LabjackServer
+#   would then write to the *same* labjack hardware, but could e.g. 
+#   do different parts of the job. You's almost certainly *not* want to do 
+#   this.
+LJ=u3.U3()
+LJPROBE=ei1050.EI1050(LJ, enablePinNum=0, dataPinNum=1, clockPinNum=2)
+LJ.configIO(NumberOfTimersEnabled = 2)
+LJ.getFeedback(u3.Timer0Config(8), u3.Timer1Config(8))
+
+#***********************************************************************#
+#2) Now define our main class, the LabjackServer.
+class LabjackServer:
+
+#Variables not used yet...
+    dome_status = 'HOME'   
+    slit_status = 'closed'  
+    weather_status = 'NULL' #Needs to come from connection to weather server. Who is the client?
+    
+#Some properties relating to the relative encoder.
+    wheel_pos = 0.0
+    wheel_command = 0
+    wheel_moving = False
+    current_pos = 0 #MJI Doesn't understand the difference between WHEEL_POS, WHEEL_COMMAND and this... Needs comments
+
+#*************************************************************************#
+#All the definitions used are listed here
+
+#definition for weather checking
+    def cmd_humidity(self,the_command):
+        ''' Get the humidity from the E1050 probe '''
+        humidity = LJPROBE.getHumidity()
+        return str(humidity)
+    
+    def cmd_temperature(self,the_command):
+        ''' Get the temperature from the E1050 probe '''
+        temperature = LJPROBE.getTemperature()
+        return str(temperature)
+    
+    def cmd_ljtemp(self,the_command):
+        ''' Get the temperature of the labjack in Kelvin'''
+        temperature = LJ.getTemperature()
+        return str(temperature)
+    
+    def cmd_status(self,the_command):
+        '''Return the status of the entire system.'''
+        return(str(self.wheel_pos))
+    
+    def cmd_wheel(self,the_command):
+        '''Move the wheel'''
+        commands=string.split(the_command)
+        if self.wheel_moving == True: 
+            return "Wheel already moving"
+        elif len(commands) ==1:
+            return "Wheel\'s current position: "+str(self.wheel_pos)+". Wheel NOT moving."
+        else:
+            self.wheel_command = commands[1]
+            self.wheel_moving = True
+            return "Wheel''s current position: "+str(self.wheel_pos)+". Moving Wheel."
+        
+#****** End of user commands *******
+        
+#This is the background job that defines if the wheel is moving.
+    def dome_rotate(self,command):
+        command = float(command)
+        command = command*48   #turns number of turns into number of counts
+        temp = LJ.getFeedback(u3.QuadratureInputTimer())
+        temp2 = temp[-1]
+        temp2 = temp2 - (self.wheel_pos*48)
+        destination = command + self.wheel_pos
+        if command >= 0:
+            if temp2 < command:
+                self.wheel_moving = True
+                temp = LJ.getFeedback(u3.QuadratureInputTimer())
+                self.current_pos = float(temp[-1])
+            else: self.wheel_moving = False
+        elif command < 0:
+            if temp2 > command:
+                self.wheel_moving = True
+                temp = LJ.getFeedback(u3.QuadratureInputTimer())
+                self.current_pos = float(temp[-1])
+            else: self.wheel_moving = False
+        else: 
+            return "ERROR"
+        
+        if self.wheel_moving == False:
+            turns = (self.current_pos/48.0) - self.wheel_pos
+            pos = self.wheel_pos
+            pos = pos + turns
+            self.wheel_pos = pos
+            return turns
+        else: return
+        
+#This will 'move' the wheel if there has been a command which has not yet completed
+#obviously at the moment the wheel is moved manually
+    def wheel_move(self):
+        if self.wheel_moving == True:
+            self.dome_rotate(self.wheel_command)
+                
+
+

make_command_dict

@@ -0,0 +1,9 @@
+#!/bin/bash
+THESTRINGS=$1=m.cmd_$1
+shift
+while [ $# -gt 0 ] 
+do
+ THESTRINGS=${THESTRINGS}','$1=m.cmd_$1
+ shift
+done
+echo ${THESTRINGS}

make_command_list

@@ -0,0 +1,9 @@
+#!/bin/bash
+#Make a list of commands from the python file.
+grep 'def cmd_' $1 | sed 's/def cmd_//g' | sed 's/^[ \t]*//' |cut -d '(' -f1 > command_list.txt
+#Now turn newlines into \n
+sed '{:q;N;s/\n/\\\\n/g;t q}' command_list.txt  > temp.txt
+sed 's/INSERT_COMMAND_LIST/'`cat temp.txt`'/g' command_list.template > temp.txt
+SED_COMMAND='./make_command_dict '`cat command_list.txt`
+sed 's/INSERT_COMMAND_DICT/'`${SED_COMMAND}`'/' temp.txt > command_list.py
+rm temp.txt

server_socket.py

@@ -0,0 +1,109 @@
+# This python object is designed to take as inputs a socket number, a server name
+# and a hardware object, and to do all communication in the same way for all servers.
+
+#*********************************************************************#
+#Code the runs on module import starts here.
+#1) Import all modules that we need. 
+
+import sys
+import string
+import select
+import socket
+from datetime import datetime
+#imports that we wrote
+import command_list as cl
+
+#*************************************************************************#
+#2) Now define our main class, the ServerSocket
+class ServerSocket:
+#Some properties needed by multiple methods.
+	clients=[]
+	jobs=[]
+	def __init__(self, port, hardware_name, hardware_object):
+#Set up the class properties "server", "input", "hardware_name" and "hardware_object"
+		self.hardware_object=hardware_object
+		self.hardware_name=hardware_name
+		IP = ''
+		ADS = (IP, port)
+		self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+#See /usr/include/sus/socket.h
+#SOL_SOCK and SO_REUSE_ADDR. This stops the port from blocking after a crash etc.
+		self.server.setsockopt(0xffff, 0x0004, 1)
+#See /usr/include/netinet/in.h
+#IPPROTO_TCP, TCP_NODELAY. This makes the packet get sent straight away (instead of waiting for extra data 
+#that might arrive).
+		self.server.setsockopt(6, 1, 1)
+		self.server.bind(ADS)
+		self.server.setblocking(0)
+		self.server.listen(5) #will allow 5 clients to connect with server
+		self.input = [self.server, sys.stdin]
+
+#This method deals with the various inputs from stdin and connected clients
+	def socket_funct(self, s):
+		if s == self.server:
+		#handle server socket
+			client, address = self.server.accept()
+			client.setblocking(0)
+			self.input.append(client)
+			self.clients.append(client)
+			self.input[-1].send("Welcome to "+self.hardware_name+"! There are "+str(len(self.clients))+" people connected\n> ")
+			self.log("A client has joined, number of clients connected: "+str(len(self.clients)))
+			return 0
+		elif s == sys.stdin:
+		#handle standard input
+			data = sys.stdin.readline()
+			return data
+		else:
+		#handle all other sockets
+			data = str(s.recv(1024))
+			if data:
+				return data
+			else:
+				s.close()
+				self.input.remove(s)
+				self.clients.remove(s)
+				return 0
+
+#We will use this to log what is happening in a file with a timestamp, but for now, print to screen
+#I should also add something to document which client sent which command
+	def log(self, message):
+		print str(datetime.now())+" "+str(message)
+
+#This closes the connections to the cliente neatly.
+	def close(self):
+		self.server.close
+
+#This medhod adds a new job to the queue.
+	def add_job(self, new_job):
+		self.jobs.append(new_job)
+
+#This method runs the jobs and waits for new input
+	def run(self):
+		self.log("Waiting for connection, number of clients connected: "+str(len(self.clients)))
+		running=True
+		while running:
+			inputready,outputready,exceptready = select.select(self.input,[],[],0)
+		
+			for s in inputready:  #loop through our array of sockets/inputs
+				data = self.socket_funct(s)
+				if data == -1:
+					running=False
+				elif data != 0:
+					response = cl.execute_command(data,self.hardware_object)
+					if response == -1:
+						running=False
+						if s == sys.stdin:
+							self.log("Manually shut down. Goodbye.")
+						else:
+							self.log("Shut down by remote connection. Goodbye.")
+					else:
+						if s==sys.stdin:
+							print response
+						else:
+							s.send(response + '\n> ')
+			for the_job in self.jobs:
+				message=the_job()
+				if message:
+					for i in self.clients:
+						i.send(message)
+