##// END OF EJS Templates
ABS » abscontrol
RSS
ABS Monitoring changes
imanay -
r146:147
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,87 +1,94
1 import library3
1 import library3
2
2
3 class ABSClient:
3 class ABSClient:
4
4
5 def __init__(self,ipSource="192.168.1.117", iDSource="Clnt_01", ipDestino="192.168.1.117", iDDestino = "CeCnMod", portDestino=7000):
5 def __init__(self,ipSource="192.168.1.117", iDSource="Clnt_01", ipDestino="192.168.1.117", iDDestino = "CeCnMod", portDestino=7000):
6
6
7 self.ipSource = ipSource
7 self.ipSource = ipSource
8 self.iDSource = iDSource
8 self.iDSource = iDSource
9 self.ipDestino = ipDestino
9 self.ipDestino = ipDestino
10 self.iDDestino = iDDestino
10 self.iDDestino = iDDestino
11 self.portDestino = portDestino
11 self.portDestino = portDestino
12
12
13 self.createObjects()
13 self.createObjects()
14
14
15 def createObjects(self):
15 def createObjects(self):
16
16
17 self.commObj = library3.TCPComm(self.ipSource, self.iDSource, self.ipDestino, self.iDDestino, self.portDestino)
17 self.commObj = library3.TCPComm(self.ipSource, self.iDSource, self.ipDestino, self.iDDestino, self.portDestino)
18 # self.wFiles = library3.FilesStuff()
18 # self.wFiles = library3.FilesStuff()
19
19
20 def __ConnectionWithCentralControl(self, cmd, data):
20 def __ConnectionWithCentralControl(self, cmd, data):
21
21
22 self.commObj.open_socket()
22 self.commObj.open_socket()
23 self.commObj.sendData(cmd = cmd, data = data, ipDestino = self.ipDestino)
23 self.commObj.sendData(cmd = cmd, data = data, ipDestino = self.ipDestino)
24 ipSource, ipDestino, cmd, output = self.commObj.waitData()
24 ipSource, ipDestino, cmd, output = self.commObj.waitData()
25 self.commObj.close_socket()
25 self.commObj.close_socket()
26
26
27 return output
27 return output
28
28
29 # def abs2ControlModuleFormatFile(self, filename):
29 # def abs2ControlModuleFormatFile(self, filename):
30 #
30 #
31 # #From matriz to control module format
31 # #From matriz to control module format
32 # self.wFiles.toCentralControlFormat(filename)
32 # self.wFiles.toCentralControlFormat(filename)
33 # FileName = "CentralControlFormat.txt"
33 # FileName = "CentralControlFormat.txt"
34 # F_Obj = open(FileName,"r")
34 # F_Obj = open(FileName,"r")
35 # FileList = F_Obj.readlines()
35 # FileList = F_Obj.readlines()
36 # F_Obj.close()
36 # F_Obj.close()
37 # FileStr = "".join(FileList)
37 # FileStr = "".join(FileList)
38 #
38 #
39 # return FileStr
39 # return FileStr
40
40
41 def sendFile(self, filename):
41 def sendFile(self, filename):
42
42
43 data = self.__readFile(filename)
43 data = self.__readFile(filename)
44 self.__ConnectionWithCentralControl(cmd = "SNDF", data = data)
44 self.__ConnectionWithCentralControl(cmd = "SNDF", data = data)
45
45
46 def changeBeam(self, newBeam):
46 def changeBeam(self, newBeam):
47
47
48 self.__ConnectionWithCentralControl(cmd = "CHGB", data = newBeam)
48 self.__ConnectionWithCentralControl(cmd = "CHGB", data = newBeam)
49
49
50 def __writeFile(self, filename, data):
50 def __writeFile(self, filename, data):
51
51
52 fobj = open(filename,"w")
52 fobj = open(filename,"w")
53 fobj.writelines(data)
53 fobj.writelines(data)
54 fobj.close()
54 fobj.close()
55
55
56 def __readFile(self, filename):
56 def __readFile(self, filename):
57
57
58 fobj = open(filename,"r")
58 fobj = open(filename,"r")
59 listData = fobj.readlines()
59 listData = fobj.readlines()
60 fobj.close()
60 fobj.close()
61 tmp = "".join(listData)
61 tmp = "".join(listData)
62 #Adding filename to the begining of the data
62 #Adding filename to the begining of the data
63 data = filename + '\n' + tmp
63 data = filename + '\n' + tmp
64 return data
64 return data
65
65
66
66
67 def getControlModuleStatus(self, data):
67 def getControlModuleStatus(self, data):
68
68
69 data = self.__ConnectionWithCentralControl(cmd = "ANST", data = data)
69 data = self.__ConnectionWithCentralControl(cmd = "ANST", data = data)
70 self.__writeFile("report.txt", data)
70 self.__writeFile("report.txt", data)
71
71
72 def getControlModulePhase(self, data):
72 def getControlModulePhase(self, opt, u = "50", pw = "10"):
73
73
74 data = self.__ConnectionWithCentralControl(cmd = "ANPH", data = data)
74 if opt == '0':
75 data = self.__ConnectionWithCentralControl(cmd = "LWPH", data = u + '/' + pw + '/')
76 elif opt == '1':
77 data = self.__ConnectionWithCentralControl(cmd = "BGPH", data = u + '/' + pw + '/')
78 elif opt == '2':
79 data = self.__ConnectionWithCentralControl(cmd = "cBPH", data = u + '/' + pw + '/')
80 else:
81 data = self.__ConnectionWithCentralControl(cmd = "cLPH", data = u + '/' + pw + '/')
75 # self.__writeFile("report.txt", data)
82 # self.__writeFile("report.txt", data)
76
83
77 def getConnectionStatus(self):
84 def getConnectionStatus(self):
78
85
79 data = self.__ConnectionWithCentralControl(cmd = "NTST", data = "none")
86 data = self.__ConnectionWithCentralControl(cmd = "NTST", data = "none")
80 self.__writeFile("connection_status.txt", data)
87 self.__writeFile("connection_status.txt", data)
81
88
82 if __name__ == '__main__':
89 if __name__ == '__main__':
83
90
84 filename = "experimento1.abs"
91 filename = "experimento1.abs"
85
92
86 absObj = ABSClient()
93 absObj = ABSClient()
87 absObj.sendFile(filename)
94 absObj.sendFile(filename)
Show file before | Show file after | Hide comments
@@ -1,290 +1,312
1 import os
1 import os
2 import library3
2 import library3
3 import time
3 import time
4
4
5 class ABSServer:
5 class ABSServer:
6
6
7 def __init__(self,ipSource="localhost", ipDestino="192.168.1.117", portDestino=7000, ipDestino2="192.168.1.11", portDestino2=5500, rx_buffer = "default"):
7 def __init__(self,ipSource="localhost", ipDestino="192.168.1.117", portDestino=7000, ipDestino2="192.168.1.11", portDestino2=5500, rx_buffer = "default"):
8
8
9 self.ipSource = ipSource
9 self.ipSource = ipSource
10 self.ipDestino = ipDestino
10 self.ipDestino = ipDestino
11 self.portDestino = portDestino
11 self.portDestino = portDestino
12
12
13 self.ipDestino2 = ipDestino2
13 self.ipDestino2 = ipDestino2
14 self.portDestino2 = portDestino2
14 self.portDestino2 = portDestino2
15
15
16 self.tx_buffer = "default"
16 self.tx_buffer = "default"
17 # self.rx_buffer = "default"
17 # self.rx_buffer = "default"
18 self.rx_buffer = rx_buffer
18 self.rx_buffer = rx_buffer
19 self.enaModules = []
19 self.enaModules = []
20
20
21 self.createObjects()
21 self.createObjects()
22
22
23 def createObjects(self):
23 def createObjects(self):
24
24
25 asServer = True
25 asServer = True
26 self.commServerObj = library3.TCPComm("Central_Control", "CeCnMod", self.ipDestino, "CnMod01", self.portDestino, asServer)
26 self.commServerObj = library3.TCPComm("Central_Control", "CeCnMod", self.ipDestino, "CnMod01", self.portDestino, asServer)
27 self.commClientObj = library3.TCPComm("Central_Control", "CeCnMod", self.ipDestino2, "CnMod01", self.portDestino2)
27 self.commClientObj = library3.TCPComm("Central_Control", "CeCnMod", self.ipDestino2, "CnMod01", self.portDestino2)
28 self.wFiles = library3.FilesStuff()
28 self.wFiles = library3.FilesStuff()
29
29
30 def waitRequest(self):
30 def waitRequest(self):
31
31
32 #Using rx buffer
32 #Using rx buffer
33 ipSource, ipDestino, cmd, self.rx_buffer = self.commServerObj.waitData()
33 ipSource, ipDestino, cmd, self.rx_buffer = self.commServerObj.waitData()
34
34
35 if cmd == "SNDF":
35 if cmd == "SNDF":
36 datarpta = self.__sendFile2Modules(cmd = cmd)
36 datarpta = self.__sendFile2Modules(cmd = cmd)
37
37
38 if cmd == "CHGB":
38 if cmd == "CHGB":
39 datarpta = self.__changeBeam(cmd = cmd)
39 datarpta = self.__changeBeam(cmd = cmd)
40
40
41 if cmd == "ANST":
41 if cmd == "ANST":
42 self.__getControlModuleStatus(cmd = cmd)
42 self.__getControlModuleStatus(cmd = cmd)
43 #Using tx buffer
43 #Using tx buffer
44 datarpta = self.tx_buffer
44 datarpta = self.tx_buffer
45
45
46 if cmd == "ANPH":
46 if cmd == "BGPH":
47 self.__getControlModulePhase(cmd = cmd)
47 self.__getControlModuleBigPhase(cmd = cmd)
48 #Using tx buffer
48 #Using tx buffer
49 datarpta = self.tx_buffer
49 datarpta = self.tx_buffer
50
50
51 if cmd == "LWPH":
52 self.__getControlModuleLowPhase(cmd = cmd)
53 #Using tx buffer
54 datarpta = self.tx_buffer
55
51 if cmd == "NTST":
56 if cmd == "NTST":
52 #Using tx buffer
57 #Using tx buffer
53 datarpta = self.__getConnectionStatus(cmd = cmd)
58 datarpta = self.__getConnectionStatus(cmd = cmd)
54
59
55 self.commServerObj.sendData(cmd=cmd, data=datarpta, ipDestino = ipSource)
60 self.commServerObj.sendData(cmd=cmd, data=datarpta, ipDestino = ipSource)
56
61
57 def checkModule(self, address):
62 def checkModule(self, address):
58
63
59 cmd = "ping -c 1 -w 1 192.168.1."+ str(address) + " >> /dev/null"
64 cmd = "ping -c 1 -w 1 192.168.1."+ str(address) + " >> /dev/null"
60 status = os.system(cmd)
65 status = os.system(cmd)
61
66
62 if status == 256:
67 if status == 256:
63 return False
68 return False
64
69
65 return True
70 return True
66
71
67 def __writeReport(self, enaModules):
72 def __writeReport(self, enaModules):
68
73
69 status_array = ["Status of modules\n"]
74 status_array = ["Status of modules\n"]
70 status_array.append("----------------\n")
75 status_array.append("----------------\n")
71
76
72 for address in range(1,65):
77 for address in range(1,65):
73 if address in enaModules:
78 if address in enaModules:
74 status_array.append("192.168.1." + str(address) + " [1 1]\n")
79 status_array.append("192.168.1." + str(address) + " [1 1]\n")
75 else:
80 else:
76 status_array.append("192.168.1." + str(address) + " [0 0]\n")
81 status_array.append("192.168.1." + str(address) + " [0 0]\n")
77
82
78 filename = "module_status.txt"
83 filename = "module_status.txt"
79 self.__writeFile(filename,status_array)
84 self.__writeFile(filename,status_array)
80 # f = open("module_status.txt","w")
85 # f = open("module_status.txt","w")
81 # f.writelines(status_array)
86 # f.writelines(status_array)
82 # f.close()
87 # f.close()
83
88
84
89
85 def __writeFile(self, filename, data):
90 def __writeFile(self, filename, data):
86
91
87 fobj = open(filename,"w")
92 fobj = open(filename,"w")
88 fobj.writelines(data)
93 fobj.writelines(data)
89 fobj.close()
94 fobj.close()
90
95
91 def checkAntenna(self):
96 def checkAntenna(self):
92
97
93 """
98 """
94 Direccion de los modulos de las antenas:
99 Direccion de los modulos de las antenas:
95
100
96 Norte : 01-16
101 Norte : 01-16
97 Este : 17-32
102 Este : 17-32
98 Oeste: : 33-48
103 Oeste: : 33-48
99 Sur : 49-64
104 Sur : 49-64
100
105
101 """
106 """
102
107
103 enaModules2 = []
108 enaModules2 = []
104
109
105 for address in range(1,65):
110 for address in range(1,65):
106 if self.checkModule(address):
111 if self.checkModule(address):
107 enaModules2.append(address)
112 enaModules2.append(address)
108
113
109 self.__writeReport(enaModules2)
114 self.__writeReport(enaModules2)
110 return enaModules2
115 return enaModules2
111
116
112 def __ConnectionWithControlModules(self,data,cmd,id):
117 def __ConnectionWithControlModules(self,data,cmd,id):
113
118
114 self.commClientObj.open_socket()
119 self.commClientObj.open_socket()
115 ip = "192.168.1." + str(id)
120 ip = "192.168.1." + str(id)
116 self.commClientObj.sendData(cmd, data, ip)
121 self.commClientObj.sendData(cmd, data, ip)
117 ipSource, ipDestino, cmd, tmp = self.commClientObj.waitData()
122 ipSource, ipDestino, cmd, tmp = self.commClientObj.waitData()
118 self.commClientObj.close_socket()
123 self.commClientObj.close_socket()
119
124
120 return tmp
125 return tmp
121
126
122 def abs2ControlModuleFormatFile(self, filename):
127 def abs2ControlModuleFormatFile(self, filename):
123
128
124 #From matriz to control module format
129 #From matriz to control module format
125 self.wFiles.toCentralControlFormat(filename)
130 self.wFiles.toCentralControlFormat(filename)
126 FileName = "CentralControlFormat.txt"
131 FileName = "CentralControlFormat.txt"
127 F_Obj = open(FileName,"r")
132 F_Obj = open(FileName,"r")
128 FileList = F_Obj.readlines()
133 FileList = F_Obj.readlines()
129 F_Obj.close()
134 F_Obj.close()
130 FileStr = "".join(FileList)
135 FileStr = "".join(FileList)
131
136
132 return FileStr
137 return FileStr
133
138
134 def __All2Blocks(self,input):
139 def __All2Blocks(self,input):
135
140
136 rx_frame_lst = input.split('\n',2)
141 rx_frame_lst = input.split('\n',2)
137
142
138 header = rx_frame_lst[0] + "\n"
143 header = rx_frame_lst[0] + "\n"
139 control_modules_str = rx_frame_lst[2]
144 control_modules_str = rx_frame_lst[2]
140 control_modules_lst = control_modules_str.split("------\n")
145 control_modules_lst = control_modules_str.split("------\n")
141
146
142 return header, control_modules_lst
147 return header, control_modules_lst
143
148
144
149
145 def __sendFile2Modules(self,cmd):
150 def __sendFile2Modules(self,cmd):
146
151
147 rx_buffer_lst = self.rx_buffer.split('\n',1)
152 rx_buffer_lst = self.rx_buffer.split('\n',1)
148 #Getting the filename from the begining of data
153 #Getting the filename from the begining of data
149 filename = rx_buffer_lst[0]
154 filename = rx_buffer_lst[0]
150 tmp = rx_buffer_lst[1]
155 tmp = rx_buffer_lst[1]
151 self.__writeFile(filename,tmp)
156 self.__writeFile(filename,tmp)
152 data = self.abs2ControlModuleFormatFile(filename)
157 data = self.abs2ControlModuleFormatFile(filename)
153 #Needed for the loop
158 #Needed for the loop
154 header, control_modules_lst = self.__All2Blocks(data)
159 header, control_modules_lst = self.__All2Blocks(data)
155 correct = 0
160 correct = 0
156
161
157 for id in range(1,65):
162 for id in range(1,65):
158
163
159 if id not in self.enaModules:
164 if id not in self.enaModules:
160 continue
165 continue
161
166
162 if self.__ConnectionWithControlModules(header + control_modules_lst[id-1], cmd, id) == "OK":
167 if self.__ConnectionWithControlModules(header + control_modules_lst[id-1], cmd, id) == "OK":
163 correct = correct + 1
168 correct = correct + 1
164
169
165 if correct == len(self.enaModules):
170 if correct == len(self.enaModules):
166 rpta = "OK"
171 rpta = "OK"
167 else:
172 else:
168 rpta = "Failure"
173 rpta = "Failure"
169
174
170 return rpta
175 return rpta
171
176
172 def __changeBeam(self, cmd):
177 def __changeBeam(self, cmd):
173
178
174 correct = 0
179 correct = 0
175 # enaModules = self.checkAntenna()
180 # enaModules = self.checkAntenna()
176 # enaModules = [11,12,13,14]
181 # enaModules = [11,12,13,14]
177
182
178 for id in range(1,65):
183 for id in range(1,65):
179 if id not in self.enaModules:
184 if id not in self.enaModules:
180 continue
185 continue
181
186
182 if self.__ConnectionWithControlModules(self.rx_buffer,cmd,id) == "OK":
187 if self.__ConnectionWithControlModules(self.rx_buffer,cmd,id) == "OK":
183 correct = correct + 1
188 correct = correct + 1
184
189
185 if correct == len(self.enaModules):
190 if correct == len(self.enaModules):
186 rpta = "OK"
191 rpta = "OK"
187 else:
192 else:
188 rpta = "Failure"
193 rpta = "Failure"
189
194
190 return rpta
195 return rpta
191
196
192 def __getControlModuleStatus(self, cmd):
197 def __getControlModuleStatus(self, cmd):
193
198
194 all_blocks = ""
199 all_blocks = ""
195 # enaModules = self.checkAntenna()
200 # enaModules = self.checkAntenna()
196 # enaModules = [11,12,13,14]
201 # enaModules = [11,12,13,14]
197
202
198 for id in range(1,65):
203 for id in range(1,65):
199 if id not in self.enaModules:
204 if id not in self.enaModules:
200 continue
205 continue
201
206
202 one_block = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
207 one_block = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
203
208
204 all_blocks = all_blocks + one_block
209 all_blocks = all_blocks + one_block
205 #Using tx buffer
210 #Using tx buffer
206 print all_blocks
211 print all_blocks
207 self.tx_buffer = all_blocks
212 self.tx_buffer = all_blocks
208
213
209 def __getControlModulePhase(self, cmd):
214 def __getControlModuleBigPhase(self, cmd):
215
216 all_blocks = ""
217 # enaModules = self.checkAntenna()
218 # enaModules = [11,12,13,14]
219
220 for id in range(1,65):
221 if id not in self.enaModules:
222 continue
223
224 one_block = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
225
226 all_blocks = all_blocks + one_block
227 #Using tx buffer
228 print all_blocks
229 self.tx_buffer = all_blocks
230
231 def __getControlModuleLowPhase(self, cmd):
210
232
211 all_blocks = ""
233 all_blocks = ""
212 # enaModules = self.checkAntenna()
234 # enaModules = self.checkAntenna()
213 # enaModules = [11,12,13,14]
235 # enaModules = [11,12,13,14]
214
236
215 for id in range(1,65):
237 for id in range(1,65):
216 if id not in self.enaModules:
238 if id not in self.enaModules:
217 continue
239 continue
218
240
219 one_block = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
241 one_block = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
220
242
221 all_blocks = all_blocks + one_block
243 all_blocks = all_blocks + one_block
222 #Using tx buffer
244 #Using tx buffer
223 print all_blocks
245 print all_blocks
224 self.tx_buffer = all_blocks
246 self.tx_buffer = all_blocks
225
247
226 def __getConnectionStatus(self, cmd):
248 def __getConnectionStatus(self, cmd):
227
249
228 ena = self.checkAntenna()
250 ena = self.checkAntenna()
229 print ena
251 print ena
230 self.enaModules = ena
252 self.enaModules = ena
231
253
232 blockLst = []
254 blockLst = []
233
255
234 for id in range(1,65):
256 for id in range(1,65):
235 if id not in self.enaModules:
257 if id not in self.enaModules:
236 continue
258 continue
237
259
238 blockStr = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
260 blockStr = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
239 blockLst.append(blockStr + ", 192.168.1." + str(id) + "\n")
261 blockLst.append(blockStr + ", 192.168.1." + str(id) + "\n")
240 #Using tx buffer
262 #Using tx buffer
241 self.tx_buffer = "".join(blockLst)
263 self.tx_buffer = "".join(blockLst)
242 print self.tx_buffer
264 print self.tx_buffer
243
265
244 return self.tx_buffer
266 return self.tx_buffer
245
267
246 def getConnectionStatus(self, cmd):
268 def getConnectionStatus(self, cmd):
247
269
248 ena = self.checkAntenna()
270 ena = self.checkAntenna()
249 self.enaModules = ena
271 self.enaModules = ena
250
272
251 blockLst = []
273 blockLst = []
252
274
253 for id in range(1,65):
275 for id in range(1,65):
254 if id not in self.enaModules:
276 if id not in self.enaModules:
255 continue
277 continue
256
278
257 blockStr = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
279 blockStr = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
258 blockLst.append(blockStr + ", 192.168.1." + str(id) + "\n")
280 blockLst.append(blockStr + ", 192.168.1." + str(id) + "\n")
259 #Using tx buffer
281 #Using tx buffer
260 self.tx_buffer = "".join(blockLst)
282 self.tx_buffer = "".join(blockLst)
261 print self.tx_buffer
283 print self.tx_buffer
262
284
263 return self.tx_buffer
285 return self.tx_buffer
264
286
265 def getControlModuleStatus(self, cmd):
287 def getControlModuleStatus(self, cmd):
266
288
267 all_blocks = ""
289 all_blocks = ""
268 # enaModules = self.checkAntenna()
290 # enaModules = self.checkAntenna()
269 # enaModules = [11,12,13,14]
291 # enaModules = [11,12,13,14]
270
292
271 for id in range(1,65):
293 for id in range(1,65):
272 if id not in self.enaModules:
294 if id not in self.enaModules:
273 continue
295 continue
274
296
275 one_block = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
297 one_block = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)
276
298
277 all_blocks = all_blocks + one_block
299 all_blocks = all_blocks + one_block
278 #Using tx buffer
300 #Using tx buffer
279 print all_blocks
301 print all_blocks
280 self.tx_buffer = all_blocks
302 self.tx_buffer = all_blocks
281
303
282 return all_blocks
304 return all_blocks
283
305
284
306
285 if __name__ == '__main__':
307 if __name__ == '__main__':
286
308
287 absObj = ABSServer()
309 absObj = ABSServer()
288
310
289 while 1:
311 while 1:
290 absObj.waitRequest() No newline at end of file
312 absObj.waitRequest()
General Comments 0
You need to be logged in to leave comments. Login now