ABS/abscontrol Commit - r233:234 · Jicamarca Repository

imanay -

r233:234

parent child

Context file:

r233:234

trunk/absroot/source/abspy/bin/client3.py +1 -1

             import library3
             import os.path
             class ABSClient(object):
                 def __init__(self,ipSource="192.168.1.117", iDSource="Clnt_01", ipDestino="192.168.1.117", iDDestino = "CeCnMod", portDestino=7000):
                     self.ipSource = ipSource
                     self.iDSource = iDSource
                     self.ipDestino = ipDestino
                     self.iDDestino = iDDestino
                     self.portDestino = portDestino
                     self.createObjects()
                 def createObjects(self):
                     self.commObj = library3.TCPComm(self.ipSource, self.iDSource, self.ipDestino, self.iDDestino, self.portDestino)
                     #self.wFiles = library3.FilesStuff()
                 def __ConnectionWithCentralControl(self, cmd, data):
                     self.commObj.open_socket()
                     self.commObj.sendData(cmd = cmd, data = data, ipDestino = self.ipDestino)
                     ipSource, ipDestino, cmd, output = self.commObj.waitData()
                     self.commObj.close_socket()
                     return output
             #    def abs2ControlModuleFormatFile(self, filename):
             #
             #        #From matriz to control module format
             #        self.wFiles.toCentralControlFormat(filename)
             #        FileName = "CentralControlFormat.txt"
             #        F_Obj = open(FileName,"r")
             #        FileList = F_Obj.readlines()
             #        F_Obj.close()
             #        FileStr = "".join(FileList)
             #
             #        return FileStr
                 def sendFile(self, filename):
                     data = self.__readFile(filename)
                     answer = self.__ConnectionWithCentralControl(cmd = "SNDF", data = data)
                     return answer
-                def readFile(self, filename):
+                def readFile(self):
                     data = "optional"
                     file = self.__ConnectionWithCentralControl(cmd = "GETF", data = data)
                     return file
                 def changeBeam(self, newBeam):
                     answer = self.__ConnectionWithCentralControl(cmd = "CHGB", data = newBeam)
                     return answer
                 def __writeFile(self, filename, data):
                     fobj = open(filename,"w")
                     fobj.writelines(data)
                     fobj.close()
                 def __readFile(self, filename):
                     fobj = open(filename,"r")
                     listData = fobj.readlines()
                     fobj.close()
                     tmp = "".join(listData)
                     #Adding filename to the begining of the data
                     newfilename = os.path.split(filename)[1]
                     #data = filename + '\n' + tmp
                     data = newfilename + '\n' + tmp
                     return data
                 def getControlModuleStatus(self, data):
                     bits = self.__ConnectionWithCentralControl(cmd = "ANST", data = data)
                     #self.__writeFile("report.txt", data)
                     print "Report:\n"
                     print "======:\n"
                     print bits
                 def getControlModulePhase(self, opt, u = "50", pw = "10"):
                     if opt == '0':
                         data = self.__ConnectionWithCentralControl(cmd = "LWPH", data = u + '/' + pw + '/')
                     elif opt ==  '1':
                         data = self.__ConnectionWithCentralControl(cmd = "BGPH", data = u + '/' + pw + '/')
                     elif opt == '2':
                         data = self.__ConnectionWithCentralControl(cmd = "cBPH", data = u + '/' + pw + '/')
                     else:
                         data = self.__ConnectionWithCentralControl(cmd = "cLPH", data = u + '/' + pw + '/')
             #        self.__writeFile("report.txt", data)
                 def getConnectionStatus(self):
                     data = self.__ConnectionWithCentralControl(cmd = "NTST", data = "none")
                     self.__writeFile("connection_status.txt", data)
             if __name__ == '__main__':
                 filename = "experimento1.abs"
                 absObj = ABSClient()
                 print absObj.sendFile(filename)

