def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setGeometry(200, 200, 300, 300)
self.setWindowTitle("Rebecca's first window!")
self.ui.pushBtn.clicked.connect(self.on_pushButton)
def __init__(self):
super(MainWindow, self).__init__()
# The following 2 lines are in charge of loading the generated python class from the UI file:
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.stopButton.setDisabled(True)
self.ui.selectTestsButton.clicked.connect(
self.add_files_to_tree
) # call method: "add_files_to_tree" when selectTestsButton is pressed
self.ui.selectAllButton.clicked.connect(
self.select_all_files
) # call method: "select_all_files" when selectAllButton is pressed
self.ui.deselectAllButton.clicked.connect(
self.deselect_all_files
) # call method: "deselect_all_files" when deselectAllButton is pressed
self.ui.runButton.clicked.connect(
self.get_checked_tests
) # call method: "get_checked_tests" when runButton is pressed
self.folder_path = ""
self.ui.refreshLogsButton.clicked.connect(
self.refresh_logs
) # call method: "refresh_logs" when refreshLogsButton is pressed
self.is_allowed_to_run = False
self.test_thread = threading.Thread(
target=self.run_tests
) # create thread that run "run_tests" method once it called
self.test_thread.start()
self.tests_to_run = []
self.ui.stopButton.clicked.connect(
self.stop_running_tests
) # call method: "stop_running_tests" when stopButton is pressed
self.process = {}
self.ui.logsArea.verticalScrollBar().rangeChanged.connect(
self.change_scroll
) # automatically call "change_scroll" method when scroll bar range changes
def __init__(self, parent=None):
super(YapayZekaProjeWidget, self).__init__(parent=parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setFixedSize(931, 675)
self.initSlots()
self.functionsUnit()
self.analiz = Analyze(self.ui)
self.ui.btn_startAnalysis.setEnabled(False)
self.ui.actionStop_Cam.setEnabled(False)
self.ui.btn_ayar.setEnabled(False)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
#Load the ui
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
#Set the MainWindow Title
self.setWindowTitle('name of the software - ' + self.version)
#When the software are closed on console the software are closed
signal.signal(signal.SIGINT, signal.SIG_DFL)
#Show the form
self.show()
def __init__(self):
super(MainWindow, self).__init__()
self.paths = []
self.files_names = []
self.checked_paths = []
self.checked = []
self.pids = []
self.process = ""
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.testsTreeWidget.setHeaderHidden(True)
self.setWindowTitle('Mahmoud Shakdan')
#---------------------------------------------------------------------------------------
self.ui.testsButton.clicked.connect(self.choose_dir)
self.ui.testsButton.setToolTip('Click to choose tests')
self.ui.testsButton.setShortcut('Ctrl+A')
self.ui.actionChoose_tests.triggered.connect(self.choose_dir)
# ---------------------------------------------------------------------------------------
self.ui.runButton.clicked.connect(self.run_tests)
self.ui.runButton.setToolTip('Click to run')
self.ui.runButton.setShortcut('Ctrl+P')
self.ui.actionRun.triggered.connect(self.run_tests)
# ---------------------------------------------------------------------------------------
self.ui.clear.clicked.connect(self.clear_tree)
self.ui.clear.setToolTip('Click to clear ')
self.ui.clear.setShortcut('Ctrl+R')
self.ui.actionClear.triggered.connect(self.clear_tree)
# ---------------------------------------------------------------------------------------
self.ui.logsButton.clicked.connect(self.go_to_log_file)
self.ui.logsButton.setToolTip('Click to choose log file to show')
# ---------------------------------------------------------------------------------------
self.ui.G.clicked.connect(self.go_to_log_dir)
self.ui.G.setToolTip('Click to open log directory ')
# ---------------------------------------------------------------------------------------
self.ui.selectButton.clicked.connect(self.select_all)
self.ui.selectButton.setToolTip('Click to select all')
self.ui.selectButton.setShortcut('Ctrl+Alt+S')
self.ui.actionSelect_all.triggered.connect(self.select_all)
# ---------------------------------------------------------------------------------------
self.ui.deselectButton.clicked.connect(self.deselect_all)
self.ui.deselectButton.setToolTip('Click to deselect all')
self.ui.deselectButton.setShortcut('Ctrl+Alt+D')
self.ui.actionDeselect_all.triggered.connect(self.deselect_all)
# ---------------------------------------------------------------------------------------
self.ui.refreshLogsButton.clicked.connect(self.refresh_log)
# ---------------------------------------------------------------------------------------
self.ui.stopButton.clicked.connect(self.kill)
self.ui.stopButton.setToolTip('Click to stop all the tests')
self.ui.stopButton.setShortcut('Ctrl+S')
self.ui.actionStop.triggered.connect(self.deselect_all)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
# Get ui object
self.ui = Ui_MainWindow()
# Initialize ui
self.ui.setupUi(self)
self.isLogging = 0
self.configured = 0
self.sampleLimit = 0
# Initialize event handlers
self.assignWidgets()
self.getSerialPorts()
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setGeometry(200, 200, 300, 300)
self.setWindowTitle("Rebecca's first window!")
self.ui.pushBtn.clicked.connect(self.on_pushButton)
def on_pushButton(self):
# name = self.ui.textEdit1.text()
# self.ui.label3.setText("Welcome " + name)
names = ["Ariel", "David", "Ana", "Oren"]
random.choice(names)
self.ui.pushBtn.setText(random.choice(names))
def __init__ ( self, parent = None ):
QMainWindow.__init__( self, parent )
self.ui = Ui_MainWindow()
self.ui.setupUi( self )
self.setWindowTitle('PenMode-QT - ' + self.version)
self.shell_color = 'QTextEdit { background-color: black; color:#18F018; }'
#Color Shell
self.ui.shellWhatWeb.setStyleSheet(self.shell_color)
self.ui.shellWhatWeb.setReadOnly(True)
self.ui.shellNmap.setStyleSheet(self.shell_color)
self.ui.shellNmap.setReadOnly(True)
self.ui.shellNikto.setStyleSheet(self.shell_color)
self.ui.shellNikto.setReadOnly(True)
self.ui.shellJoomScan.setStyleSheet(self.shell_color)
self.ui.shellJoomScan.setReadOnly(True)
self.ui.shellWpScan.setStyleSheet(self.shell_color)
self.ui.shellWpScan.setReadOnly(True)
self.ui.shellSkipFish.setStyleSheet(self.shell_color)
self.ui.shellSkipFish.setReadOnly(True)
self.ui.shellSqlmap.setStyleSheet(self.shell_color)
self.ui.shellSqlmap.setReadOnly(True)
self.ui.shellSlowLoris.setStyleSheet(self.shell_color)
self.ui.shellSlowLoris.setReadOnly(True)
#Slot
self.ui.pushSocat.clicked.connect(self.startStopSocat)
self.ui.pushTor.clicked.connect(self.startStopTor)
if self.checkSocat() == 1:
self.ui.pushSocat.setText('Enabled')
if self.checkTor() == 1:
self.ui.pushTor.setText('Enabled')
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.show()
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.ser = None
self.receiveData = ReadPort()
self.sendData = WritePort()
self.ui = Ui_MainWindow()
self.setupUi()
class MainWindow ( QMainWindow , Ui_MainWindow):
#Create settings for the software
settings = QSettings('Your Name','Name of the software')
settings.setFallbacksEnabled(False)
version = 'Your version'
def __init__ ( self, parent = None ):
QMainWindow.__init__( self, parent )
#Load the ui
self.ui = Ui_MainWindow()
self.ui.setupUi( self )
#Set the MainWindow Title
self.setWindowTitle('name of the software - ' + self.version)
#When the software are closed on console the software are closed
signal.signal(signal.SIGINT, signal.SIG_DFL)
#Show the form
self.show()
class MainWindow(QMainWindow, Ui_MainWindow):
#Create settings for the software
settings = QSettings('Your Name', 'Name of the software')
settings.setFallbacksEnabled(False)
version = 'Your version'
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
#Load the ui
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
#Set the MainWindow Title
self.setWindowTitle('name of the software - ' + self.version)
#When the software are closed on console the software are closed
signal.signal(signal.SIGINT, signal.SIG_DFL)
#Show the form
self.show()
def __init__ ( self, parent = None ):
QMainWindow.__init__( self, parent )
#Load the ui
self.ui = Ui_MainWindow()
self.ui.setupUi( self )
#Set the MainWindow Title
self.setWindowTitle('name of the software - ' + self.version)
#When the software are closed on console the software are closed
signal.signal(signal.SIGINT, signal.SIG_DFL)
#Show the form
self.show()
def __init__(self, parent=None): super(MainWindow, self).__init__(parent) # Get ui object self.ui = Ui_MainWindow() # Initialize ui self.ui.setupUi(self) self.isLogging = 0 self.configured = 0 self.sampleLimit = 0 # Initialize event handlers self.assignWidgets() self.getSerialPorts()
def __init__(self):
super(QMainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.txtNumber.setValidator(QIntValidator())
self.ui.txtName.textChanged.connect(self.onFilterChanged)
self.ui.txtNumber.textChanged.connect(self.onFilterChanged)
self.ui.btnNewMarble.clicked.connect(self.onNewMarble)
self.ui.btnDeleteMarble.clicked.connect(self.onDeleteMarble)
self.ui.btnSell.clicked.connect(self.onSell)
self.ui.lstMarble.doubleClicked.connect(self.onMarbleDoubleClicked)
self.ui.btnViewSales.clicked.connect(self.showSales)
self.queryModel = QSqlQueryModel()
self.ui.lstMarble.setModel(self.queryModel)
self.db = QSqlDatabase.addDatabase('QSQLITE')
self.db.setDatabaseName('inventory.db')
self.db.open()
self.execSql('''PRAGMA foreign_keys = ON;''')
self.execSql('''CREATE TABLE IF NOT EXISTS `slabs` (
`id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
`name` TEXT NOT NULL,
`num` INTEGER NOT NULL,
`amount` INTEGER NOT NULL,
`dimL` INTEGER NOT NULL,
`dimW` INTEGER NOT NULL,
`dimH` INTEGER NOT NULL,
`notes` TEXT NOT NULL
);''')
self.execSql('''CREATE TABLE IF NOT EXISTS `sales` (
`id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
`slabid` INTEGER NOT NULL,
`date` INTEGER NOT NULL,
`amount` INTEGER NOT NULL,
`leftover` INTEGER NOT NULL,
`buyer` TEXT NOT NULL,
`notes` TEXT NOT NULL,
FOREIGN KEY(slabid) REFERENCES slabs(id)
);''')
self.onFilterChanged()
self.ui.lstMarble.setColumnHidden(0, True)
class MainWindow(QMainWindow):
def __init__(self):
super(QMainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.txtNumber.setValidator(QIntValidator())
self.ui.txtName.textChanged.connect(self.onFilterChanged)
self.ui.txtNumber.textChanged.connect(self.onFilterChanged)
self.ui.btnNewMarble.clicked.connect(self.onNewMarble)
self.ui.btnDeleteMarble.clicked.connect(self.onDeleteMarble)
self.ui.btnSell.clicked.connect(self.onSell)
self.ui.lstMarble.doubleClicked.connect(self.onMarbleDoubleClicked)
self.ui.btnViewSales.clicked.connect(self.showSales)
self.queryModel = QSqlQueryModel()
self.ui.lstMarble.setModel(self.queryModel)
self.db = QSqlDatabase.addDatabase('QSQLITE')
self.db.setDatabaseName('inventory.db')
self.db.open()
self.execSql('''PRAGMA foreign_keys = ON;''')
self.execSql('''CREATE TABLE IF NOT EXISTS `slabs` (
`id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
`name` TEXT NOT NULL,
`num` INTEGER NOT NULL,
`amount` INTEGER NOT NULL,
`dimL` INTEGER NOT NULL,
`dimW` INTEGER NOT NULL,
`dimH` INTEGER NOT NULL,
`notes` TEXT NOT NULL
);''')
self.execSql('''CREATE TABLE IF NOT EXISTS `sales` (
`id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
`slabid` INTEGER NOT NULL,
`date` INTEGER NOT NULL,
`amount` INTEGER NOT NULL,
`leftover` INTEGER NOT NULL,
`buyer` TEXT NOT NULL,
`notes` TEXT NOT NULL,
FOREIGN KEY(slabid) REFERENCES slabs(id)
);''')
self.onFilterChanged()
self.ui.lstMarble.setColumnHidden(0, True)
def onFilterChanged(self):
conditions = []
if self.ui.txtNumber.text() != '':
conditions.append('`num` = %d' % (int(self.ui.txtNumber.text()), ))
if self.ui.txtName.text() != '':
conditions.append("`name` LIKE '%%%s%%'" % (self.ui.txtName.text(), ))
conditionsStr = ''
if len(conditions) != 0:
conditionsStr = ' WHERE ' + ' AND '.join(conditions)
query = "SELECT id, name, num, amount, (dimH||'x'||dimL||'x'||dimW) as dimensions, notes FROM `slabs`" + conditionsStr + ' ORDER BY `name`, `num` ASC;'
print(query)
self.queryModel.setQuery(query, self.db)
def onNewMarble(self):
editMarble = EditMarble()
while True:
result = editMarble.exec()
if result == 0:
return
try:
name, number, amount, dimL, dimH, dimW, notes = editMarble.getValues()
break
except Exception as e:
QMessageBox.critical(self, "Error", "Invalid values entered: " + str(e))
query = '''SELECT `id`, `amount`, `notes` FROM `slabs` WHERE `name`='%s' AND `num`=%d AND `dimL`=%d AND `dimW`=%d AND `dimH`=%d''' % (sqlEscape(name), number, dimL, dimW, dimH)
result = self.execSql(query)
if result == None:
return #TOOD: error dialog? or maybe we should just try to insert?
if result.next() and result.value(2) == notes:
slabId = result.value(0)
previousAmount = result.value(1)
result.finish()
del result
result = None
query = '''UPDATE `slabs` SET `amount`=%d WHERE `id`=%d''' % (previousAmount + amount, slabId)
self.execSql(query)
return
del result
query = '''INSERT INTO `slabs` (`name`, `num`, `amount`, `dimL`, `dimW`, `dimH`, `notes`)
VALUES ('%s', %d, %d, %d, %d, %d, '%s');''' % (sqlEscape(name), number, amount, dimL, dimW, dimH, sqlEscape(notes))
self.execSql(query)
def onDeleteMarble(self):
if len(self.ui.lstMarble.selectedIndexes()) == 0: #nothing selected
QMessageBox.critical(self, "Error", "No slab selected.\nPlease select a slab of marble first")
return
rowIndex = self.ui.lstMarble.selectedIndexes()[0].row()
primaryKey = self.ui.lstMarble.model().data(self.ui.lstMarble.model().index(rowIndex,0));
query = '''DELETE FROM `slabs` WHERE `id` == %d''' % (primaryKey, )
self.execSql(query)
def getSlabData(self, primaryKey):
query = '''SELECT `name`, `num`, `amount`, `dimL`, `dimW`, `dimH`, `notes` FROM `slabs` WHERE id=%d''' % (primaryKey, )
sqlQuery = QSqlQuery(query, self.db);
if not sqlQuery.next(): # user supplied an invalid primary key
QMessageBox.critical(self, "Error", 'slab with id %d was not found' % (primaryKey,))
raise Exception('slab with id %d was not found' % (primaryKey,))
name = sqlQuery.value(0)
number = sqlQuery.value(1)
amount = sqlQuery.value(2)
dimL = sqlQuery.value(3)
dimW = sqlQuery.value(4)
dimH = sqlQuery.value(5)
notes = sqlQuery.value(6)
return name, number, amount, dimL, dimW, dimH, notes
def onMarbleDoubleClicked(self, modelIndex):
rowIndex = modelIndex.row()
primaryKey = self.ui.lstMarble.model().data(self.ui.lstMarble.model().index(rowIndex,0));
name, number, amount, dimL, dimW, dimH, notes = self.getSlabData(primaryKey)
editMarble = EditMarble()
editMarble.setValues(name, number, amount, dimL, dimW, dimH, notes)
result = editMarble.exec()
if result == 0:
return
name, number, amount, dimL, dimH, dimW, notes = editMarble.getValues()
self.execSql('''UPDATE `slabs` SET `name`='%s', `num`=%d, `amount`=%d, `dimL`=%d, `dimW`=%d, `dimH`=%d, `notes`='%s'
WHERE id = %d;''' % (sqlEscape(name), number, amount, dimL, dimW, dimH, sqlEscape(notes), primaryKey))
def execSql(self, query):
print(query)
sqlquery = QSqlQuery(query, self.db)
#self.db.exec(query)
if sqlquery.lastError().number() != -1: #TODO: print these in a dialog box
QMessageBox.critical(self, "Error", 'ERROR OCCURRED WHILE EXECUTING STATEMENT: ' + query + "\n" + \
'Database Text:' + sqlquery.lastError().databaseText() + \
'Databse Driver:' + sqlquery.lastError().driverText())
return None
self.onFilterChanged()
return sqlquery
def onSell(self):
if len(self.ui.lstMarble.selectedIndexes()) == 0: #nothing selected
QMessageBox.critical(self, "Error", "No slab selected.\nPlease select a slab of marble first")
return
rowIndex = self.ui.lstMarble.selectedIndexes()[0].row()
slabPrimaryKey = self.ui.lstMarble.model().data(self.ui.lstMarble.model().index(rowIndex,0));
name, number, amount, dimL, dimW, dimH, notes = self.getSlabData(slabPrimaryKey)
sell = SellDialog(name, number, amount)
result = sell.exec()
if result == 0:
return
amountSold, amountOfLeftovers, buyer, datetime, notes = sell.getValues()
leftoverQueries = []
while amountOfLeftovers > 0:
newMarble = EditMarble()
newMarble.setValues(name, number, amountSold, dimL, dimW, dimH, notes)
newMarble.setMaxAmount(amountOfLeftovers)
result = newMarble.exec()
if result == 0:
return
newName, newNumber, newAmount, newDimL, newDimW, newDimH, newNotes = newMarble.getValues()
leftoverQueries.append('''INSERT INTO `slabs` (`name`, `num`, `amount`, `dimL`, `dimW`, `dimH`, `notes`)
VALUES ('%s', %d, %d, %d, %d, %d, '%s');''' % (sqlEscape(newName), newNumber, newAmount, newDimL, newDimW, newDimH, sqlEscape(newNotes)))
amountOfLeftovers = amountOfLeftovers - newAmount
queryUpdate = '''UPDATE `slabs` SET `amount`=`amount`-%d WHERE id = %d;''' % (amountSold, slabPrimaryKey)
querySale = '''INSERT INTO `sales` (`slabid`, `date`, `amount`, `leftover`, `buyer`, `notes`)
VALUES(%d, %d, %d, 0, '%s', '%s');''' % (slabPrimaryKey, datetime, amountSold, buyer, notes)
self.execSql('BEGIN TRANSACTION;')
self.execSql(queryUpdate)
self.execSql(querySale)
for leftoverQuery in leftoverQueries:
self.execSql(leftoverQuery)
self.execSql('COMMIT;')
self.onFilterChanged()
def showSales(self):
sales = SalesForm(self.db)
sales.exec()
class MainWindow(QtGui.QMainWindow):
# Constructor
# Initializes ui
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
# Get ui object
self.ui = Ui_MainWindow()
# Initialize ui
self.ui.setupUi(self)
self.isLogging = 0
self.configured = 0
self.sampleLimit = 0
# Initialize event handlers
self.assignWidgets()
self.getSerialPorts()
# Event handler assignments
def assignWidgets(self):
# Quick Measurement
self.ui.quickResHelp.clicked.connect(self.showHelp)
self.ui.quickTakeMeasurement.clicked.connect(self.quickMeasurement)
# Settings
self.ui.connectToDevice.clicked.connect(self.connect)
self.ui.beepEnable.stateChanged.connect(self.beeperControl)
self.ui.displayEnable.stateChanged.connect(self.displayControl)
self.ui.systReset.clicked.connect(self.reset)
self.ui.viewErrors.clicked.connect(self.showErrors)
# Logging
self.ui.logFileBrowse.clicked.connect(self.getLogFilePath)
self.ui.logResHelp.clicked.connect(self.showHelp)
self.ui.logStart.clicked.connect(self.configureRepeat)
self.ui.loggingStop.clicked.connect(self.loggingStop)
self.ui.dataNotes.returnPressed.connect(self.configureRepeat)
def showHelp(self):
self.reshelp.show()
# Load file from server serialBaudRate
def connect(self):
self.dmm = DMM34401A(self.ui.serialDevice.currentText(),self.ui.serialBaudRate.currentText(),self.ui.serialParity.currentText() )
self.reset()
# Load file from server
def reset(self):
self.dmm.reset()
delay = 1
self.dmm.setdisplayText("AkBKukU")
time.sleep(delay)
self.dmm.setdisplayClear()
self.dmm.setSampleCount(1)
self.dmm.setTriggerDelay(0)
def showErrors(self):
QtGui.QMessageBox.information(
self,
'Stored Errors',
self.dmm.errorCheck(),
0
)
# Load file from server
def beeperControl(self):
self.dmm.setBeeper(self.ui.beepEnable.checkState())
# Load file from server
def displayControl(self):
self.dmm.setdisplay(self.ui.displayEnable.checkState())
# Open a dialog to get a filepath for the log
def getLogFilePath(self):
fileName , other= QtGui.QFileDialog.getSaveFileName(self, 'Save log as', '', selectedFilter='*.csv')
# Add ".csv" to the end of the filename if not present
if( not fileName.endswith(".csv") ):
fileName = str(fileName)+".csv"
print fileName
# Set the text input to the file path
self.ui.logFilePath.setText(str(fileName))
# Get measurement from DMM and put it in last measurement
def quickMeasurement(self):
self.dmm.setMeasurementMode(self.ui.quickMeasureMode.currentIndex())
self.dmm.setResolution(self.ui.quickResOverload.text(),self.ui.quickResLowerLimit.text())
reading = self.dmm.takeMeasurement()
print str(reading)
reading = float(reading[0])
self.setLastMesurement(reading,self.dmm.getModeName())
# Set the last measured feilds
def setLastMesurement(self,value,mode):
self.ui.lastMeasurement.setText(str(value))
self.ui.lastMeasureMode.setText(str(mode))
# Get a list of all availible serial port to give the user
def getSerialPorts(self):
if sys.platform.startswith('win'):
ports = ['COM%s' % (i + 1) for i in range(256)]
elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
# this excludes your current terminal "/dev/tty"
ports = glob.glob('/dev/tty[A-Za-z]*')
elif sys.platform.startswith('darwin'):
ports = glob.glob('/dev/tty.*')
else:
raise EnvironmentError('Unsupported platform')
result = []
for port in ports:
try:
s = serial.Serial(port)
s.close()
result.append(port)
except (OSError, serial.SerialException):
pass
for device in result:
self.ui.serialDevice.addItem(device)
# Logging start button logic
def configureRepeat(self):
if( self.isLogging == 0) :
# Inital configureation for log session
if( self.configured == 0) :
print "Configure Logging"
# Update DMM with current settings
self.dmm.setMeasurementMode(self.ui.logMeasureMode.currentIndex())
self.dmm.setResolution(self.ui.logResOverload.text(),self.ui.logResLowerLimit.text())
self.dmm.setSampleCount(self.ui.logTriggerSampleCount.value())
self.dmm.setTriggerDelay(self.ui.logTriggerSampleDelay.value())
# Set logic variables
self.configured = 1
self.isLogging = 1
self.stopLogging = 0
# Clear file if set to replace
if( not self.ui.logFilePath.text() == "" ):
print "Opening the file..."
if(self.ui.logReplace.isChecked()):
logFile = open(self.ui.logFilePath.text(), 'w')
logFile.truncate()
logFile.close()
# Automatic mode configure
if( self.ui.logTrigSource.currentIndex() == 0) :
# Start timer to call function
self.logtimer = QtCore.QTimer(self)
self.logtimer.timeout.connect(self.repeatAction)
self.logtimer.start((self.ui.logAutoInterval.value() * 1000))
# Set the limit of samples to take
self.sampleLimit = self.ui.logAutoSamplesMax.value()
self.ui.logStart.setText("Stop Logging")
# Manual mode configure
if( self.ui.logTrigSource.currentIndex() == 1) :
self.isLogging = 1
self.configured = 1
carryOutLog = 1
self.ui.logStart.setText("Take Measurement")
else:
# Manual mode Take sample
if( self.ui.logTrigSource.currentIndex() == 1) :
self.isLogging = 1
self.configured = 1
carryOutLog = 1
self.repeatAction()
self.ui.logStart.setText("Take Measurement")
# Default
else:
self.ui.logStart.setText("Start Logging")
self.stopLogging = 1
self.isLogging = 0
self.configured = 0
# End loggin session
def loggingStop(self):
self.stopLogging = 1
self.ui.logStart.setText("Start Logging")
self.isLogging = 0
self.configured = 0
# Log function to collect and store data
def repeatAction(self):
print "Log Action"
# Keep filepath from changing
self.ui.logFilePath.setReadOnly(True)
# Check if loggin over
if( self.stopLogging ):
self.logtimer.stop()
self.ui.logFilePath.setReadOnly(False)
else:
# Get measurement from DMM
reading = self.dmm.takeMeasurement()
# Convert from list of strings to list of floats
reading = np.array(map(float, reading))
# Set last measurement
self.setLastMesurement(reading[0],self.dmm.getModeName())
# Check if samples are limited and subtract 1
if( not self.ui.logAutoSamplesLimit.isChecked() ):
self.sampleLimit -= 1
# Stop measuring when limit reached
if( not self.sampleLimit ):
self.loggingStop()
# Check if file is set
if( not self.ui.logFilePath.text() == "" ):
# Log data to file
parsed = str(reading).replace("[ ","").replace("[","").replace("]","").replace(" ",",").replace(" ",",")
logFile = open(self.ui.logFilePath.text(), 'a')
now = '%s' % datetime.datetime.now()
date, time = now.split(" ")
notes = self.ui.dataNotes.text()
logFile.write(str(date)+","+str(time)+","+str(notes)+","+parsed+"\n")
logFile.close()
class MainWindow ( QMainWindow , Ui_MainWindow):
#var initialization
settings = QSettings('Phos','Penmode')
settings.setFallbacksEnabled(False)
version = 'V 0.1 Alpha'
def __init__ ( self, parent = None ):
QMainWindow.__init__( self, parent )
self.ui = Ui_MainWindow()
self.ui.setupUi( self )
self.setWindowTitle('PenMode-QT - ' + self.version)
self.shell_color = 'QTextEdit { background-color: black; color:#18F018; }'
#Color Shell
self.ui.shellWhatWeb.setStyleSheet(self.shell_color)
self.ui.shellWhatWeb.setReadOnly(True)
self.ui.shellNmap.setStyleSheet(self.shell_color)
self.ui.shellNmap.setReadOnly(True)
self.ui.shellNikto.setStyleSheet(self.shell_color)
self.ui.shellNikto.setReadOnly(True)
self.ui.shellJoomScan.setStyleSheet(self.shell_color)
self.ui.shellJoomScan.setReadOnly(True)
self.ui.shellWpScan.setStyleSheet(self.shell_color)
self.ui.shellWpScan.setReadOnly(True)
self.ui.shellSkipFish.setStyleSheet(self.shell_color)
self.ui.shellSkipFish.setReadOnly(True)
self.ui.shellSqlmap.setStyleSheet(self.shell_color)
self.ui.shellSqlmap.setReadOnly(True)
self.ui.shellSlowLoris.setStyleSheet(self.shell_color)
self.ui.shellSlowLoris.setReadOnly(True)
#Slot
self.ui.pushSocat.clicked.connect(self.startStopSocat)
self.ui.pushTor.clicked.connect(self.startStopTor)
if self.checkSocat() == 1:
self.ui.pushSocat.setText('Enabled')
if self.checkTor() == 1:
self.ui.pushTor.setText('Enabled')
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.show()
def checkSocat(self):
stdout = Popen('(ps caux | grep socat)', shell=True, stdout=PIPE).stdout
stdout = str(stdout.read()).replace("b''",'')
if stdout != '':
return 1
else:
return 0
def startStopSocat(self):
if self.checkSocat() == 1:
Popen('killall socat', shell=True, stdout=PIPE)
self.ui.pushSocat.setText('Enable')
else:
Popen('socat TCP4-LISTEN:8080,fork SOCKS4a:127.0.0.1:$ip,socksport=9050 &', shell=True, stdout=PIPE)
self.ui.pushSocat.setText('Disable')
def checkTor(self):
stdout = Popen('ps aux | grep torrc | grep -v grep', shell=True, stdout=PIPE).stdout
stdout = str(stdout.read()).replace("b''",'')
if stdout != '':
return 1
else:
return 0
def startStopTor(self):
if self.checkTor() == 1:
Popen('su-to-root -X -c /etc/init.d/tor stop', shell=True, stdout=PIPE)
self.ui.pushSocat.setText('Enable')
else:
Popen('su-to-root -X -c /etc/init.d/tor start', shell=True, stdout=PIPE)
self.ui.pushSocat.setText('Disable')
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
# The following 2 lines are in charge of loading the generated python class from the UI file:
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.stopButton.setDisabled(True)
self.ui.selectTestsButton.clicked.connect(
self.add_files_to_tree
) # call method: "add_files_to_tree" when selectTestsButton is pressed
self.ui.selectAllButton.clicked.connect(
self.select_all_files
) # call method: "select_all_files" when selectAllButton is pressed
self.ui.deselectAllButton.clicked.connect(
self.deselect_all_files
) # call method: "deselect_all_files" when deselectAllButton is pressed
self.ui.runButton.clicked.connect(
self.get_checked_tests
) # call method: "get_checked_tests" when runButton is pressed
self.folder_path = ""
self.ui.refreshLogsButton.clicked.connect(
self.refresh_logs
) # call method: "refresh_logs" when refreshLogsButton is pressed
self.is_allowed_to_run = False
self.test_thread = threading.Thread(
target=self.run_tests
) # create thread that run "run_tests" method once it called
self.test_thread.start()
self.tests_to_run = []
self.ui.stopButton.clicked.connect(
self.stop_running_tests
) # call method: "stop_running_tests" when stopButton is pressed
self.process = {}
self.ui.logsArea.verticalScrollBar().rangeChanged.connect(
self.change_scroll
) # automatically call "change_scroll" method when scroll bar range changes
# this method operates the folders browser and then adds all the JS files's from the chosen folder to the test list
def add_files_to_tree(self):
# open folders browser and get folder's path:
self.folder_path = QFileDialog.getExistingDirectory(
None, "message", "base_path", QFileDialog.ShowDirsOnly)
if self.folder_path: # if any folder has chosen
# get names of all JS test files from the chosen folder:
files_list = os.listdir(
self.folder_path
) # get list of all of the files in the chosen folder
js_files_list = []
for file_name in files_list: # for each file in the chosen folder
splitted_file_name = file_name.lower(
) # transform file_name to lower cased
splitted_file_name = splitted_file_name.split(
".") # split file_name to list of file name + file type
if file_name.endswith(
".js"
): # if the file name ends with ".js" (i.e. it's a JS file)
if splitted_file_name[0].startswith(
"test") or splitted_file_name[0].endswith("test"):
js_files_list.append(
file_name) # add it to the js files list
# add all JS files to the tests list:
for js_file_name in js_files_list:
file_to_add = QTreeWidgetItem([js_file_name])
self.ui.testsList.addTopLevelItem(file_to_add)
file_to_add.setCheckState(0, QtCore.Qt.Unchecked)
# this method selects the checkboxes of all the files in the tests list
def select_all_files(self):
for i in range(self.ui.testsList.topLevelItemCount()
): # for each item in the tree
self.ui.testsList.topLevelItem(i).setCheckState(
0, QtCore.Qt.Checked) # check checkbox
# this method deselects the checkboxes of all the files in the tests list
def deselect_all_files(self):
for i in range(self.ui.testsList.topLevelItemCount()
): # for each item in the tree
self.ui.testsList.topLevelItem(i).setCheckState(
0, QtCore.Qt.Unchecked) # uncheck checkbox
# this method create a list of the checked tests and then call the test_thread to run the tests from this list
def get_checked_tests(self):
self.tests_to_run = [] # list of test to run
# before start running - set Run button and tests list to be disabled, and Stop button to be enabled:
self.ui.runButton.setDisabled(True)
self.ui.stopButton.setEnabled(True)
self.ui.testsList.setDisabled(True)
# get checked tests:
for i in range(self.ui.testsList.topLevelItemCount()
): # for each test file in the tree
if self.ui.testsList.topLevelItem(i).checkState(
0
) == QtCore.Qt.Checked: # if the test's checkbox is checked
test_file_name = self.ui.testsList.topLevelItem(i).text(
0) # get test's file name
self.tests_to_run.append(
test_file_name) # add it to "tests_to_run" list
self.is_allowed_to_run = True # allow running tests (because runButton was pressed)
# this method run the checked tests (method runs as a thread):
def run_tests(self):
while True: # endless loop
if self.is_allowed_to_run: # i.e. run button was pressed
for test_to_run in self.tests_to_run: # for each checked test:
if not self.is_allowed_to_run: # i.e stop button was pressed
break
self.process = Popen(
['node', self.folder_path + '/' + test_to_run],
stdout=PIPE,
stderr=PIPE,
text=True) # execute it
stdout, stderr = self.process.communicate()
# after done running - set Run button and tests list to be enabled, and Stop button to be disabled:
self.ui.runButton.setEnabled(True)
self.ui.stopButton.setDisabled(True)
self.ui.testsList.setEnabled(True)
self.is_allowed_to_run = False
else: # i.e. no tests to run
time.sleep(
0.5
) # don't take resources from the CPU while there are no tests to run
# this method stops the running of the tests
def stop_running_tests(self):
self.is_allowed_to_run = False # NOT allow running tests (because stopButton was pressed)
self.process.kill()
# this method cleans the logs area and then reload the logs
def refresh_logs(self):
# clear the logs area:
self.ui.logsArea.clear()
# read the logs file:
logs_file = open("logs/log.log")
logs_text = logs_file.read() # the text from the log file
# add logs text to the logs area:
self.ui.logsArea.insertPlainText(logs_text)
# this method get min&max position of scrollbar from callback and set the position to max (bottom)
def change_scroll(self, min, max):
self.ui.logsArea.ensureCursorVisible()
self.ui.logsArea.verticalScrollBar().setSliderPosition(max)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.paths = []
self.files_names = []
self.checked_paths = []
self.checked = []
self.pids = []
self.process = ""
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.testsTreeWidget.setHeaderHidden(True)
self.setWindowTitle('Mahmoud Shakdan')
#---------------------------------------------------------------------------------------
self.ui.testsButton.clicked.connect(self.choose_dir)
self.ui.testsButton.setToolTip('Click to choose tests')
self.ui.testsButton.setShortcut('Ctrl+A')
self.ui.actionChoose_tests.triggered.connect(self.choose_dir)
# ---------------------------------------------------------------------------------------
self.ui.runButton.clicked.connect(self.run_tests)
self.ui.runButton.setToolTip('Click to run')
self.ui.runButton.setShortcut('Ctrl+P')
self.ui.actionRun.triggered.connect(self.run_tests)
# ---------------------------------------------------------------------------------------
self.ui.clear.clicked.connect(self.clear_tree)
self.ui.clear.setToolTip('Click to clear ')
self.ui.clear.setShortcut('Ctrl+R')
self.ui.actionClear.triggered.connect(self.clear_tree)
# ---------------------------------------------------------------------------------------
self.ui.logsButton.clicked.connect(self.go_to_log_file)
self.ui.logsButton.setToolTip('Click to choose log file to show')
# ---------------------------------------------------------------------------------------
self.ui.G.clicked.connect(self.go_to_log_dir)
self.ui.G.setToolTip('Click to open log directory ')
# ---------------------------------------------------------------------------------------
self.ui.selectButton.clicked.connect(self.select_all)
self.ui.selectButton.setToolTip('Click to select all')
self.ui.selectButton.setShortcut('Ctrl+Alt+S')
self.ui.actionSelect_all.triggered.connect(self.select_all)
# ---------------------------------------------------------------------------------------
self.ui.deselectButton.clicked.connect(self.deselect_all)
self.ui.deselectButton.setToolTip('Click to deselect all')
self.ui.deselectButton.setShortcut('Ctrl+Alt+D')
self.ui.actionDeselect_all.triggered.connect(self.deselect_all)
# ---------------------------------------------------------------------------------------
self.ui.refreshLogsButton.clicked.connect(self.refresh_log)
# ---------------------------------------------------------------------------------------
self.ui.stopButton.clicked.connect(self.kill)
self.ui.stopButton.setToolTip('Click to stop all the tests')
self.ui.stopButton.setShortcut('Ctrl+S')
self.ui.actionStop.triggered.connect(self.deselect_all)
def choose_dir(self):
self.dir = QFileDialog.getExistingDirectory(self, 'Select Directory',
'c:/')
# The QFileDialog class enables a user to traverse the file system in order to select one or many files or a directory.
# return a (<class 'str'>) the path of the directory
if self.dir:
for get_tests in os.listdir(self.dir):
# The method listdir() returns a list containing the names of the entries in the directory given by path. The list is in arbitrary order.
if get_tests.endswith(
'Test.js'
): # The endswith() method returns a boolean.
self.paths.append(self.dir)
self.files_names.append(get_tests)
item = QTreeWidgetItem(self.ui.testsTreeWidget,
[get_tests])
item.setCheckState(0, QtCore.Qt.Unchecked)
#Tree widget items are used to hold rows of information for tree widgets. Rows usually contain several columns of data, each of which can contain a text label and an icon.
#The QTreeWidgetItem class is a convenience class that replaces the QListViewItem class in Qt 3. It provides an item for use with the QTreeWidget class.
#Returns the check box’s check state
# https://stackoverflow.com/questions/31342228/pyqt-tree-widget-adding-check-boxes-for-dynamic-removal
def clear_tree(self):
self.ui.testsTreeWidget.clear()
# The QTreeWidgetItemIterator class provides a way to iterate over the items in a QtGui.QTreeWidget instance.
# The iterator will walk the items in a pre-order traversal order, thus visiting the parent node before it continues to the child nodes.
def run_tests(self):
iterator = QTreeWidgetItemIterator(self.ui.testsTreeWidget)
i = 0
while iterator.value():
if (iterator.value()).checkState(0):
self.checked.append((iterator.value()).text(0))
self.checked_paths.append(self.paths[i])
i += 1
iterator += 1
t = threading.Thread(target=self.run_threads)
t.start()
def run_threads(self):
m = 'node '
for i in range(0, len(self.checked_paths)):
if i != 0:
m += f" && node {self.checked_paths[i]}/{self.checked[i]}"
else:
m += f"{self.checked_paths[i]}/{self.checked[i]}"
print(m)
# self.process = Popen(m, shell=True)
#https://medium.com/python-pandemonium/a-trap-of-shell-true-in-the-subprocess-module-6db7fc66cdfd
# when we want to kill just and only the running test the nwe need to use this :
# for i in range(0, len(self.checked_paths)):
# self.process = Popen(['Node', self.checked_paths[i] + '/' + self.checked[i]], shell=True)
# self.process.communicate()
def kill(self):
process = psutil.Process(self.process.pid)
for proc in process.children(recursive=True):
proc.kill()
process.kill()
# https://stackoverflow.com/questions/6549669/how-to-kill-process-and-child-processes-from-python
#https://psutil.readthedocs.io/en/latest/
def go_to_log_file(self):
self.specific_log = QFileDialog.getOpenFileName(
self, "Select Log File")
# print(self.specific_log)
log_file_name = os.path.basename(self.specific_log[0])
# print(log_file_name)
log_file_path = self.specific_log[0][:(len(self.specific_log[0]) -
(len(log_file_name)))]
# print(log_file_path)
os.chdir(log_file_path)
the_file = open(log_file_name)
texter = the_file.read()
print(texter)
self.ui.textEdit.setText(texter)
def go_to_log_dir(self):
os.startfile(sys.path[0] + "\log")
def select_all(self):
iterator = QTreeWidgetItemIterator(self.ui.testsTreeWidget)
while iterator.value():
item = iterator.value()
item.setCheckState(0, Qt.Checked)
iterator += 1
def deselect_all(self):
iterator = QTreeWidgetItemIterator(self.ui.testsTreeWidget)
while iterator.value():
item = iterator.value()
item.setCheckState(0, Qt.Unchecked)
iterator += 1
def refresh_log(self):
print(self.checked_paths)
print(self.checked)
class YapayZekaProjeWidget(QMainWindow):
def __init__(self, parent=None):
super(YapayZekaProjeWidget, self).__init__(parent=parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setFixedSize(931, 675)
self.initSlots()
self.functionsUnit()
self.analiz = Analyze(self.ui)
self.ui.btn_startAnalysis.setEnabled(False)
self.ui.actionStop_Cam.setEnabled(False)
self.ui.btn_ayar.setEnabled(False)
def analyze(self):
QMessageBox.information(self, "Bilgi", "Analiz Başlıyor...")
self.analiz.getImage(self.copyImage)
self.analiz.run()
def functionsUnit(self):
faceProto = "models/opencv_face_detector.pbtxt"
faceModel = "models/opencv_face_detector_uint8.pb"
ageProto = "models/age_deploy.prototxt"
ageModel = "models/age_net.caffemodel"
genderProto = "models/gender_deploy.prototxt"
genderModel = "models/gender_net.caffemodel"
self.MODEL_MEAN_VALUES = (78.4263377603, 87.7689143744, 114.895847746)
self.ageList = [
'(0-2)', '(4-6)', '(8-12)', '(15-20)', '(25-32)', '(38-43)',
'(48-53)', '(60-100)'
]
self.genderList = ['Erkek', 'Kadın']
self.padding = 20
self.faceNet = cv2.dnn.readNet(faceModel, faceProto)
self.ageNet = cv2.dnn.readNet(ageModel, ageProto)
self.genderNet = cv2.dnn.readNet(genderModel, genderProto)
self.copyImage = None
self.input_shape = (224, 224)
def initSlots(self):
self.kontrol = False
self.ui.actionResim_Ekle.triggered.connect(self.getImageFromFile)
self.ui.btn_ayar.clicked.connect(self.loadModels)
self.ui.actionStart_Cam.triggered.connect(self.startCam)
self.ui.actionStop_Cam.triggered.connect(self.stopWebCam)
self.ui.btn_startAnalysis.clicked.connect(self.analyze)
self.ui.actionExit.triggered.connect(
lambda: QtCore.QCoreApplication.instance().quit())
def startCam(self):
self.ui.btn_startAnalysis.setEnabled(True)
self.ui.actionStop_Cam.setEnabled(True)
self.capture = cv2.VideoCapture(0)
self.Kontrol = True
self.capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 607)
self.capture.set(cv2.CAP_PROP_FRAME_WIDTH, 576)
self.timer = QTimer(self)
self.timer.timeout.connect(self.update_frame)
self.timer.start(1000. / 24)
def update_frame(self):
ret, self.frame = self.capture.read()
self.copyImage = self.frame.copy()
resultImg, faceBoxes = highlightFace(self.faceNet, self.frame)
for faceBox in faceBoxes:
face = self.frame[
max(0, faceBox[1] -
self.padding):min(faceBox[3] +
self.padding, self.frame.shape[0] - 1),
max(0, faceBox[0] -
self.padding):min(faceBox[2] +
self.padding, self.frame.shape[1] - 1)]
blob = cv2.dnn.blobFromImage(face,
1.0, (227, 227),
self.MODEL_MEAN_VALUES,
swapRB=False)
self.genderNet.setInput(blob)
genderPreds = self.genderNet.forward()
gender = self.genderList[genderPreds[0].argmax()]
self.ageNet.setInput(blob)
agePreds = self.ageNet.forward()
age = self.ageList[agePreds[0].argmax()]
cv2.putText(resultImg, f'{gender}, {age}',
(faceBox[0], faceBox[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 255), 2,
cv2.LINE_AA)
self.displayImage(resultImg)
def displayImage(self, img):
qFormat = QImage.Format_Indexed8
if len(img.shape) == 3:
if img.shape[2] == 4:
qFormat = QImage.Format_RGBA8888
else:
qFormat = QImage.Format_RGB888
outImage = QImage(img, img.shape[1], img.shape[0], img.strides[0],
qFormat)
# BGR to RGB
self.outImage = outImage.rgbSwapped()
self.ui.label.setPixmap(QPixmap.fromImage(self.outImage))
self.ui.label.setScaledContents(True)
def stopWebCam(self):
self.capture.release()
self.timer.stop()
def getImageFromFile(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(
self,
"QFileDialog.getOpenFileName()",
"",
"PNG Files (*.png);;JPG Files (*.jpg) ",
options=options)
if fileName:
print(fileName)
self.resim = str(fileName)
self.loadImage(fileName)
self.ui.btn_ayar.setEnabled(True)
else:
self.resimCheck = False
def loadImage(self, fileName):
self.ImageStudentPath = fileName
self.ui.lbl_foto.setPixmap(QPixmap(self.ImageStudentPath))
self.ui.lbl_foto.setScaledContents(True)
def loadModels(self):
self.ui.lbl_cinsiyet.clear()
self.ui.lbl_duygu.clear()
self.ui.lbl_yas.clear()
self.ui.lbl_irk.clear()
QMessageBox.information(self, "Bilgi", "Analiz Başlıyor...")
path = self.resim
img = cv2.imread(path)
resp = DeepFace.analyze(img)
if self.ui.cins_check.isChecked():
self.ui.lbl_cinsiyet.setText(str(resp["gender"]))
if self.ui.duygu_check.isChecked():
self.ui.lbl_duygu.setText(str(resp["dominant_emotion"]))
if self.ui.yas_check.isChecked():
self.ui.lbl_yas.setText(str(round(resp["age"])))
if self.ui.irk_check.isChecked():
self.ui.lbl_irk.setText(str(resp["dominant_race"]))
class MainWindow(QtGui.QMainWindow):
# Constructor
# Initializes ui
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
# Get ui object
self.ui = Ui_MainWindow()
# Initialize ui
self.ui.setupUi(self)
self.isLogging = 0
self.configured = 0
self.sampleLimit = 0
# Initialize event handlers
self.assignWidgets()
self.getSerialPorts()
# Event handler assignments
def assignWidgets(self):
# Quick Measurement
self.ui.quickResHelp.clicked.connect(self.showHelp)
self.ui.quickTakeMeasurement.clicked.connect(self.quickMeasurement)
# Settings
self.ui.connectToDevice.clicked.connect(self.connect)
self.ui.beepEnable.stateChanged.connect(self.beeperControl)
self.ui.displayEnable.stateChanged.connect(self.displayControl)
self.ui.systReset.clicked.connect(self.reset)
self.ui.viewErrors.clicked.connect(self.showErrors)
# Logging
self.ui.logFileBrowse.clicked.connect(self.getLogFilePath)
self.ui.logResHelp.clicked.connect(self.showHelp)
self.ui.logStart.clicked.connect(self.configureRepeat)
self.ui.loggingStop.clicked.connect(self.loggingStop)
self.ui.dataNotes.returnPressed.connect(self.configureRepeat)
def showHelp(self):
self.reshelp.show()
# Load file from server serialBaudRate
def connect(self):
self.dmm = DMM34401A(self.ui.serialDevice.currentText(),
self.ui.serialBaudRate.currentText(),
self.ui.serialParity.currentText())
self.reset()
# Load file from server
def reset(self):
self.dmm.reset()
delay = 1
self.dmm.setdisplayText("AkBKukU")
time.sleep(delay)
self.dmm.setdisplayClear()
self.dmm.setSampleCount(1)
self.dmm.setTriggerDelay(0)
def showErrors(self):
QtGui.QMessageBox.information(self, 'Stored Errors',
self.dmm.errorCheck(), 0)
# Load file from server
def beeperControl(self):
self.dmm.setBeeper(self.ui.beepEnable.checkState())
# Load file from server
def displayControl(self):
self.dmm.setdisplay(self.ui.displayEnable.checkState())
# Open a dialog to get a filepath for the log
def getLogFilePath(self):
fileName, other = QtGui.QFileDialog.getSaveFileName(
self, 'Save log as', '', selectedFilter='*.csv')
# Add ".csv" to the end of the filename if not present
if (not fileName.endswith(".csv")):
fileName = str(fileName) + ".csv"
print fileName
# Set the text input to the file path
self.ui.logFilePath.setText(str(fileName))
# Get measurement from DMM and put it in last measurement
def quickMeasurement(self):
self.dmm.setMeasurementMode(self.ui.quickMeasureMode.currentIndex())
self.dmm.setResolution(self.ui.quickResOverload.text(),
self.ui.quickResLowerLimit.text())
reading = self.dmm.takeMeasurement()
print str(reading)
reading = float(reading[0])
self.setLastMesurement(reading, self.dmm.getModeName())
# Set the last measured feilds
def setLastMesurement(self, value, mode):
self.ui.lastMeasurement.setText(str(value))
self.ui.lastMeasureMode.setText(str(mode))
# Get a list of all availible serial port to give the user
def getSerialPorts(self):
if sys.platform.startswith('win'):
ports = ['COM%s' % (i + 1) for i in range(256)]
elif sys.platform.startswith('linux') or sys.platform.startswith(
'cygwin'):
# this excludes your current terminal "/dev/tty"
ports = glob.glob('/dev/tty[A-Za-z]*')
elif sys.platform.startswith('darwin'):
ports = glob.glob('/dev/tty.*')
else:
raise EnvironmentError('Unsupported platform')
result = []
for port in ports:
try:
s = serial.Serial(port)
s.close()
result.append(port)
except (OSError, serial.SerialException):
pass
for device in result:
self.ui.serialDevice.addItem(device)
# Logging start button logic
def configureRepeat(self):
if (self.isLogging == 0):
# Inital configureation for log session
if (self.configured == 0):
print "Configure Logging"
# Update DMM with current settings
self.dmm.setMeasurementMode(
self.ui.logMeasureMode.currentIndex())
self.dmm.setResolution(self.ui.logResOverload.text(),
self.ui.logResLowerLimit.text())
self.dmm.setSampleCount(self.ui.logTriggerSampleCount.value())
self.dmm.setTriggerDelay(self.ui.logTriggerSampleDelay.value())
# Set logic variables
self.configured = 1
self.isLogging = 1
self.stopLogging = 0
# Clear file if set to replace
if (not self.ui.logFilePath.text() == ""):
print "Opening the file..."
if (self.ui.logReplace.isChecked()):
logFile = open(self.ui.logFilePath.text(), 'w')
logFile.truncate()
logFile.close()
# Automatic mode configure
if (self.ui.logTrigSource.currentIndex() == 0):
# Start timer to call function
self.logtimer = QtCore.QTimer(self)
self.logtimer.timeout.connect(self.repeatAction)
self.logtimer.start((self.ui.logAutoInterval.value() * 1000))
# Set the limit of samples to take
self.sampleLimit = self.ui.logAutoSamplesMax.value()
self.ui.logStart.setText("Stop Logging")
# Manual mode configure
if (self.ui.logTrigSource.currentIndex() == 1):
self.isLogging = 1
self.configured = 1
carryOutLog = 1
self.ui.logStart.setText("Take Measurement")
else:
# Manual mode Take sample
if (self.ui.logTrigSource.currentIndex() == 1):
self.isLogging = 1
self.configured = 1
carryOutLog = 1
self.repeatAction()
self.ui.logStart.setText("Take Measurement")
# Default
else:
self.ui.logStart.setText("Start Logging")
self.stopLogging = 1
self.isLogging = 0
self.configured = 0
# End loggin session
def loggingStop(self):
self.stopLogging = 1
self.ui.logStart.setText("Start Logging")
self.isLogging = 0
self.configured = 0
# Log function to collect and store data
def repeatAction(self):
print "Log Action"
# Keep filepath from changing
self.ui.logFilePath.setReadOnly(True)
# Check if loggin over
if (self.stopLogging):
self.logtimer.stop()
self.ui.logFilePath.setReadOnly(False)
else:
# Get measurement from DMM
reading = self.dmm.takeMeasurement()
# Convert from list of strings to list of floats
reading = np.array(map(float, reading))
# Set last measurement
self.setLastMesurement(reading[0], self.dmm.getModeName())
# Check if samples are limited and subtract 1
if (not self.ui.logAutoSamplesLimit.isChecked()):
self.sampleLimit -= 1
# Stop measuring when limit reached
if (not self.sampleLimit):
self.loggingStop()
# Check if file is set
if (not self.ui.logFilePath.text() == ""):
# Log data to file
parsed = str(reading).replace("[ ", "").replace(
"[", "").replace("]", "").replace(" ",
",").replace(" ", ",")
logFile = open(self.ui.logFilePath.text(), 'a')
now = '%s' % datetime.datetime.now()
date, time = now.split(" ")
notes = self.ui.dataNotes.text()
logFile.write(
str(date) + "," + str(time) + "," + str(notes) + "," +
parsed + "\n")
logFile.close()
def __init__(self):
super(MainWindow, self).__init__()
ui = Ui_MainWindow()
ui.setupUi(self)
ui.pushButton.clicked.connect(self.click_agregar)
class MainWindow(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.ser = None
self.receiveData = ReadPort()
self.sendData = WritePort()
self.ui = Ui_MainWindow()
self.setupUi()
def closeEvent(self, event):
self.closePort()
QMainWindow.closeEvent(self, event)
def setupUi(self):
self.ui.setupUi(self)
self.ui.comboBox_Bandrate.addItems(baudRates)
self.refreshComboBoxPortName()
# TODO QObject.connect(self.ui.comboBox_PortName, SIGNAL("activated()"), self.refreshComboBoxPortName)
self.ui.pushButton_OpenPort.clicked.connect(self.openPort)
self.ui.pushButton_ClosePort.clicked.connect(self.closePort)
self.ui.pushButton_SendCmd.clicked.connect(self.sendCommand)
self.receiveData.newData.connect(self.printComPortData)
self.receiveData.error.connect(self.printError)
self.sendData.error.connect(self.printError)
def refreshComboBoxPortName(self):
self.ui.comboBox_PortName.clear()
self.ui.comboBox_PortName.addItems(self.getPortName())
def getPortName(self):
portNames = []
try:
for port in serial.tools.list_ports.comports():
portNames.append(port[0])
except:
portNames.append("null")
self.printError("Failed to scan port!")
return portNames
def getPortConfig(self):
" Get port setting from ui "
return self.ui.comboBox_PortName.currentText()
def getBandRateConfig(self):
" Get baudrate setting from ui "
return self.ui.comboBox_Bandrate.currentText()
def printComPortData(self, text):
self.ui.plainTextEdit_txtDisplay.moveCursor(QTextCursor.End)
self.ui.plainTextEdit_txtDisplay.insertPlainText(text)
self.ui.plainTextEdit_txtDisplay.moveCursor(QTextCursor.End)
def printInfo(self, text):
" Print information to ui "
self.ui.plainTextEdit_txtDisplay.appendPlainText(text)
self.ui.plainTextEdit_txtDisplay.moveCursor(QTextCursor.End)
def printError(self, text):
" Print error to ui "
self.ui.plainTextEdit_txtDisplay.appendPlainText(text)
self.ui.plainTextEdit_txtDisplay.moveCursor(QTextCursor.End)
def printCommand(self, text):
" Print error to ui "
self.ui.plainTextEdit_txtDisplay.appendPlainText("> " + text + "\n")
self.ui.plainTextEdit_txtDisplay.moveCursor(QTextCursor.End)
def sendCommand(self):
" Send command string to com port "
self.ui.comboBox_CommandInput.lineEdit().returnPressed.emit()
cmd = self.ui.comboBox_CommandInput.currentText()
cmd = cmd.replace("\\x16", "\x16", cs=Qt.CaseInsensitive)
cmd = cmd.replace("\\x0d", "\x0d", cs=Qt.CaseInsensitive)
self.printCommand(cmd)
self.sendData.start(self.ser, cmd)
# self.ui.cmdLineEdit.clear()
def openPort(self):
" Open serial port "
self.closePort()
try:
self.printInfo("Connecting to %s with %s baud rate." % (self.getPortConfig(), self.getBandRateConfig()))
self.ser = serial.Serial(str(self.getPortConfig()), int(self.getBandRateConfig()))
self.receiveData.start(self.ser)
self.printInfo("->>- Connected successfully.")
except:
self.ser = None
self.printError("Failed to connect!")
def closePort(self):
" Close serial port "
if self.receiveData.isRunning():
self.receiveData.terminate()
if self.sendData.isRunning():
self.sendData.terminate()
if self.ser == None:
return
try:
if self.ser.isOpen:
self.ser.close()
self.printInfo("-<>- Disconnected successfully.")
except:
self.printError("Failed to disconnect!")
self.ser = None
