ABS/abscontrol Commit - r269:270 · Jicamarca Repository

1

import os

1

import os

2

import library3

2

import library3

3

import time

3

import time

4

from threading import Thread

4

from threading import Thread

5

import threading

5

import threading

6

import Queue

6

import Queue

7

8

class ABSServer:

8

class ABSServer:

9

10

def __init__(self,ipSource="localhost", ipDestino="192.168.1.117", portDestino=7000, ipDestino2="192.168.1.11", portDestino2=5500, rx_buffer = "default"):

10

def __init__(self,ipSource="localhost", ipDestino="192.168.1.117", portDestino=7000, ipDestino2="192.168.1.11", portDestino2=5500, rx_buffer = "default"):

11

12

13

self.ipSource = ipSource

13

self.ipSource = ipSource

14

self.ipDestino = ipDestino

14

self.ipDestino = ipDestino

15

self.portDestino = portDestino

15

self.portDestino = portDestino

16

17

self.ipDestino2 = ipDestino2

17

self.ipDestino2 = ipDestino2

18

self.portDestino2 = portDestino2

18

self.portDestino2 = portDestino2

19

20

self.tx_buffer = "default"

20

self.tx_buffer = "default"

21

self.rx_buffer = rx_buffer

21

self.rx_buffer = rx_buffer

22

self.enaModules = []

22

self.enaModules = []

23

self.bits = []

23

self.bits = []

24

self.phase = []

24

self.phase = []

25

self.txFile = []

25

self.txFile = []

26

self.rxFile = []

26

self.rxFile = []

27

28

self.createObjects()

28

self.createObjects()

29

30

print "Checking control modules, please wait ..."

30

print "Checking control modules, please wait ..."

31

self.enaModules = self.checkAntenna()

31

self.enaModules = self.checkAntenna()

32

print '\nThis modules are present : ' + str(self.enaModules) + '\n'

32

print '\nThis modules are present : ' + str(self.enaModules) + '\n'

33

# print "Starting automatic control module status."

33

# print "Starting automatic control module status."

34

self.__StartingAutomaticControlModules()

34

self.__StartingAutomaticControlModules()

35

# self.__AutomaticControlModules()

35

# self.__AutomaticControlModules()

36

37

def createObjects(self):

37

def createObjects(self):

38

39

asServer = True

39

asServer = True

40

self.commServerObj = library3.TCPComm("Central_Control", "CeCnMod", self.ipDestino, "CnMod01", self.portDestino, asServer)

40

self.commServerObj = library3.TCPComm("Central_Control", "CeCnMod", self.ipDestino, "CnMod01", self.portDestino, asServer)

41

self.commClientObj = library3.TCPComm("Central_Control", "CeCnMod", self.ipDestino2, "CnMod01", self.portDestino2)

41

self.commClientObj = library3.TCPComm("Central_Control", "CeCnMod", self.ipDestino2, "CnMod01", self.portDestino2)

42

self.wFiles = library3.FilesStuff()

42

self.wFiles = library3.FilesStuff()

43

44

def waitRequest(self):

44

def waitRequest(self):

45

46

#Using rx buffer

46

#Using rx buffer

47

# ipSource, ipDestino, cmd, self.rx_buffer = self.commServerObj.waitData()

47

# ipSource, ipDestino, cmd, self.rx_buffer = self.commServerObj.waitData()

48

ipSource, ipDestino, cmd, rx_buffer = self.commServerObj.waitData()

48

ipSource, ipDestino, cmd, rx_buffer = self.commServerObj.waitData()

49

50

if cmd == "SNDF":

50

if cmd == "SNDF":

51

datarpta = self.__sendFile2Modules(cmd = cmd, rx_buffer = rx_buffer)

51

datarpta = self.__sendFile2Modules(cmd = cmd, rx_buffer = rx_buffer)

52

53

if cmd == "GETF":

53

if cmd == "GETF":

54

datarpta = self.__getFileFromModules(cmd = cmd, rx_buffer = rx_buffer)

54

datarpta = self.__getFileFromModules(cmd = cmd, rx_buffer = rx_buffer)

55

56

if cmd == "CHGB":

56

if cmd == "CHGB":

57

datarpta = self.__changeBeam(cmd = cmd, rx_buffer = rx_buffer)

57

datarpta = self.__changeBeam(cmd = cmd, rx_buffer = rx_buffer)

58

59

if cmd == "ANST":

59

if cmd == "ANST":

60

datarpta = self.__getControlModuleStatus_old(cmd = cmd, rx_buffer = rx_buffer)

60

datarpta = self.__getControlModuleStatus_old(cmd = cmd, rx_buffer = rx_buffer)

61

62

if cmd == "BGPH":

62

if cmd == "BGPH":

63

datarpta = self.__getControlModuleBigPhase(cmd = cmd, rx_buffer = rx_buffer)