trunk/absroot/source/abspy/bin/server3.py +3 -1

             import os
             import library3
             import time
             from threading import Thread
             import threading
             import Queue
             class ABSServer:
                 def __init__(self,ipSource="localhost", ipDestino="192.168.1.117", portDestino=7000, ipDestino2="192.168.1.11", portDestino2=5500, rx_buffer = "default"):
                     self.ipSource = ipSource
                     self.ipDestino = ipDestino
                     self.portDestino = portDestino
                     self.ipDestino2 = ipDestino2
                     self.portDestino2 = portDestino2
                     self.tx_buffer = "default"
                     self.rx_buffer = rx_buffer
                     self.enaModules = []
                     self.bits = []
                     self.phase = []
                     self.txFile = []
                     self.rxFile = []
                     self.createObjects()
                     print "Checking control modules, please wait ..."
                     self.enaModules = self.checkAntenna()
                     print '\nThis modules are present : ' +  str(self.enaModules) + '\n'
             #        print "Starting automatic control module status."
                     self.__StartingAutomaticControlModules()
             #        self.__AutomaticControlModules()
                 def createObjects(self):
                     asServer = True
                     self.commServerObj = library3.TCPComm("Central_Control", "CeCnMod", self.ipDestino, "CnMod01", self.portDestino, asServer)
                     self.commClientObj = library3.TCPComm("Central_Control", "CeCnMod", self.ipDestino2, "CnMod01", self.portDestino2)
                     self.wFiles = library3.FilesStuff()
                 def waitRequest(self):
                     #Using rx buffer
             #        ipSource, ipDestino, cmd, self.rx_buffer = self.commServerObj.waitData()
                     ipSource, ipDestino, cmd, rx_buffer = self.commServerObj.waitData()
                     if cmd == "SNDF":
                         datarpta = self.__sendFile2Modules(cmd = cmd, rx_buffer = rx_buffer)
                     if cmd == "GETF":
                         datarpta = self.__getFileFromModules(cmd = cmd, rx_buffer = rx_buffer)
                     if cmd == "CHGB":
                         datarpta = self.__changeBeam(cmd = cmd, rx_buffer = rx_buffer)
                     if cmd == "ANST":
                         datarpta = self.__getControlModuleStatus_old(cmd = cmd, rx_buffer = rx_buffer)
                     if cmd == "BGPH":
                         datarpta = self.__getControlModuleBigPhase(cmd = cmd, rx_buffer = rx_buffer)
                     if cmd == "LWPH":
                         datarpta = self.__getControlModuleLowPhase(cmd = cmd, rx_buffer = rx_buffer)
                     if cmd == "NTST":
                         datarpta = self.__getConnectionStatus(cmd = cmd, rx_buffer = rx_buffer)
                     self.commServerObj.sendData(cmd=cmd, data=datarpta, ipDestino = ipSource)
                 def __checkModule(self, address):
                     cmd = "ping -c 1 -w 1 192.168.1."+ str(address) + " >> /dev/null"
                     status = os.system(cmd)
                     if status == 256:
                         return False
                     return True
                 def __writeReport(self, enaModules):
                     status_array = ["Status of modules\n"]
                     status_array.append("----------------\n")
                     for address in range(1,65):
                         if address in enaModules:
                             status_array.append("192.168.1." + str(address) + " [1 1]\n")
                         else:
                             status_array.append("192.168.1." + str(address) + " [0 0]\n")
                     filename = "module_status.txt"
                     self.__writeFile(filename,status_array)
             #        f = open("module_status.txt","w")
             #        f.writelines(status_array)
             #        f.close()
                 def __CreateFile(self, filename):
                     fobj = open(filename,"w")
                     fobj.close()
                 def __writeNewFile(self, filename, data):
                     fobj = open(filename,"w")
                     fobj.writelines(data)
                     fobj.close()
                 def __writeFile(self, filename, data):
                     fobj = open(filename,"a")
                     fobj.writelines(data)
                     fobj.close()
                 def __checkAntenna(self):
                     """
                     Direccion de los modulos de las antenas:
                         Norte    :    01-16
                         Este     :    17-32
                         Oeste:   :    33-48
                         Sur      :    49-64
                     """
                     enaModules2 = []
                     for address in range(1,65):
                         if self.checkModule(address):
                             enaModules2.append(address)
                     self.__writeReport(enaModules2)
                     return  enaModules2
                 def checkModule(self, arg, queue):
                     cmd = "ping -c 1 -w 1 192.168.1."+ str(arg) + " >> /dev/null"
                     status = os.system(cmd)
                     if status == 256:
                         result = "failed"
                     else:
                         result = "ok"
                     queue.put({arg: result})
                 def checkAntenna(self):
                     iD = range(1,65)
                     q = Queue.Queue()
                     threads = []
                     tOut = []
                     modules = []
                     for argument in iD:
                         t = Thread(target=self.checkModule, args=(argument, q))
                         t.start()
                         threads.append(t)
                     for t in threads:
                         t.join()
                     for _ in range(len(iD)):
                         tOut.append(q.get())
                     for i in tOut:
                         if i.values()[0] == 'ok':
                             modules.append(i.keys()[0])
                     return modules
                 def __ConnectionWithControlModules(self,data,cmd,id):
                     self.commClientObj.open_socket()
                     ip = "192.168.1." + str(id)
                     self.commClientObj.sendData(cmd, data, ip)
                     ipSource, ipDestino, cmd, tmp = self.commClientObj.waitData()
                     self.commClientObj.close_socket()
                     return tmp
                 def abs2ControlModuleFormatFile(self, filename):
                     #From matriz to control module format
                     self.wFiles.toCentralControlFormat(filename)
                     FileName = "CentralControlFormat.txt"
                     F_Obj = open(FileName,"r")
                     FileList = F_Obj.readlines()
                     F_Obj.close()
                     FileStr = "".join(FileList)
                     return FileStr
                 def __All2Blocks(self,input):
                     rx_frame_lst = input.split('\n',2)
                     header = rx_frame_lst[0] + "\n"
                     control_modules_str = rx_frame_lst[2]
                     control_modules_lst = control_modules_str.split("------\n")
                     return  header, control_modules_lst
                 def __sendFile2Modules(self,cmd, rx_buffer):
             #        rx_buffer_lst = self.rx_buffer.split('\n',1)
                     rx_buffer_lst = rx_buffer.split('\n',1)
                     #Getting the filename from the begining of data
                     filename = rx_buffer_lst[0]
                     tmp = rx_buffer_lst[1]
                     self.__writeFile(filename,tmp)
                     data = self.abs2ControlModuleFormatFile(filename)
                     #Needed for the loop
                     header, control_modules_lst = self.__All2Blocks(data)
                     correct = 0
                     for id in range(1,65):
                         if id not in self.enaModules:
                             continue
                         if self.__ConnectionWithControlModules(header + control_modules_lst[id-1], cmd, id) == "OK":
                             correct = correct + 1
                     if correct == len(self.enaModules):
                         rpta = "OK"
                     else:
                         rpta = "Failure"
                     return rpta
                 def __getFileFromModules(self, cmd, rx_buffer):
                     for id in range(1,65):
                         if id not in self.enaModules:
                             continue
                         file = self.__ConnectionWithControlModules(rx_buffer,cmd,id)
                         del self.rxFile[id-1]
                         self.rxFile.insert(id-1, file)
