You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1276 lines
37 KiB
1276 lines
37 KiB
//Author: Timothy Pearson <kb9vqf@pearsoncomputing.net>, (C) 2014
|
|
//Copyright: See COPYING file that comes with this distribution
|
|
|
|
#include "define.h"
|
|
#include "part.h"
|
|
|
|
#include <tdeaboutdata.h> //::createAboutData()
|
|
#include <tdeaction.h>
|
|
#include <tdelocale.h>
|
|
#include <tdemessagebox.h> //::start()
|
|
#include <tdefiledialog.h>
|
|
#include <tdeparts/genericfactory.h>
|
|
#include <kstatusbar.h>
|
|
#include <kstdaction.h>
|
|
#include <tqfile.h> //encodeName()
|
|
#include <tqtimer.h>
|
|
#include <tqvbox.h>
|
|
#include <tqsocket.h>
|
|
#include <tqmutex.h>
|
|
#include <tqgroupbox.h>
|
|
#include <tqlayout.h>
|
|
#include <tqcombobox.h>
|
|
#include <tqcheckbox.h>
|
|
#include <tqpushbutton.h>
|
|
#include <tqeventloop.h>
|
|
#include <tqapplication.h>
|
|
#include <unistd.h> //access()
|
|
#include <stdint.h>
|
|
#include <cmath>
|
|
|
|
#include "tracewidget.h"
|
|
#include "floatspinbox.h"
|
|
#include "layout.h"
|
|
|
|
#define NETWORK_COMM_TIMEOUT_MS 15000
|
|
|
|
/* exception handling */
|
|
struct exit_exception {
|
|
int c;
|
|
exit_exception(int c):c(c) { }
|
|
};
|
|
|
|
enum connectionStates {
|
|
LogicAnalyzerState_InitialRequest = 0,
|
|
LogicAnalyzerState_ResetRequest = 2,
|
|
LogicAnalyzerState_HorizontalDivCountRequest = 4,
|
|
LogicAnalyzerState_ChannelCountRequest = 8,
|
|
LogicAnalyzerState_ChannelNameRequest = 10,
|
|
LogicAnalyzerState_ChannelActiveStateRequest = 12,
|
|
LogicAnalyzerState_TraceSampleCountRequest = 14,
|
|
LogicAnalyzerState_TraceSecondsDivRequest = 16,
|
|
LogicAnalyzerState_RunningRequest = 18,
|
|
LogicAnalyzerState_TraceRequest = 50,
|
|
LogicAnalyzerState_ChannelActiveStateUpdate = 100,
|
|
LogicAnalyzerState_TraceVoltsDivUpdate = 102,
|
|
LogicAnalyzerState_RunningUpdate = 106,
|
|
LogicAnalyzerState_ExternalCommandRequest = 255
|
|
};
|
|
|
|
namespace RemoteLab {
|
|
|
|
typedef KParts::GenericFactory<RemoteLab::LogicAnalyzerPart> Factory;
|
|
#define CLIENT_LIBRARY "libremotelab_logicanalyzer"
|
|
K_EXPORT_COMPONENT_FACTORY( libremotelab_logicanalyzer, RemoteLab::Factory )
|
|
|
|
LogicAnalyzerPart::LogicAnalyzerPart( TQWidget *parentWidget, const char *widgetName, TQObject *parent, const char *name, const TQStringList& )
|
|
: RemoteInstrumentPart( parent, name ), m_traceWidget(0), m_commHandlerState(-1), m_commHandlerMode(0), m_commHandlerCommandState(0), m_connectionActiveAndValid(false),
|
|
m_base(0), stopTraceUpdate(false)
|
|
{
|
|
// Initialize important base class variables
|
|
m_clientLibraryName = CLIENT_LIBRARY;
|
|
|
|
// Initialize mutex
|
|
m_instrumentMutex = new TQMutex(false);
|
|
|
|
// Initialize kpart
|
|
setInstance(Factory::instance());
|
|
setWidget(new TQVBox(parentWidget, widgetName));
|
|
|
|
// Create timers
|
|
m_forcedUpdateTimer = new TQTimer(this);
|
|
connect(m_forcedUpdateTimer, SIGNAL(timeout()), this, SLOT(mainEventLoop()));
|
|
m_updateTimeoutTimer = new TQTimer(this);
|
|
connect(m_updateTimeoutTimer, SIGNAL(timeout()), this, SLOT(mainEventLoop()));
|
|
|
|
// Initialize data
|
|
m_hdivs = 0;
|
|
m_vdivs = 0;
|
|
for (int traceno=0; traceno<=MAXTRACES; traceno++) {
|
|
m_samplesInTrace[traceno] = 0;
|
|
m_channelActive[traceno] = false;
|
|
m_channelName[traceno] = TQString("Channel %1").arg(traceno);
|
|
m_voltsDiv[traceno] = 0;
|
|
m_secsDiv[traceno] = 0;
|
|
|
|
m_voltsDivSet[traceno] = false;
|
|
m_channelActiveSet[traceno] = false;
|
|
}
|
|
m_runningSet = false;
|
|
|
|
// Create widgets
|
|
m_base = new LogicAnalyzerBase(widget());
|
|
m_traceControlWidgetGrid = new TQGridLayout(m_base->traceControlLayoutWidget);
|
|
m_traceWidget = m_base->traceScrollWidget->traceWidget();
|
|
m_base->traceScrollWidget->setSizePolicy(TQSizePolicy(TQSizePolicy::MinimumExpanding, TQSizePolicy::MinimumExpanding));
|
|
m_base->traceScrollWidget->setHScrollBarMode(TQScrollView::Auto);
|
|
m_base->traceScrollWidget->setVScrollBarMode(TQScrollView::Auto);
|
|
m_traceWidget->showLeftTraceInfoArea(true);
|
|
m_traceWidget->fitLeftTraceInfoArea(true);
|
|
m_traceWidget->setLeftTraceInfoAreaFitSpacing(10);
|
|
m_traceWidget->setMinimumPixelsPerHorizDiv(30);
|
|
m_traceWidget->setNumberOfCursors(2);
|
|
m_traceWidget->setCursorColor(0, TQColor(0, 255, 0));
|
|
m_traceWidget->setCursorColor(1, TQColor(0, 255, 0));
|
|
m_traceWidget->setCursorHighlightColor(0, TQColor(192, 255, 192));
|
|
m_traceWidget->setCursorHighlightColor(1, TQColor(192, 255, 192));
|
|
m_traceWidget->setCursorOrientation(0, TQt::Vertical);
|
|
m_traceWidget->setCursorOrientation(1, TQt::Vertical);
|
|
m_traceWidget->setCursorEnabled(0, true);
|
|
m_traceWidget->setCursorEnabled(1, true);
|
|
m_traceWidget->setCursorName(0, "Cursor V1");
|
|
m_traceWidget->setCursorName(1, "Cursor V2");
|
|
m_traceWidget->setCursorPosition(0, 25);
|
|
m_traceWidget->setCursorPosition(1, 75);
|
|
TraceNumberList activeTraces;
|
|
for (uint trace=0; trace<1; trace++) {
|
|
activeTraces.append(trace);
|
|
}
|
|
m_traceWidget->setCursorActiveTraceList(0, activeTraces);
|
|
m_traceWidget->setCursorActiveTraceList(1, activeTraces);
|
|
m_traceWidget->setZoomBoxEnabled(false);
|
|
|
|
connect(m_base->acqStart, SIGNAL(clicked()), this, SLOT(startDAQ()));
|
|
connect(m_base->acqStop, SIGNAL(clicked()), this, SLOT(stopDAQ()));
|
|
connect(m_base->runControlStartButton, SIGNAL(clicked()), this, SLOT(startLogicAnalyzer()));
|
|
connect(m_base->runControlStopButton, SIGNAL(clicked()), this, SLOT(stopLogicAnalyzer()));
|
|
|
|
connect(m_base->waveformSave, SIGNAL(clicked()), this, SLOT(saveWaveforms()));
|
|
connect(m_base->waveformRecall, SIGNAL(clicked()), this, SLOT(recallWaveforms()));
|
|
|
|
TQTimer::singleShot(0, this, TQT_SLOT(postInit()));
|
|
}
|
|
|
|
LogicAnalyzerPart::~LogicAnalyzerPart() {
|
|
if (m_instrumentMutex->locked()) {
|
|
printf("[WARNING] Exiting when data transfer still in progress!\n\r"); fflush(stdout);
|
|
}
|
|
|
|
disconnectFromServer();
|
|
delete m_instrumentMutex;
|
|
}
|
|
|
|
void LogicAnalyzerPart::postInit() {
|
|
setUsingFixedSize(false);
|
|
}
|
|
|
|
bool LogicAnalyzerPart::openURL(const KURL &url) {
|
|
int ret;
|
|
m_connectionActiveAndValid = false;
|
|
ret = connectToServer(url.url());
|
|
processLockouts();
|
|
return (ret != 0);
|
|
}
|
|
|
|
bool LogicAnalyzerPart::closeURL() {
|
|
disconnectFromServer();
|
|
m_url = KURL();
|
|
return true;
|
|
}
|
|
|
|
void LogicAnalyzerPart::processLockouts() {
|
|
// Largest area
|
|
if (m_connectionActiveAndValid) {
|
|
if ((m_commHandlerMode < 2) && (m_commHandlerState < 2)) {
|
|
m_base->setEnabled(false);
|
|
}
|
|
else {
|
|
m_base->setEnabled(true);
|
|
}
|
|
}
|
|
else {
|
|
m_base->setEnabled(false);
|
|
}
|
|
|
|
// Middle area
|
|
if (((m_commHandlerMode < 2) && (m_commHandlerState < 50)) || (stopTraceUpdate)) {
|
|
m_base->groupLogicAnalyzerCaptureControls->setEnabled(false);
|
|
}
|
|
else {
|
|
m_base->groupLogicAnalyzerCaptureControls->setEnabled(true);
|
|
}
|
|
|
|
// Least area
|
|
if (stopTraceUpdate) {
|
|
m_base->acqStop->setEnabled(false);
|
|
m_base->acqStart->setEnabled(true);
|
|
m_base->waveformSave->setEnabled(true);
|
|
m_base->waveformRecall->setEnabled(true);
|
|
}
|
|
else {
|
|
m_base->acqStop->setEnabled(true);
|
|
m_base->acqStart->setEnabled(false);
|
|
m_base->waveformSave->setEnabled(false);
|
|
m_base->waveformRecall->setEnabled(false);
|
|
}
|
|
if (m_running) {
|
|
m_base->runControlStartButton->setEnabled(false);
|
|
m_base->runControlStopButton->setEnabled(true);
|
|
}
|
|
else {
|
|
m_base->runControlStartButton->setEnabled(true);
|
|
m_base->runControlStopButton->setEnabled(false);
|
|
}
|
|
}
|
|
|
|
void LogicAnalyzerPart::disconnectFromServerCallback() {
|
|
m_forcedUpdateTimer->stop();
|
|
m_updateTimeoutTimer->stop();
|
|
m_connectionActiveAndValid = false;
|
|
}
|
|
|
|
void LogicAnalyzerPart::connectionFinishedCallback() {
|
|
connect(m_socket, SIGNAL(readyRead()), m_socket, SLOT(processPendingData()));
|
|
m_socket->processPendingData();
|
|
connect(m_socket, SIGNAL(newDataReceived()), this, SLOT(mainEventLoop()));
|
|
m_tickerState = 0;
|
|
m_commHandlerState = 0;
|
|
m_commHandlerMode = 0;
|
|
m_socket->setDataTimeout(NETWORK_COMM_TIMEOUT_MS);
|
|
m_updateTimeoutTimer->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
|
|
processLockouts();
|
|
mainEventLoop();
|
|
return;
|
|
}
|
|
|
|
void LogicAnalyzerPart::connectionStatusChangedCallback() {
|
|
processLockouts();
|
|
}
|
|
|
|
void LogicAnalyzerPart::setTickerMessage(TQString message) {
|
|
int i;
|
|
bool updatesPending = false;
|
|
for (i=0; i<=MAXTRACES;i++) {
|
|
if (m_channelActiveSet[i]) updatesPending = true;
|
|
if (m_voltsDivSet[i]) updatesPending = true;
|
|
if (m_runningSet) updatesPending = true;
|
|
}
|
|
|
|
m_connectionActiveAndValid = true;
|
|
TQString tickerChar;
|
|
switch (m_tickerState) {
|
|
case 0:
|
|
tickerChar = "-";
|
|
break;
|
|
case 1:
|
|
tickerChar = "\\";
|
|
break;
|
|
case 2:
|
|
tickerChar = "|";
|
|
break;
|
|
case 3:
|
|
tickerChar = "/";
|
|
break;
|
|
}
|
|
if (updatesPending) {
|
|
setStatusMessage(i18n("Updates pending") + ", " + message + TQString("... %1").arg(tickerChar));
|
|
}
|
|
else {
|
|
setStatusMessage(message + TQString("... %1").arg(tickerChar));
|
|
}
|
|
m_tickerState++;
|
|
if (m_tickerState > 3) {
|
|
m_tickerState = 0;
|
|
}
|
|
}
|
|
|
|
#define UPDATEDISPLAY_TIMEOUT m_connectionActiveAndValid = false; \
|
|
m_tickerState = 0; \
|
|
m_commHandlerState = LogicAnalyzerState_ResetRequest; \
|
|
m_commHandlerMode = 0; \
|
|
m_socket->clearIncomingData(); \
|
|
setStatusMessage(i18n("Server ping timeout. Please verify the status of your network connection.")); \
|
|
m_updateTimeoutTimer->start(NETWORK_COMM_TIMEOUT_MS, TRUE); \
|
|
m_instrumentMutex->unlock(); \
|
|
return;
|
|
|
|
#define COMMUNICATIONS_FAILED m_connectionActiveAndValid = false; \
|
|
m_tickerState = 0; \
|
|
m_commHandlerState = LogicAnalyzerState_ResetRequest; \
|
|
m_commHandlerMode = 0; \
|
|
m_socket->clearIncomingData(); \
|
|
setStatusMessage(i18n("Instrument communication failure. Please verify the status of your network connection.")); \
|
|
m_updateTimeoutTimer->start(NETWORK_COMM_TIMEOUT_MS, TRUE); \
|
|
m_instrumentMutex->unlock(); \
|
|
return;
|
|
|
|
#define SET_WATCHDOG_TIMER if (!m_updateTimeoutTimer->isActive()) m_updateTimeoutTimer->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
|
|
#define PAT_WATCHDOG_TIMER m_updateTimeoutTimer->stop(); m_updateTimeoutTimer->start(NETWORK_COMM_TIMEOUT_MS, TRUE);
|
|
|
|
#define SET_NEXT_STATE(x) if (m_commHandlerMode == 0) { \
|
|
m_commHandlerState = x; \
|
|
} \
|
|
else { \
|
|
m_commHandlerState = LogicAnalyzerState_ExternalCommandRequest; \
|
|
EXEC_NEXT_STATE_IMMEDIATELY \
|
|
}
|
|
#define SET_NEXT_STATE_DATA_WAITING(x) m_commHandlerState = x;
|
|
|
|
#define EXEC_NEXT_STATE_IMMEDIATELY m_forcedUpdateTimer->start(0, TRUE);
|
|
|
|
int getNextActiveChannel(int current, bool* activity, int maxtracenumber) {
|
|
int ret = -1;
|
|
for (int i=current+1; i<=maxtracenumber; i++) {
|
|
if (activity[i]) {
|
|
ret = i;
|
|
break;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void LogicAnalyzerPart::mainEventLoop() {
|
|
TQDataStream ds(m_socket);
|
|
ds.setPrintableData(true);
|
|
|
|
if (!m_instrumentMutex->tryLock()) {
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
return;
|
|
}
|
|
|
|
if (m_socket) {
|
|
if ((m_commHandlerMode == 0) || (m_commHandlerMode == 1)) {
|
|
if (m_commHandlerState == LogicAnalyzerState_InitialRequest) {
|
|
// Request logic analyzer access
|
|
ds << TQString("LOGICANALYZER");
|
|
m_socket->writeEndOfFrame();
|
|
|
|
m_commHandlerState = LogicAnalyzerState_InitialRequest+1;
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_InitialRequest+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Connected"));
|
|
|
|
// Get command status
|
|
TQString result;
|
|
ds >> result;
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
SET_NEXT_STATE(LogicAnalyzerState_ResetRequest)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ResetRequest) {
|
|
// Reset logicanalyzer
|
|
ds << TQString("RESET");
|
|
m_socket->writeEndOfFrame();
|
|
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_ResetRequest+1)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ResetRequest+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Loading [Reset complete]"));
|
|
|
|
// Get command status
|
|
TQString result;
|
|
ds >> result;
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
SET_NEXT_STATE(LogicAnalyzerState_HorizontalDivCountRequest)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_HorizontalDivCountRequest) {
|
|
// Get number of horizontal divisions, step 1
|
|
ds << TQString("GETHORIZONTALDIVCOUNT");
|
|
m_socket->writeEndOfFrame();
|
|
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_HorizontalDivCountRequest+1)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_HorizontalDivCountRequest+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Loading [Received horizontal division count]"));
|
|
|
|
// Get number of horizontal divisions, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
if (result == "ACK") {
|
|
ds >> m_hdivs;
|
|
}
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
SET_NEXT_STATE(LogicAnalyzerState_ChannelCountRequest)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ChannelCountRequest) {
|
|
// Get number of channels, step 1
|
|
ds << TQString("GETNUMBEROFCHANNELS");
|
|
m_socket->writeEndOfFrame();
|
|
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_ChannelCountRequest+1)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ChannelCountRequest+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Loading [Received number of channels]"));
|
|
|
|
// Get number of channels, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
if (result == "ACK") {
|
|
ds >> m_maxNumberOfTraces;
|
|
if (m_maxNumberOfTraces > MAXTRACES) {
|
|
m_maxNumberOfTraces = MAXTRACES;
|
|
}
|
|
|
|
// Lock the number of vertical divisions to the number of traces
|
|
// This provides a useful baseline effect whereby each trace has a dotted zero line
|
|
m_vdivs = m_maxNumberOfTraces;
|
|
|
|
// Set true/false (0-1) to one division
|
|
double voltsDiv = 1.5;
|
|
int traceno;
|
|
for (traceno=0; traceno<m_maxNumberOfTraces; traceno++) {
|
|
m_voltsDiv[traceno+1] = voltsDiv;
|
|
}
|
|
|
|
// Stack all channels vertically
|
|
double offset = ((double)m_vdivs/2)*voltsDiv;
|
|
double step = ((double)m_vdivs/m_maxNumberOfTraces)*voltsDiv;
|
|
offset = offset - step; // Make sure the first channel text is visible
|
|
for (int i=0;i<m_maxNumberOfTraces; i++) {
|
|
m_traceWidget->setTraceOffset(i, offset, true);
|
|
m_traceWidget->setTraceTextOffset(i, 0.75, true);
|
|
offset = offset - step;
|
|
}
|
|
}
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
m_currentOpChannel = 1;
|
|
SET_NEXT_STATE(LogicAnalyzerState_ChannelNameRequest)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ChannelNameRequest) {
|
|
// Get channel name, step 1
|
|
ds << TQString("GETCHANNELNAME");
|
|
m_socket->writeEndOfFrame();
|
|
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_ChannelNameRequest+1)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ChannelNameRequest+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Loading [Received channel names]"));
|
|
|
|
// Get channel status, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
if (result == "ACK") {
|
|
int traceno;
|
|
for (traceno=0; traceno<m_maxNumberOfTraces; traceno++) {
|
|
ds >> m_channelName[traceno+1];
|
|
}
|
|
}
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
SET_NEXT_STATE(LogicAnalyzerState_ChannelActiveStateRequest)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ChannelActiveStateRequest) {
|
|
// Get channel status, step 1
|
|
ds << TQString("GETCHANNELACTIVE");
|
|
m_socket->writeEndOfFrame();
|
|
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_ChannelActiveStateRequest+1)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ChannelActiveStateRequest+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Loading [Received channel activity status]"));
|
|
|
|
// Get channel status, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
if (result == "ACK") {
|
|
int traceno;
|
|
for (traceno=0; traceno<m_maxNumberOfTraces; traceno++) {
|
|
TQ_INT16 active;
|
|
ds >> active;
|
|
m_channelActive[traceno+1] = (active != 0);
|
|
}
|
|
}
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceSampleCountRequest)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_TraceSampleCountRequest) {
|
|
// Get number of samples in trace, step 1
|
|
ds << TQString("GETTRACESAMPLECOUNT");
|
|
m_socket->writeEndOfFrame();
|
|
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_TraceSampleCountRequest+1)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_TraceSampleCountRequest+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Loading [Received trace sample count]"));
|
|
|
|
// Get number of samples in trace, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
if (result == "ACK") {
|
|
int traceno;
|
|
for (traceno=0; traceno<m_maxNumberOfTraces; traceno++) {
|
|
ds >> m_samplesInTrace[traceno+1];
|
|
}
|
|
}
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceSecondsDivRequest)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_TraceSecondsDivRequest) {
|
|
// Get seconds per division, step 1
|
|
ds << TQString("GETSECONDSSDIV");
|
|
m_socket->writeEndOfFrame();
|
|
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_TraceSecondsDivRequest+1)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_TraceSecondsDivRequest+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Loading [Received seconds/div]"));
|
|
|
|
// Get seconds per division, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
if (result == "ACK") {
|
|
int traceno;
|
|
for (traceno=0; traceno<m_maxNumberOfTraces; traceno++) {
|
|
ds >> m_secsDiv[traceno+1];
|
|
}
|
|
}
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
SET_NEXT_STATE(LogicAnalyzerState_RunningRequest)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_RunningRequest) {
|
|
// Get running, step 1
|
|
ds << TQString("GETRUNNING");
|
|
ds << m_currentOpChannel;
|
|
m_socket->writeEndOfFrame();
|
|
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_RunningRequest+1)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_RunningRequest+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Loading [Received run status]"));
|
|
|
|
// Get running, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
if (result == "ACK") {
|
|
TQ_INT16 status;
|
|
ds >> status;
|
|
m_running = (status != 0);
|
|
}
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
// Update display widget(s)
|
|
updateGraticule();
|
|
}
|
|
|
|
if (result == "ACK") {
|
|
m_currentOpChannel = getNextActiveChannel(0, m_channelActive, m_maxNumberOfTraces);
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceRequest)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_TraceRequest) {
|
|
// Get trace, step 1
|
|
ds << TQString("GETLOGICTRACES");
|
|
ds << m_currentOpChannel;
|
|
m_socket->writeEndOfFrame();
|
|
|
|
m_lastChangesRequireFullUpdate = false;
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_TraceRequest+1)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_TraceRequest+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Running [Received traces]"));
|
|
|
|
// Get trace, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
|
|
if (result == "ACK") {
|
|
int traceno;
|
|
for (traceno=0; traceno<m_maxNumberOfTraces; traceno++) {
|
|
TQDoubleArray trace;
|
|
TQDoubleArray positions;
|
|
|
|
// Get trace data
|
|
ds >> trace;
|
|
ds >> positions;
|
|
|
|
// Set trace widgets
|
|
m_traceWidget->setSamples(traceno, trace, true);
|
|
m_traceWidget->setPositions(traceno, positions, (traceno<(m_maxNumberOfTraces-1))?true:false);
|
|
}
|
|
}
|
|
m_socket->clearFrameTail();
|
|
|
|
// Update display widget(s)
|
|
postProcessTrace();
|
|
m_traceWidget->repaint(false);
|
|
|
|
if (result == "ACK") {
|
|
if ((m_channelActiveSet[m_currentOpChannel] == false)
|
|
&& (m_voltsDivSet[m_currentOpChannel] == false)
|
|
&& (m_runningSet == false)
|
|
) {
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceRequest)
|
|
}
|
|
else {
|
|
m_currentOpChannel = getNextActiveChannel(0, m_channelActive, m_maxNumberOfTraces);
|
|
SET_NEXT_STATE(LogicAnalyzerState_ChannelActiveStateUpdate)
|
|
}
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ChannelActiveStateUpdate) {
|
|
if (m_channelActiveSet[m_currentOpChannel]) {
|
|
// Set channel active, step 1
|
|
ds << TQString("SETCHANNELACTIVE");
|
|
ds << m_currentOpChannel;
|
|
TQ_INT16 active = (m_channelActive[m_currentOpChannel])?1:0;
|
|
ds << active;
|
|
m_socket->writeEndOfFrame();
|
|
|
|
m_lastChangesRequireFullUpdate = true;
|
|
m_channelActiveSet[m_currentOpChannel] = false;
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_ChannelActiveStateUpdate+1)
|
|
}
|
|
else {
|
|
if (m_currentOpChannel < (m_maxNumberOfTraces-1)) {
|
|
m_currentOpChannel++;
|
|
SET_NEXT_STATE(LogicAnalyzerState_ChannelActiveStateUpdate)
|
|
}
|
|
else {
|
|
m_currentOpChannel = getNextActiveChannel(0, m_channelActive, m_maxNumberOfTraces);
|
|
if (m_lastChangesRequireFullUpdate) {
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceSecondsDivRequest)
|
|
}
|
|
else {
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceVoltsDivUpdate)
|
|
}
|
|
}
|
|
}
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ChannelActiveStateUpdate+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Updating [Set channel %1 activity status]").arg(m_currentOpChannel));
|
|
|
|
// Set channel active, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
m_currentOpChannel = getNextActiveChannel(m_currentOpChannel, m_channelActive, m_maxNumberOfTraces);
|
|
if (m_currentOpChannel > 0) {
|
|
SET_NEXT_STATE(LogicAnalyzerState_ChannelActiveStateUpdate)
|
|
}
|
|
else {
|
|
m_currentOpChannel = getNextActiveChannel(0, m_channelActive, m_maxNumberOfTraces);
|
|
if (m_lastChangesRequireFullUpdate) {
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceSecondsDivRequest)
|
|
}
|
|
else {
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceVoltsDivUpdate)
|
|
}
|
|
}
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_TraceVoltsDivUpdate) {
|
|
if (m_voltsDivSet[m_currentOpChannel]) {
|
|
// Set volts per division, step 1
|
|
ds << TQString("SETVOLTSDIV");
|
|
ds << m_currentOpChannel;
|
|
ds << m_voltsDiv[m_currentOpChannel];
|
|
m_socket->writeEndOfFrame();
|
|
|
|
m_voltsDivSet[m_currentOpChannel] = false;
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_TraceVoltsDivUpdate+1)
|
|
}
|
|
else {
|
|
m_currentOpChannel = getNextActiveChannel(m_currentOpChannel, m_channelActive, m_maxNumberOfTraces);
|
|
if (m_currentOpChannel > 0) {
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceVoltsDivUpdate)
|
|
}
|
|
else {
|
|
SET_NEXT_STATE(LogicAnalyzerState_RunningUpdate)
|
|
}
|
|
}
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_TraceVoltsDivUpdate+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Updating [Set volts/div for channel %1]").arg(m_currentOpChannel));
|
|
|
|
// Set volts per division, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
m_currentOpChannel = getNextActiveChannel(m_currentOpChannel, m_channelActive, m_maxNumberOfTraces);
|
|
if (m_currentOpChannel > 0) {
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceVoltsDivUpdate)
|
|
}
|
|
else {
|
|
SET_NEXT_STATE(LogicAnalyzerState_RunningUpdate)
|
|
}
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_RunningUpdate) {
|
|
if (m_runningSet) {
|
|
// Set running, step 1
|
|
ds << TQString("SETRUNNING");
|
|
TQ_INT16 running = (m_running)?1:0;
|
|
ds << running;
|
|
m_socket->writeEndOfFrame();
|
|
|
|
m_runningSet = false;
|
|
SET_NEXT_STATE_DATA_WAITING(LogicAnalyzerState_RunningUpdate+1)
|
|
}
|
|
else {
|
|
m_currentOpChannel = getNextActiveChannel(0, m_channelActive, m_maxNumberOfTraces);
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceRequest)
|
|
}
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_RunningUpdate+1) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Updating [Set run status]"));
|
|
|
|
// Set running, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
m_currentOpChannel = getNextActiveChannel(0, m_channelActive, m_maxNumberOfTraces);
|
|
SET_NEXT_STATE(LogicAnalyzerState_TraceRequest)
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerState == LogicAnalyzerState_ExternalCommandRequest) {
|
|
// Execute pending command
|
|
m_commHandlerMode = 2;
|
|
m_socket->clearIncomingData();
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
SET_WATCHDOG_TIMER
|
|
}
|
|
else if (m_commHandlerMode == 2) {
|
|
if (m_commHandlerCommandState == 0) {
|
|
m_commHandlerMode = 0;
|
|
m_commHandlerState = LogicAnalyzerState_ChannelActiveStateRequest;
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerCommandState == 1) {
|
|
// Set channel active
|
|
ds << TQString("SETCHANNELACTIVE");
|
|
ds << m_nextOpChannel;
|
|
ds << m_nextOpParameter16;
|
|
m_socket->writeEndOfFrame();
|
|
|
|
m_commHandlerCommandState = 2;
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else if (m_commHandlerCommandState == 2) {
|
|
// Get response data
|
|
if (m_socket->canReadFrame()) {
|
|
PAT_WATCHDOG_TIMER
|
|
setTickerMessage(i18n("Connected"));
|
|
|
|
// Set channel active, step 2
|
|
TQString result;
|
|
ds >> result;
|
|
m_socket->clearFrameTail();
|
|
|
|
if (result == "ACK") {
|
|
m_commHandlerCommandState = 0;
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
if (stopTraceUpdate == false) {
|
|
COMMUNICATIONS_FAILED
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (!m_updateTimeoutTimer->isActive()) {
|
|
if (stopTraceUpdate == false) {
|
|
UPDATEDISPLAY_TIMEOUT
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_commHandlerCommandState == 3) {
|
|
if (stopTraceUpdate == false) {
|
|
m_commHandlerCommandState = 0;
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
else {
|
|
setTickerMessage(i18n("Data acquisition stopped"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
m_commHandlerState = LogicAnalyzerState_ResetRequest;
|
|
m_commHandlerCommandState = 0;
|
|
}
|
|
|
|
processLockouts();
|
|
|
|
m_instrumentMutex->unlock();
|
|
}
|
|
|
|
void LogicAnalyzerPart::postProcessTrace() {
|
|
return;
|
|
}
|
|
|
|
void LogicAnalyzerPart::startDAQ() {
|
|
stopTraceUpdate = false;
|
|
if (m_socket) m_socket->clearIncomingData();
|
|
EXEC_NEXT_STATE_IMMEDIATELY
|
|
}
|
|
|
|
void LogicAnalyzerPart::stopDAQ() {
|
|
if (m_commHandlerMode < 2) {
|
|
stopTraceUpdate = true;
|
|
for (int i=0; i<=MAXTRACES;i++) {
|
|
m_channelActiveSet[i] = false;
|
|
m_voltsDivSet[i] = false;
|
|
}
|
|
m_runningSet = false;
|
|
m_commHandlerMode = 1;
|
|
m_commHandlerCommandState = 3;
|
|
mainEventLoop();
|
|
}
|
|
}
|
|
|
|
#define WAVEFORM_MAGIC_NUMBER 1
|
|
#define WAVEFORM_FILE_VERSION 1
|
|
|
|
void LogicAnalyzerPart::saveWaveforms() {
|
|
TQString saveFileName = KFileDialog::getSaveFileName(TQString::null, "*.wfm|Waveform Files (*.wfm)", 0, i18n("Save waveforms..."));
|
|
if (saveFileName != "") {
|
|
TQFile file(saveFileName);
|
|
file.open(IO_WriteOnly);
|
|
TQDataStream ds(&file);
|
|
TQ_INT32 magicNumber = WAVEFORM_MAGIC_NUMBER;
|
|
TQ_INT32 version = WAVEFORM_FILE_VERSION;
|
|
ds << magicNumber;
|
|
ds << version;
|
|
ds << m_hdivs;
|
|
ds << m_vdivs;
|
|
ds << m_maxNumberOfTraces;
|
|
for (int traceno=1; traceno<=m_maxNumberOfTraces; traceno++) {
|
|
TQ_UINT8 boolValue;
|
|
boolValue = m_channelActive[traceno];
|
|
ds << boolValue;
|
|
ds << m_samplesInTrace[traceno];
|
|
ds << m_voltsDiv[traceno];
|
|
ds << m_secsDiv[traceno];
|
|
ds << m_traceWidget->samples(traceno-1);
|
|
ds << m_traceWidget->positions(traceno-1);
|
|
}
|
|
for (int cursorno=0; cursorno<5; cursorno++) {
|
|
ds << m_traceWidget->cursorPosition(cursorno);
|
|
}
|
|
}
|
|
}
|
|
|
|
void LogicAnalyzerPart::recallWaveforms() {
|
|
TQString openFileName = KFileDialog::getOpenFileName(TQString::null, "*.wfm|Waveform Files (*.wfm)", 0, i18n("Open waveforms..."));
|
|
if (openFileName != "") {
|
|
TQFile file(openFileName);
|
|
file.open(IO_ReadOnly);
|
|
TQDataStream ds(&file);
|
|
TQ_INT32 magicNumber;
|
|
TQ_INT32 version;
|
|
ds >> magicNumber;
|
|
if (magicNumber == WAVEFORM_MAGIC_NUMBER) {
|
|
ds >> version;
|
|
if (version == WAVEFORM_FILE_VERSION) {
|
|
ds >> m_hdivs;
|
|
ds >> m_vdivs;
|
|
ds >> m_maxNumberOfTraces;
|
|
for (int traceno=1; traceno<=m_maxNumberOfTraces; traceno++) {
|
|
TQ_UINT8 boolValue;
|
|
ds >> boolValue;
|
|
m_channelActive[traceno] = (boolValue!=0)?true:false;
|
|
ds >> m_samplesInTrace[traceno];
|
|
ds >> m_voltsDiv[traceno];
|
|
ds >> m_secsDiv[traceno];
|
|
double offset;
|
|
TQDoubleArray values;
|
|
TQDoubleArray positions;
|
|
ds >> offset;
|
|
ds >> values;
|
|
ds >> positions;
|
|
m_traceWidget->setSamples(traceno-1, values);
|
|
m_traceWidget->setPositions(traceno-1, positions);
|
|
m_traceWidget->setTraceOffset(traceno-1, offset);
|
|
}
|
|
for (int cursorno=0; cursorno<5; cursorno++) {
|
|
double cursorPos;
|
|
ds >> cursorPos;
|
|
m_traceWidget->setCursorPosition(cursorno, cursorPos);
|
|
}
|
|
updateGraticule();
|
|
postProcessTrace();
|
|
m_traceWidget->repaint(false);
|
|
}
|
|
else {
|
|
KMessageBox::error(0, i18n("<qt>The selected waveform file version does not match this client</qt>"), i18n("Invalid File"));
|
|
}
|
|
}
|
|
else {
|
|
KMessageBox::error(0, i18n("<qt>Invalid waveform file selected</qt>"), i18n("Invalid File"));
|
|
}
|
|
}
|
|
}
|
|
|
|
void LogicAnalyzerPart::updateGraticule() {
|
|
m_traceWidget->setNumberOfHorizontalDivisions(m_hdivs);
|
|
m_traceWidget->setNumberOfVerticalDivisions(m_vdivs);
|
|
|
|
for (int traceno=1; traceno<=m_maxNumberOfTraces; traceno++) {
|
|
m_traceWidget->setTraceEnabled(traceno-1, m_channelActive[traceno], TraceWidget::NoText, true);
|
|
m_traceWidget->setTraceName(traceno-1, m_channelName[traceno], true);
|
|
m_traceWidget->setTraceHorizontalUnits(traceno-1, "s", true);
|
|
m_traceWidget->setTraceVerticalUnits(traceno-1, "", true);
|
|
|
|
m_traceWidget->setNumberOfSamples(traceno-1, m_samplesInTrace[traceno], true);
|
|
|
|
m_traceWidget->setDisplayLimits(traceno-1, TQRectF(0.0, (m_voltsDiv[traceno]*m_vdivs)/2.0, (m_secsDiv[traceno]*m_hdivs), (m_voltsDiv[traceno]*m_vdivs)/-2.0), (traceno<m_maxNumberOfTraces)?true:false);
|
|
}
|
|
}
|
|
|
|
void LogicAnalyzerPart::startLogicAnalyzer() {
|
|
m_running = true;
|
|
m_runningSet = true;
|
|
}
|
|
|
|
void LogicAnalyzerPart::stopLogicAnalyzer() {
|
|
m_running = false;
|
|
m_runningSet = true;
|
|
}
|
|
|
|
TDEAboutData* LogicAnalyzerPart::createAboutData() {
|
|
return new TDEAboutData( APP_NAME, I18N_NOOP( APP_PRETTYNAME ), APP_VERSION );
|
|
}
|
|
|
|
} //namespace RemoteLab
|
|
|
|
#include "part.moc"
|