63

datarpta = self.__getControlModuleBigPhase(cmd = cmd, rx_buffer = rx_buffer)

64

65

if cmd == "LWPH":

65

if cmd == "LWPH":

66

datarpta = self.__getControlModuleLowPhase(cmd = cmd, rx_buffer = rx_buffer)

66

datarpta = self.__getControlModuleLowPhase(cmd = cmd, rx_buffer = rx_buffer)

67

68

if cmd == "NTST":

68

if cmd == "NTST":

69

datarpta = self.__getConnectionStatus(cmd = cmd, rx_buffer = rx_buffer)

69

datarpta = self.__getConnectionStatus(cmd = cmd, rx_buffer = rx_buffer)

70

71

if cmd == "MNTR":

71

if cmd == "MNTR":

72

datarpta = self.__getControlModuleStatus_new(cmd = cmd, type = rx_buffer)

72

datarpta = self.__getControlModuleStatus_new(cmd = cmd, type = rx_buffer)

73

74

self.commServerObj.sendData(cmd=cmd, data=datarpta, ipDestino = ipSource)

74

self.commServerObj.sendData(cmd=cmd, data=datarpta, ipDestino = ipSource)

75

76

def __checkModule(self, address):

76

def __checkModule(self, address):

77

78

cmd = "ping -c 1 -w 1 192.168.1."+ str(address) + " >> /dev/null"

78

cmd = "ping -c 1 -w 1 192.168.1."+ str(address) + " >> /dev/null"

79

status = os.system(cmd)

79

status = os.system(cmd)

80

81

if status == 256:

81

if status == 256:

82

return False

82

return False

83

84

return True

84

return True

85

86

def __writeReport(self, enaModules):

86

def __writeReport(self, enaModules):

87

88

status_array = ["Status of modules\n"]

88

status_array = ["Status of modules\n"]

89

status_array.append("----------------\n")

89

status_array.append("----------------\n")

90

91

for address in range(1,65):

91

for address in range(1,65):

92

if address in enaModules:

92

if address in enaModules:

93

status_array.append("192.168.1." + str(address) + " [1 1]\n")

93

status_array.append("192.168.1." + str(address) + " [1 1]\n")

94

else:

94

else:

95

status_array.append("192.168.1." + str(address) + " [0 0]\n")

95

status_array.append("192.168.1." + str(address) + " [0 0]\n")

96

97

filename = "module_status.txt"

97

filename = "module_status.txt"

98

self.__writeFile(filename,status_array)

98

self.__writeFile(filename,status_array)

99

# f = open("module_status.txt","w")

99

# f = open("module_status.txt","w")

100

# f.writelines(status_array)

100

# f.writelines(status_array)

101

# f.close()

101

# f.close()

102

103

104

def __CreateFile(self, filename):

104

def __CreateFile(self, filename):

105

106

fobj = open(filename,"w")

106

fobj = open(filename,"w")

107

fobj.close()

107

fobj.close()

108

109

def __writeNewFile(self, filename, data):

109

def __writeNewFile(self, filename, data):

110

111

fobj = open(filename,"w")

111

fobj = open(filename,"w")

112

fobj.writelines(data)

112

fobj.writelines(data)

113

fobj.close()

113

fobj.close()

114

115

def __writeFile(self, filename, data):

115

def __writeFile(self, filename, data):

116

117

fobj = open(filename,"a")

117

fobj = open(filename,"a")

118

fobj.writelines(data)

118

fobj.writelines(data)

119

fobj.close()

119

fobj.close()

120

121

def __checkAntenna(self):

121

def __checkAntenna(self):

122

123

"""

123

"""

124

Direccion de los modulos de las antenas:

124

Direccion de los modulos de las antenas:

125

126

Norte : 01-16

126

Norte : 01-16

127

Este : 17-32

127

Este : 17-32

128

Oeste: : 33-48

128

Oeste: : 33-48

129

Sur : 49-64

129

Sur : 49-64

130

131

"""

131

"""

132

133

enaModules2 = []

133

enaModules2 = []

134

135

for address in range(1,65):

135

for address in range(1,65):

136

if self.checkModule(address):

136

if self.checkModule(address):

137

enaModules2.append(address)

137

enaModules2.append(address)

138

139

self.__writeReport(enaModules2)

139

self.__writeReport(enaModules2)

140

return enaModules2

140

return enaModules2

141

142

def checkModule(self, arg, queue):

142

def checkModule(self, arg, queue):

143

cmd = "ping -c 1 -w 1 192.168.1."+ str(arg) + " >> /dev/null"

143

cmd = "ping -c 1 -w 1 192.168.1."+ str(arg) + " >> /dev/null"

144

status = os.system(cmd)

144

status = os.system(cmd)

145

if status == 256:

145

if status == 256:

146

result = "failed"

146

result = "failed"

147

else:

147

else:

148

result = "ok"

148

result = "ok"

149

queue.put({arg: result})

149

queue.put({arg: result})

150

151

def checkAntenna(self):

151

def checkAntenna(self):

152

153

iD = range(1,65)

153

iD = range(1,65)

154

q = Queue.Queue()

154

q = Queue.Queue()

155

threads = []

155

threads = []

156

tOut = []

156

tOut = []

157

modules = []

157

modules = []

158

159

for argument in iD:

159

for argument in iD:

160

t = Thread(target=self.checkModule, args=(argument, q))

160

t = Thread(target=self.checkModule, args=(argument, q))

161

t.start()

161

t.start()

162

threads.append(t)

162

threads.append(t)

163

164

for t in threads:

164

for t in threads:

165

t.join()

165

t.join()

166

167

for _ in range(len(iD)):

167

for _ in range(len(iD)):

168

tOut.append(q.get())

168

tOut.append(q.get())

169

170

for i in tOut:

170

for i in tOut:

171

if i.values()[0] == 'ok':

171

if i.values()[0] == 'ok':

172

modules.append(i.keys()[0])

172

modules.append(i.keys()[0])

173

174

return modules

174

return modules

175

176

def __ConnectionWithControlModules(self,data,cmd,id):

176

def __ConnectionWithControlModules(self,data,cmd,id):

177

178

self.commClientObj.open_socket()

178

self.commClientObj.open_socket()

179

ip = "192.168.1." + str(id)

179

ip = "192.168.1." + str(id)

180

self.commClientObj.sendData(cmd, data, ip)

180

self.commClientObj.sendData(cmd, data, ip)

181

ipSource, ipDestino, cmd, tmp = self.commClientObj.waitData()

181

ipSource, ipDestino, cmd, tmp = self.commClientObj.waitData()

182

self.commClientObj.close_socket()

182

self.commClientObj.close_socket()

183

184

return tmp

184

return tmp

185

186

def abs2ControlModuleFormatFile(self, filename):

186

def abs2ControlModuleFormatFile(self, filename):

187

188

#From matriz to control module format

188

#From matriz to control module format

189

self.wFiles.toCentralControlFormat(filename)

189

self.wFiles.toCentralControlFormat(filename)

190

FileName = "CentralControlFormat.txt"

190

FileName = "CentralControlFormat.txt"

191

F_Obj = open(FileName,"r")

191

F_Obj = open(FileName,"r")

192

FileList = F_Obj.readlines()

192

FileList = F_Obj.readlines()

193

F_Obj.close()

193

F_Obj.close()

194

FileStr = "".join(FileList)

194

FileStr = "".join(FileList)

195

196

return FileStr

196

return FileStr

197

198

def __All2Blocks(self,input):

198

def __All2Blocks(self,input):

199

200

rx_frame_lst = input.split('\n',2)

200

rx_frame_lst = input.split('\n',2)

201

202

header = rx_frame_lst[0] + "\n"

202

header = rx_frame_lst[0] + "\n"

203

control_modules_str = rx_frame_lst[2]

203

control_modules_str = rx_frame_lst[2]

204

control_modules_lst = control_modules_str.split("------\n")

204

control_modules_lst = control_modules_str.split("------\n")

205

206

return header, control_modules_lst

206

return header, control_modules_lst

207

208

209

def __sendFile2Modules(self,cmd, rx_buffer):

209

def __sendFile2Modules(self,cmd, rx_buffer):

210

211

# rx_buffer_lst = self.rx_buffer.split('\n',1)

211

# rx_buffer_lst = self.rx_buffer.split('\n',1)

212

rx_buffer_lst = rx_buffer.split('\n',1)

212

rx_buffer_lst = rx_buffer.split('\n',1)

213

#Getting the filename from the begining of data

213

#Getting the filename from the begining of data

214

filename = rx_buffer_lst[0]

214

filename = rx_buffer_lst[0]

215

tmp = rx_buffer_lst[1]

215

tmp = rx_buffer_lst[1]

216

self.__writeNewFile(filename,tmp)

216

self.__writeNewFile(filename,tmp)

217

data = self.abs2ControlModuleFormatFile(filename)

217

data = self.abs2ControlModuleFormatFile(filename)

218

219

print data

219

print data

220

#Needed for the loop

220

#Needed for the loop

221

header, control_modules_lst = self.__All2Blocks(data)

221

header, control_modules_lst = self.__All2Blocks(data)

222

correct = 0

222

correct = 0

223

224

for id in range(1,65):

224

for id in range(1,65):

225

226

if id not in self.enaModules:

226

if id not in self.enaModules:

227

continue

227

continue

228

229

if self.__ConnectionWithControlModules(header + control_modules_lst[id-1], cmd, id) == "OK":

229

if self.__ConnectionWithControlModules(header + control_modules_lst[id-1], cmd, id) == "OK":

230

correct = correct + 1

230

correct = correct + 1

231

232

if correct == len(self.enaModules):

232

if correct == len(self.enaModules):

233

rpta = "OK"

233

rpta = "OK"

234

else:

234

else:

235

rpta = "Failure"

235

rpta = "Failure"

236

237

return rpta

237

return rpta

238

239

def __getFileFromModules(self, cmd, rx_buffer):

239

def __getFileFromModules(self, cmd, rx_buffer):

240

241

for id in range(1,65):

241

for id in range(1,65):

242

if id not in self.enaModules:

242

if id not in self.enaModules:

243

continue

243

continue

244

245

file = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

245

file = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

246

del self.rxFile[id-1]

246

del self.rxFile[id-1]

247

self.rxFile.insert(id-1, file)

247

self.rxFile.insert(id-1, file)

248

249

return self.rxFile

249

return self.rxFile

250

251

def __changeBeam(self, cmd, rx_buffer):

251

def __changeBeam(self, cmd, rx_buffer):

252

253

correct = 0

253

correct = 0

254

# enaModules = self.checkAntenna()

254

# enaModules = self.checkAntenna()

255

# enaModules = [11,12,13,14]

255

# enaModules = [11,12,13,14]

256

257

for id in range(1,65):

257

for id in range(1,65):

258

if id not in self.enaModules:

258

if id not in self.enaModules:

259

continue

259

continue

260

261

if self.__ConnectionWithControlModules(rx_buffer,cmd,id) == "OK":

261

if self.__ConnectionWithControlModules(rx_buffer,cmd,id) == "OK":

262

correct = correct + 1

262

correct = correct + 1

263

264

if correct == len(self.enaModules):

264

if correct == len(self.enaModules):

265

rpta = "OK"

265

rpta = "OK"

266

else:

266

else:

267

rpta = "Failure"

267

rpta = "Failure"

268

269

return rpta

269

return rpta

270

271

def __getControlModuleStatus(self, cmd, rx_buffer):

271

def __getControlModuleStatus(self, cmd, rx_buffer):

272

273

# all_blocks = ""

273

# all_blocks = ""

274

# all_blocks = []

274

# all_blocks = []

275

# enaModules = self.checkAntenna()

275

# enaModules = self.checkAntenna()

276

# enaModules = [11,12,13,14]

276

# enaModules = [11,12,13,14]

277

278

for id in range(1,65):

278

for id in range(1,65):

279

if id not in self.enaModules:

279

if id not in self.enaModules:

280

continue

280

continue

281

282

bits = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

282

bits = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

283

del self.bits[id-1]

283

del self.bits[id-1]

284

self.bits.insert(id-1, bits)

284

self.bits.insert(id-1, bits)

285

286

# all_blocks.append(one_block)

286

# all_blocks.append(one_block)

287

#Using tx buffer

287

#Using tx buffer

288

289

return self.bits

289

return self.bits

290

291

def __getControlModuleStatus_new(self, cmd, type):

291

def __getControlModuleStatus_new(self, cmd, type):

292

293

cm_lst = self.__gettingDataFromControlModules(cmd = cmd, rx_buffer = type)

293

cm_lst = self.__gettingDataFromControlModules(cmd = cmd, rx_buffer = type)

294

out_str = self.__processingCMdata(in_data = cm_lst, type = type)

294

out_str = self.__processingCMdata(in_data = cm_lst, type = type)

295

296

return out_str

296

return out_str

297

298

def __gettingDataFromControlModules(self, cmd, rx_buffer):

298

def __gettingDataFromControlModules(self, cmd, rx_buffer):

299

300

for id in range(1,65):

300

for id in range(1,65):

301

if id not in self.enaModules:

301

if id not in self.enaModules:

302

continue

302

continue

303

304

cm = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

304

cm = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

305

del self.test[id-1]

305

del self.test[id-1]

306

self.test.insert(id-1, cm)

306

self.test.insert(id-1, cm)

307

308

return self.test

308

return self.test

309

310

def __processingCMdata(self,in_data, type):

310

def __processingCMdata(self,in_data, type):

311

312

if (type == "0") or (type == "1") or (type == "2"):

312

if (type == "0") or (type == "1") or (type == "2"):

313

out_str = "".join(in_data)

313

out_str = "".join(in_data)

314

elif type == "3":

314

elif type == "3":

315

out_str = self.__TwoComparation(in_lst = in_data)

315

out_str = self.__TwoComparation(in_lst = in_data)

316

else:

316

else:

317

out_str = self.__ThreeComparation(in_lst = in_data)

317

out_str = self.__ThreeComparation(in_lst = in_data)

318

319

return out_str

319

return out_str

320

321

def __TwoComparation(self, in_lst):

321

def __TwoComparation(self, in_lst):

322

323

324

file = []

323

file = []

325

relay = []

324

relay = []

326

status = []

325

status = []

327

mode = '0'

326

328

327

for i in in_lst:

329

if ~~mode~~ == ~~'0'~~:

328

if len(i) == 7:

330

329

file.append("xxxxxx")

331

for i in in_lst:

330

relay.append("xxxxxx")

332

if ~~len~~(i) == 7:

331

else:

333

file.append(~~"xxxxxx"~~)

332

file.append(i[16:22])

334

relay.append(~~"xxxxxx"~~)

333

relay.append(i[23:29])

335

else:

334

#Loop to generate a status

336

file.append(i[16:22])

335

for i in range(64):

337

relay.append(i[23:29])

336

cnt = 0

338

#Loop to generate a status

337

if file[i] == "xxxxxx":

339

for i in range(64):

338

status.append("xx")

340

cnt = 0

339

continue

341

if file[i] == "xxxxxx":

342

status.append("xx")

343

continue

344

340

345

if cmp(file[i],relay[i]) == 0:

341

if cmp(file[i],relay[i]) == 0:

346

cnt = cnt + 1

342

cnt = cnt + 1

347

343

348

if cmp(file[i][0:3],relay[i][0:3]) == 0:

344

if cmp(file[i][0:3],relay[i][0:3]) == 0:

349

cnt = cnt + 1

345

cnt = cnt + 1

350

346

351

if cmp(file[i][3:6],relay[i][3:6]) == 0:

347

if cmp(file[i][3:6],relay[i][3:6]) == 0:

352

cnt = cnt + 2

348

cnt = cnt + 2

353

349

354

355

356

if cnt == 4:

350

if cnt == 4:

357

status.append("00")

351

status.append("00")

358

elif cnt == 0:

352

elif cnt == 0:

359

status.append("11")

353

status.append("11")

360

elif cnt == 1:

354

elif cnt == 1:

361

status.append("01")

355

status.append("01")

362

else:

356

else:

363

status.append("10")

357

status.append("10")

364

365

else:

366

367

cm_up =[]

368

cm_dw =[]

369

relay_up =[]

370

relay_dw =[]

371

372

for i in in_lst:

373

if len(i) == 8:

374

relay_up.append("-")

375

relay_dw.append("-")

376

cm_up.append("-")

377

cm_dw.append("-")

378

continue

379

relay_up.append(i[14:17])

380

relay_dw.append(i[17:20])

381

cm_up.append(i[21:24])

382

cm_dw.append(i[24:27])

383

384

comp_up = []

385

comp_dw = []

386

387

for i in range(64):

388

if len(relay_up == 1):

389

comp_up.append('x')

390

else:

391

if cmp(relay_up[i], cm_up[i]) == 0:

392

comp_up.append('0')

393

else:

394

comp_up.append('1')

395

396

for i in range(64):

397

if len(relay_dw == 1):

398

comp_dw.append('x')

399

else:

400

if cmp(relay_dw[i], cm_dw[i]) == 0:

401

comp_dw.append('0')

402

else:

403

comp_dw.append('1')

404

405

# Example:

406

# comp_up = [1,0,x,1,1,1 ..,1,0,1,x]

407

#

408

print comp_up

409

print comp_dw

410

358

411

#Doing final format

359

#Doing final format

412

return self.__FinalFormat(data1 = file, data2 = relay, data3 = status)

360

return self.__FinalFormat(data1 = file, data2 = relay, data3 = status)

413

361

414

def __FinalFormat(self,data1,data2,data3):

362

def __FinalFormat(self,data1,data2,data3):

415

363

416

header = "Device\tFile\tRelay\tStatus\n"

364

header = "Device\tFile\tRelay\tStatus\n"

417

body = ""

365

body = ""

418

for i in range(64):

366

for i in range(64):

419

if i<9:

367

if i<9:

420

device = "CM0" + str(i+1)

368

device = "CM0" + str(i+1)

421

else:

369

else:

422

device = "CM" + str(i+1)

370

device = "CM" + str(i+1)

423

371

424

line = device + '\t' + data1[i] + '\t' + data2[i] + '\t' + data3[i] + '\n'

372

line = device + '\t' + data1[i] + '\t' + data2[i] + '\t' + data3[i] + '\n'

425

body = body + line

373

body = body + line

426

374

427

report = header + body

375

report = header + body

428

376

429

return report

377

return report

430

378

431

def __ThreeComparation(self, in_lst):

379

def __ThreeComparation(self, in_lst):

432

pass

380

pass

433

381

434

def __getControlModuleBigPhase(self, cmd, rx_buffer):

382

def __getControlModuleBigPhase(self, cmd, rx_buffer):

435

383

436

# all_blocks = ""

384

# all_blocks = ""

437

all_blocks = []

385

all_blocks = []

438

# enaModules = self.checkAntenna()

386

# enaModules = self.checkAntenna()

439

# enaModules = [11,12,13,14]

387

# enaModules = [11,12,13,14]

440

388

441

for id in range(1,65):

389

for id in range(1,65):

442

if id not in self.enaModules:

390

if id not in self.enaModules:

443

continue

391

continue

444

392

445

one_block = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

393

one_block = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

446

394

447

# all_blocks = all_blocks + one_block

395

# all_blocks = all_blocks + one_block

448

all_blocks.append(one_block)

396

all_blocks.append(one_block)

449

#Using tx buffer

397

#Using tx buffer

450

return all_blocks

398

return all_blocks

451

399

452

def __getControlModuleLowPhase(self, cmd, rx_buffer):

400

def __getControlModuleLowPhase(self, cmd, rx_buffer):

453

401

454

# all_blocks = ""

402

# all_blocks = ""

455

# all_blocks = []

403

# all_blocks = []

456

# enaModules = self.checkAntenna()

404

# enaModules = self.checkAntenna()

457

# enaModules = [11,12,13,14]

405

# enaModules = [11,12,13,14]

458

406

459

for id in range(1,65):

407

for id in range(1,65):

460

if id not in self.enaModules:

408

if id not in self.enaModules:

461

continue

409

continue

462

410

463

phase = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

411

phase = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

464

del self.phase[id-1]

412

del self.phase[id-1]

465

self.phase.insert(id-1, phase)

413

self.phase.insert(id-1, phase)

466

# all_blocks = all_blocks + one_block

414

# all_blocks = all_blocks + one_block

467

# all_blocks.append(one_block)

415

# all_blocks.append(one_block)

468

#Using tx buffer

416

#Using tx buffer

469

# return all_blocks

417

# return all_blocks

470

418

471

def __getConnectionStatus(self, cmd, rx_buffer):

419

def __getConnectionStatus(self, cmd, rx_buffer):

472

420

473

ena = self.checkAntenna()

421

ena = self.checkAntenna()

474

print ena

422

print ena

475

self.enaModules = ena

423

self.enaModules = ena

476

424

477

blockLst = []

425

blockLst = []

478

426

479

for id in range(1,65):

427

for id in range(1,65):

480

if id not in self.enaModules:

428

if id not in self.enaModules:

481

continue

429

continue

482

430

483

blockStr = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

431

blockStr = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

484

blockLst.append(blockStr + ", 192.168.1." + str(id) + "\n")

432

blockLst.append(blockStr + ", 192.168.1." + str(id) + "\n")

485

#Using tx buffer

433

#Using tx buffer

486

all_blocks = "".join(blockLst)

434

all_blocks = "".join(blockLst)

487

435

488

return all_blocks

436

return all_blocks

489

437

490

def getConnectionStatus(self, cmd):

438

def getConnectionStatus(self, cmd):

491

439

492

ena = self.checkAntenna()

440

ena = self.checkAntenna()

493

self.enaModules = ena

441

self.enaModules = ena

494

442

495

blockLst = []

443

blockLst = []

496

444

497

for id in range(1,65):

445

for id in range(1,65):

498

if id not in self.enaModules:

446

if id not in self.enaModules:

499

continue

447

continue

500

448

501

blockStr = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)

449

blockStr = self.__ConnectionWithControlModules(self.rx_buffer,cmd,id)

502

blockLst.append(blockStr + ", 192.168.1." + str(id) + "\n")

450

blockLst.append(blockStr + ", 192.168.1." + str(id) + "\n")

503

#Using tx buffer

451

#Using tx buffer

504

self.tx_buffer = "".join(blockLst)

452

self.tx_buffer = "".join(blockLst)

505

print self.tx_buffer

453

print self.tx_buffer

506

454

507

return self.tx_buffer

455

return self.tx_buffer

508

456

509

def __getControlModuleStatus_old(self, cmd, rx_buffer):

457

def __getControlModuleStatus_old(self, cmd, rx_buffer):

510

458

511

all_blocks = ""

459

all_blocks = ""

512

# enaModules = self.checkAntenna()

460

# enaModules = self.checkAntenna()

513

# enaModules = [11,12,13,14]

461

# enaModules = [11,12,13,14]

514

462

515

for id in range(1,65):

463

for id in range(1,65):

516

if id not in self.enaModules:

464

if id not in self.enaModules:

517

continue

465

continue

518

466

519

one_block = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

467

one_block = self.__ConnectionWithControlModules(rx_buffer,cmd,id)

520

468

521

all_blocks = all_blocks + one_block

469

all_blocks = all_blocks + one_block

522

#Using tx buffer

470

#Using tx buffer

523

print all_blocks

471

print all_blocks

524

self.tx_buffer = all_blocks

472

self.tx_buffer = all_blocks

525

473

526

return all_blocks

474

return all_blocks

527

475

528

def __StartingAutomaticControlModules(self):

476

def __StartingAutomaticControlModules(self):

529

477

530

#Starting file

478

#Starting file

531

self.__CreateFile("Monitoring.txt")

479

self.__CreateFile("Monitoring.txt")

532

# data = "MOD.\t BITS\t\t PHASE\n"

480

# data = "MOD.\t BITS\t\t PHASE\n"

533

# self.__writeFile("Monitoring.txt", data)

481

# self.__writeFile("Monitoring.txt", data)

534

#Starting lists

482

#Starting lists

535

self.txFile = list("------\n------\n------\n" for i in range(64))

483

self.txFile = list("------\n------\n------\n" for i in range(64))

536

self.rxFile = list("------\n------\n------\n" for i in range(64))

484

self.rxFile = list("------\n------\n------\n" for i in range(64))

537

self.bits = list("------\n------\n------\n" for i in range(64))

485

self.bits = list("------\n------\n------\n" for i in range(64))

538

self.phase = list("----- -----\n----- -----\n----- -----\n" for i in range(64))

486

self.phase = list("----- -----\n----- -----\n----- -----\n" for i in range(64))

539

self.test = list("------\n" for i in range(64))

487

self.test = list("------\n" for i in range(64))

540

488

541

def __AutomaticControlModules(self):

489

def __AutomaticControlModules(self):

542

490

543

# cmd = "GETF"

491

# cmd = "GETF"

544

# rx_buffer = "experimento1.ab1" + "\n"

492

# rx_buffer = "experimento1.ab1" + "\n"

545

# self.__getFileFromModules(cmd = cmd, rx_buffer = rx_buffer)

493

# self.__getFileFromModules(cmd = cmd, rx_buffer = rx_buffer)

546

#

494

#

547

# print self.rxFile

495

# print self.rxFile

548

496

549

cmd = "ANST"

497

cmd = "ANST"

550

rx_buffer = "1"

498

rx_buffer = "1"

551

self.__getControlModuleStatus(cmd = cmd, rx_buffer = rx_buffer)

499

self.__getControlModuleStatus(cmd = cmd, rx_buffer = rx_buffer)

552

500

553

cmd = "LWPH"

501

cmd = "LWPH"

554

rx_buffer = "0"

502

rx_buffer = "0"

555

self.__getControlModuleLowPhase(cmd = cmd, rx_buffer = rx_buffer)

503

self.__getControlModuleLowPhase(cmd = cmd, rx_buffer = rx_buffer)

556

print "Saving file..."

504

print "Saving file..."

557

505

558

506

559

print self.bits

507

print self.bits

560

print self.phase

508

print self.phase

561

509

562

self.__WritingMonitoringFile()

510

self.__WritingMonitoringFile()

563

511

564

threading.Timer(60, self.__AutomaticControlModules).start()

512

threading.Timer(60, self.__AutomaticControlModules).start()

565

513

566

def __WritingMonitoringFile(self):

514

def __WritingMonitoringFile(self):

567

filename = "Monitoring.txt"

515

filename = "Monitoring.txt"

568

data = '===============================' + '\n'

516

data = '===============================' + '\n'

569

self.__writeFile(filename, data)

517

self.__writeFile(filename, data)

570

data = time.strftime('\t' + "%d%b%Y %I:%M:%S %p" + '\n', time.localtime())

518

data = time.strftime('\t' + "%d%b%Y %I:%M:%S %p" + '\n', time.localtime())

571

self.__writeFile(filename, data)

519

self.__writeFile(filename, data)

572

data = "MOD.\t BITS\t\t PHASE\n"

520

data = "MOD.\t BITS\t\t PHASE\n"

573

self.__writeFile(filename, data)

521

self.__writeFile(filename, data)

574

data = '===============================' + '\n'

522

data = '===============================' + '\n'

575

self.__writeFile(filename, data)

523

self.__writeFile(filename, data)

576

for i in range(64):

524

for i in range(64):

577

tmp = self.bits[i].split('\n',3)

525

tmp = self.bits[i].split('\n',3)

578

self.__writeFile(filename, ' ' + str(i + 1) + '\t\t' + tmp[2])

526

self.__writeFile(filename, ' ' + str(i + 1) + '\t\t' + tmp[2])

579

tmp = self.phase[i].split('\n',3)

527

tmp = self.phase[i].split('\n',3)

580

self.__writeFile(filename, '\t\t' + tmp[2] + '\n')

528

self.__writeFile(filename, '\t\t' + tmp[2] + '\n')

581

529

582

530

583

if __name__ == '__main__':

531

if __name__ == '__main__':

584

532

585

absObj = ABSServer()

533

absObj = ABSServer()

586

534

587

while 1:

535

while 1:

588

absObj.waitRequest() No newline at end of file

536

absObj.waitRequest()

	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

             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)
                     if cmd == "MNTR":
                         datarpta = self.__getControlModuleStatus_new(cmd = cmd, type = 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.__writeNewFile(filename,tmp)
                     data = self.abs2ControlModuleFormatFile(filename)
                     print data
                     #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 __getControlModuleStatus_new(self, cmd, type):
                     cm_lst = self.__gettingDataFromControlModules(cmd = cmd, rx_buffer = type)
                     out_str = self.__processingCMdata(in_data = cm_lst, type = type)
                     return out_str
                 def __gettingDataFromControlModules(self, cmd, rx_buffer):
                     for id in range(1,65):
                         if id not in self.enaModules:
                             continue
                         cm = self.__ConnectionWithControlModules(rx_buffer,cmd,id)
                         del self.test[id-1]
                         self.test.insert(id-1, cm)
                     return self.test
                 def __processingCMdata(self,in_data, type):
                     if (type == "0") or (type == "1") or (type == "2"):
                         out_str = "".join(in_data)
                     elif type == "3":
                         out_str = self.__TwoComparation(in_lst = in_data)
                     else:
                         out_str = self.__ThreeComparation(in_lst = in_data)
                     return out_str
                 def __TwoComparation(self, in_lst):
                     file = []
                     relay = []
                     status = []
-                    mode = '0'
+                    for i in in_lst:
-                    if mode == '0':
+                        if len(i) == 7:
+                            file.append("xxxxxx")
-                        for i in in_lst:
+                            relay.append("xxxxxx")
-                            if len(i) == 7:
+                        else:
-                                file.append("xxxxxx")
+                            file.append(i[16:22])
-                                relay.append("xxxxxx")
+                            relay.append(i[23:29])
-                            else:
+                    #Loop to generate a status
-                                file.append(i[16:22])
+                    for i in range(64):
-                                relay.append(i[23:29])
+                        cnt = 0
-                        #Loop to generate a status
+                        if file[i] == "xxxxxx":
-                        for i in range(64):
+                            status.append("xx")
-                            cnt = 0
+                            continue
-                            if file[i] == "xxxxxx":
-                                status.append("xx")
-                                continue
                             if cmp(file[i],relay[i]) == 0:
                                 cnt = cnt + 1
                             if cmp(file[i][0:3],relay[i][0:3]) == 0:
                                 cnt = cnt + 1
                             if cmp(file[i][3:6],relay[i][3:6]) == 0:
                                 cnt = cnt + 2
                             if cnt == 4:
                                 status.append("00")
                             elif cnt == 0:
                                 status.append("11")
                             elif cnt == 1:
                                 status.append("01")
                             else:
                                 status.append("10")
-                    else:
-                        cm_up =[]
-                        cm_dw =[]
-                        relay_up =[]
-                        relay_dw =[]
-                        for i in in_lst:
-                            if len(i) == 8:
-                                relay_up.append("-")
-                                relay_dw.append("-")
-                                cm_up.append("-")
-                                cm_dw.append("-")
-                                continue
-                            relay_up.append(i[14:17])
-                            relay_dw.append(i[17:20])
-                            cm_up.append(i[21:24])
-                            cm_dw.append(i[24:27])
-                        comp_up = []
-                        comp_dw = []
-                        for i in range(64):
-                            if len(relay_up == 1):
-                                comp_up.append('x')
-                            else:
-                                if cmp(relay_up[i], cm_up[i]) == 0:
-                                    comp_up.append('0')
-                                else:
-                                    comp_up.append('1')
-                        for i in range(64):
-                            if len(relay_dw == 1):
-                                comp_dw.append('x')
-                            else:
-                                if cmp(relay_dw[i], cm_dw[i]) == 0:
-                                    comp_dw.append('0')
-                                else:
-                                    comp_dw.append('1')
-                #    Example:
-                #    comp_up = [1,0,x,1,1,1 ..,1,0,1,x]
-                        print comp_up
-                        print comp_dw
                     #Doing final format
                     return self.__FinalFormat(data1 = file, data2 = relay, data3 = status)
                 def __FinalFormat(self,data1,data2,data3):
                     header = "Device\tFile\tRelay\tStatus\n"
                     body = ""
                     for i in range(64):
                         if i<9:
                             device = "CM0" + str(i+1)
                         else:
                             device = "CM" + str(i+1)
                         line = device + '\t' + data1[i] + '\t' + data2[i] + '\t' + data3[i] + '\n'
                         body = body + line
                     report = header + body
                     return report
                 def __ThreeComparation(self, in_lst):
                     pass
                 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))
                     self.test = list("------\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()