+                        return self.rxFile
                 def __changeBeam(self, cmd, rx_buffer):
                     correct = 0
             #        enaModules = self.checkAntenna()
             #        enaModules = [11,12,13,14]
                     for id in range(1,65):
                         if id not in self.enaModules:
                             continue
                         if self.__ConnectionWithControlModules(rx_buffer,cmd,id) == "OK":
                             correct = correct + 1
                     if correct == len(self.enaModules):
                         rpta = "OK"
                     else:
                         rpta = "Failure"
                     return rpta
                 def __getControlModuleStatus(self, cmd, rx_buffer):
             #        all_blocks = ""
             #        all_blocks = []
             #        enaModules = self.checkAntenna()
             #        enaModules = [11,12,13,14]
                     for id in range(1,65):
                         if id not in self.enaModules:
                             continue
                         bits = self.__ConnectionWithControlModules(rx_buffer,cmd,id)
                         del self.bits[id-1]
                         self.bits.insert(id-1, bits)
             #            all_blocks.append(one_block)
                     #Using tx buffer
                     return self.bits
                 def __getControlModuleBigPhase(self, cmd, rx_buffer):
             #        all_blocks = ""
                     all_blocks = []
             #        enaModules = self.checkAntenna()
             #        enaModules = [11,12,13,14]
                     for id in range(1,65):
                         if id not in self.enaModules:
                             continue
                         one_block = self.__ConnectionWithControlModules(rx_buffer,cmd,id)
             #            all_blocks = all_blocks + one_block
                         all_blocks.append(one_block)
                     #Using tx buffer
                     return all_blocks
                 def __getControlModuleLowPhase(self, cmd, rx_buffer):
             #        all_blocks = ""
             #        all_blocks = []
             #        enaModules = self.checkAntenna()
             #        enaModules = [11,12,13,14]
                     for id in range(1,65):
                         if id not in self.enaModules:
                             continue
                         phase = self.__ConnectionWithControlModules(rx_buffer,cmd,id)
                         del self.phase[id-1]
                         self.phase.insert(id-1, phase)
             #            all_blocks = all_blocks + one_block
             #            all_blocks.append(one_block)
                     #Using tx buffer
             #        return all_blocks
                 def __getConnectionStatus(self, cmd, rx_buffer):
                     ena = self.checkAntenna()
                     print ena
                     self.enaModules = ena
                     blockLst = []
                     for id in range(1,65):
                         if id not in self.enaModules:
                             continue
                         blockStr = self.__ConnectionWithControlModules(rx_buffer,cmd,id)
                         blockLst.append(blockStr + ", 192.168.1." + str(id) + "\n")
                     #Using tx buffer
                     all_blocks = "".join(blockLst)
                     return all_blocks
                 def getConnectionStatus(self, cmd):
                     ena = self.checkAntenna()
                     self.enaModules = ena
                     blockLst = []
                     for id in range(1,65):
                         if id not in self.enaModules:
                             continue
                         blockStr = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
                         blockLst.append(blockStr + ", 192.168.1." + str(id) + "\n")
                     #Using tx buffer
                     self.tx_buffer = "".join(blockLst)
                     print self.tx_buffer
                     return  self.tx_buffer
                 def __getControlModuleStatus_old(self, cmd, rx_buffer):
                     all_blocks = ""
             #        enaModules = self.checkAntenna()
             #        enaModules = [11,12,13,14]
                     for id in range(1,65):
                         if id not in self.enaModules:
                             continue
                         one_block = self.__ConnectionWithControlModules(rx_buffer,cmd,id)
                         all_blocks = all_blocks + one_block
                     #Using tx buffer
                     print all_blocks
                     self.tx_buffer = all_blocks
                     return all_blocks
                 def __StartingAutomaticControlModules(self):
                     #Starting file
                     self.__CreateFile("Monitoring.txt")
             #        data = "MOD.\t BITS\t\t   PHASE\n"
             #        self.__writeFile("Monitoring.txt", data)
                     #Starting lists
                     self.txFile = list("------\n------\n------\n" for i in range(64))
                     self.rxFile = list("------\n------\n------\n" for i in range(64))
                     self.bits = list("------\n------\n------\n" for i in range(64))
                     self.phase = list("----- -----\n----- -----\n----- -----\n" for i in range(64))
                 def __AutomaticControlModules(self):
             #        cmd = "GETF"
             #        rx_buffer = "experimento1.ab1" + "\n"
             #        self.__getFileFromModules(cmd = cmd, rx_buffer = rx_buffer)
             #
             #        print self.rxFile
                     cmd = "ANST"
                     rx_buffer = "1"
                     self.__getControlModuleStatus(cmd = cmd, rx_buffer = rx_buffer)
                     cmd = "LWPH"
                     rx_buffer = "0"
                     self.__getControlModuleLowPhase(cmd = cmd, rx_buffer = rx_buffer)
                     print  "Saving file..."
                     print self.bits
                     print self.phase
                     self.__WritingMonitoringFile()
                     threading.Timer(60, self.__AutomaticControlModules).start()
                 def __WritingMonitoringFile(self):
                     filename = "Monitoring.txt"
                     data = '===============================' + '\n'
                     self.__writeFile(filename, data)
                     data = time.strftime('\t' + "%d%b%Y %I:%M:%S %p" + '\n', time.localtime())
                     self.__writeFile(filename, data)
                     data = "MOD.\t BITS\t\t   PHASE\n"
                     self.__writeFile(filename, data)
                     data = '===============================' + '\n'
                     self.__writeFile(filename, data)
                     for i in range(64):
                         tmp = self.bits[i].split('\n',3)
                         self.__writeFile(filename, ' ' + str(i + 1) + '\t\t' + tmp[2])
                         tmp = self.phase[i].split('\n',3)
                         self.__writeFile(filename, '\t\t' +  tmp[2] + '\n')
             if __name__ == '__main__':
                 absObj = ABSServer()
                 while 1:
                     absObj.waitRequest()

trunk/absroot/source/abspy/scripts/readFile.py +6 -17

             import optparse, os, sys
             pathFile = os.path.dirname(os.path.abspath(__file__))
             sys.path.append(os.path.split(pathFile)[0])
             from bin.client3 import ABSClient
             class readFile(object):
                 def __init__(self):
                     self.output = ""
-                def execute(self, filename):
+                def execute(self):
-                    if os.path.exists(filename):
+                    absObj = ABSClient(ipDestino="10.10.20.27")
-            	    #absObj = ABSClient(ipDestino="10.10.10.97")
+                    self.output = absObj.readFile()
-                        absObj = ABSClient(ipDestino="10.10.20.27")
-                        self.output = absObj.readFile(filename)
-                        #pass
-                    else:
-                        print "No file"
                 def getOutput(self):
                     return self.output
             usage = "::::::::::::\n"
             if __name__ == '__main__':
-                parser = optparse.OptionParser(usage=usage)
+                app = readFile()
+                app.execute()
-                parser.add_option("-f", "--filename", dest="filename", type="string", default="", help="Filename")
-                (options, args) = parser.parse_args()
+                print app.output
-                filename = options.filename
-                app = readFile()
-                app.execute(filename)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages