void MainWidget::connectSignals()
{
connect(configForm, SIGNAL(finished(int)), this, SLOT(dialogResult(int)));
connect(managerForm, SIGNAL(stopped()), qApp, SLOT(quit()));
connect(managerForm, SIGNAL(deviceConnected(QString)), this, SIGNAL(deviceConnected(QString)));
connect(managerForm, SIGNAL(deviceDisconnected()), this, SIGNAL(deviceDisconnected()));
connect(managerForm, SIGNAL(messageSent(QString)), this, SIGNAL(messageReceived(QString)));
connect(managerForm, SIGNAL(updated(int)), this, SIGNAL(databaseUpdated(int)));
}
void CmaClient::processNewConnection(vita_device_t *device)
{
QMutexLocker locker(&mutex);
in_progress = true;
broadcast.setUnavailable();
qDebug("Vita connected: id %s", VitaMTP_Get_Identification(device));
DeviceCapability vita_info;
if(!vita_info.exchangeInfo(device)) {
qCritical("Error while exchanging info with the vita");
} else {
// Conection successful, inform the user
emit deviceConnected(QString(tr("Connected to ")) + vita_info.getOnlineId());
enterEventLoop(device);
}
VitaMTP_SendHostStatus(device, VITA_HOST_STATUS_EndConnection);
qDebug("Releasing device...");
VitaMTP_Release_Device(device);
emit deviceDisconnected();
broadcast.setAvailable();
in_progress = false;
sema.release();
}
BtLocalDevice::BtLocalDevice(QObject *parent) :
QObject(parent), securityFlags(QBluetooth::NoSecurity)
{
localDevice = new QBluetoothLocalDevice(this);
connect(localDevice, SIGNAL(error(QBluetoothLocalDevice::Error)),
this, SIGNAL(error(QBluetoothLocalDevice::Error)));
connect(localDevice, SIGNAL(hostModeStateChanged(QBluetoothLocalDevice::HostMode)),
this, SIGNAL(hostModeStateChanged()));
connect(localDevice, SIGNAL(pairingFinished(QBluetoothAddress,QBluetoothLocalDevice::Pairing)),
this, SLOT(pairingFinished(QBluetoothAddress,QBluetoothLocalDevice::Pairing)));
connect(localDevice, SIGNAL(deviceConnected(QBluetoothAddress)),
this, SLOT(connected(QBluetoothAddress)));
connect(localDevice, SIGNAL(deviceDisconnected(QBluetoothAddress)),
this, SLOT(disconnected(QBluetoothAddress)));
connect(localDevice, SIGNAL(pairingDisplayConfirmation(QBluetoothAddress,QString)),
this, SLOT(pairingDisplayConfirmation(QBluetoothAddress,QString)));
if (localDevice->isValid()) {
deviceAgent = new QBluetoothDeviceDiscoveryAgent(this);
connect(deviceAgent, SIGNAL(deviceDiscovered(QBluetoothDeviceInfo)),
this, SLOT(deviceDiscovered(QBluetoothDeviceInfo)));
connect(deviceAgent, SIGNAL(finished()),
this, SLOT(discoveryFinished()));
connect(deviceAgent, SIGNAL(error(QBluetoothDeviceDiscoveryAgent::Error)),
this, SLOT(discoveryError(QBluetoothDeviceDiscoveryAgent::Error)));
connect(deviceAgent, SIGNAL(canceled()),
this, SLOT(discoveryCanceled()));
serviceAgent = new QBluetoothServiceDiscoveryAgent(this);
connect(serviceAgent, SIGNAL(serviceDiscovered(QBluetoothServiceInfo)),
this, SLOT(serviceDiscovered(QBluetoothServiceInfo)));
connect(serviceAgent, SIGNAL(finished()),
this, SLOT(serviceDiscoveryFinished()));
connect(serviceAgent, SIGNAL(canceled()),
this, SLOT(serviceDiscoveryCanceled()));
connect(serviceAgent, SIGNAL(error(QBluetoothServiceDiscoveryAgent::Error)),
this, SLOT(serviceDiscoveryError(QBluetoothServiceDiscoveryAgent::Error)));
socket = new QBluetoothSocket(SOCKET_PROTOCOL, this);
connect(socket, SIGNAL(stateChanged(QBluetoothSocket::SocketState)),
this, SLOT(socketStateChanged(QBluetoothSocket::SocketState)));
connect(socket, SIGNAL(error(QBluetoothSocket::SocketError)),
this, SLOT(socketError(QBluetoothSocket::SocketError)));
connect(socket, SIGNAL(connected()), this, SLOT(socketConnected()));
connect(socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected()));
connect(socket, SIGNAL(readyRead()), this, SLOT(readData()));
setSecFlags(socket->preferredSecurityFlags());
server = new QBluetoothServer(SOCKET_PROTOCOL, this);
connect(server, SIGNAL(newConnection()), this, SLOT(serverNewConnection()));
connect(server, SIGNAL(error(QBluetoothServer::Error)),
this, SLOT(serverError(QBluetoothServer::Error)));
} else {
deviceAgent = 0;
serviceAgent = 0;
socket = 0;
server = 0;
}
}
void DeviceBase::_deviceDisconnected() {
deviceDisconnected();
m_token = nullptr;
if (m_hidDev) {
m_hidDev->_deviceDisconnected();
m_hidDev.reset();
}
}
void USBHALHost::UsbIrqhandler() {
if( LPC_USB->HcInterruptStatus & LPC_USB->HcInterruptEnable ) //Is there something to actually process?
{
uint32_t int_status = LPC_USB->HcInterruptStatus & LPC_USB->HcInterruptEnable;
// Root hub status change interrupt
if (int_status & OR_INTR_STATUS_RHSC) {
if (LPC_USB->HcRhPortStatus1 & OR_RH_PORT_CSC) {
if (LPC_USB->HcRhStatus & OR_RH_STATUS_DRWE) {
// When DRWE is on, Connect Status Change
// means a remote wakeup event.
} else {
//Root device connected
if (LPC_USB->HcRhPortStatus1 & OR_RH_PORT_CCS) {
// wait 150ms to avoid bounce
wait_ms(150);
//Hub 0 (root hub), Port 1 (count starts at 1), Low or High speed
deviceConnected(0, 1, LPC_USB->HcRhPortStatus1 & OR_RH_PORT_LSDA);
}
//Root device disconnected
else {
if (!(int_status & OR_INTR_STATUS_WDH)) {
usb_hcca->DoneHead = 0;
}
// wait 200ms to avoid bounce
wait_ms(200);
deviceDisconnected(0, 1, NULL, usb_hcca->DoneHead & 0xFFFFFFFE);
if (int_status & OR_INTR_STATUS_WDH) {
usb_hcca->DoneHead = 0;
LPC_USB->HcInterruptStatus = OR_INTR_STATUS_WDH;
}
}
}
LPC_USB->HcRhPortStatus1 = OR_RH_PORT_CSC;
}
if (LPC_USB->HcRhPortStatus1 & OR_RH_PORT_PRSC) {
LPC_USB->HcRhPortStatus1 = OR_RH_PORT_PRSC;
}
LPC_USB->HcInterruptStatus = OR_INTR_STATUS_RHSC;
}
// Writeback Done Head interrupt
if (int_status & OR_INTR_STATUS_WDH) {
transferCompleted(usb_hcca->DoneHead & 0xFFFFFFFE);
LPC_USB->HcInterruptStatus = OR_INTR_STATUS_WDH;
}
}
}
void EkosManager::processLocalDevice(ISD::GDInterface *devInterface)
{
DriverInfo *di = devInterface->getDriverInfo();
switch (di->getType())
{
case KSTARS_TELESCOPE:
scope = devInterface;
break;
case KSTARS_CCD:
if (guider_di == di)
{
guider = devInterface;
guiderName = devInterface->getDeviceName();
}
else
ccd = devInterface;
break;
case KSTARS_FOCUSER:
focuser = devInterface;
break;
case KSTARS_FILTER:
if (filter_di == di)
filter = devInterface;
if (useFilterFromCCD)
ccd = devInterface;
break;
case KSTARS_AUXILIARY:
if (aux_di == di)
aux = devInterface;
break;
default:
return;
break;
}
nDevices--;
connect(devInterface, SIGNAL(Connected()), this, SLOT(deviceConnected()));
connect(devInterface, SIGNAL(Disconnected()), this, SLOT(deviceDisconnected()));
connect(devInterface, SIGNAL(propertyDefined(INDI::Property*)), this, SLOT(processNewProperty(INDI::Property*)));
if (nDevices == 0)
{
connectB->setEnabled(true);
disconnectB->setEnabled(false);
controlPanelB->setEnabled(true);
}
}
inline void _removeToken(const std::string& path) {
auto preCheck = m_tokens.find(path);
if (preCheck != m_tokens.end()) {
DeviceToken& tok = *preCheck->second;
std::shared_ptr<DeviceBase> dev = tok.m_connectedDev;
tok._deviceClose();
deviceDisconnected(tok, dev.get());
m_tokensLock.lock();
m_tokens.erase(preCheck);
m_tokensLock.unlock();
}
}
WaterTowerWidget::WaterTowerWidget(int id, QWidget *parent) :
QGroupBox(parent),
ui(new Ui::WaterTowerWidget),
uuid(NotifyPanel::instance()->uuid())
{
ui->setupUi(this);
setTitle(readableName(id));
waterTower = WaterTower::instance(id);
connect(waterTower, SIGNAL(waterLevelChanged(int)), this, SLOT(waterLevelChanged(int)));
connect(waterTower, SIGNAL(deviceConnected()), this, SLOT(deviceConnect()));
connect(waterTower, SIGNAL(deviceDisconnected()), this, SLOT(deviceDisconnect()));
connect(waterTower, SIGNAL(highWaterLevelAlarm()), this, SLOT(highWaterLevelAlarm()));
waterTower->getWaterLevel();
ui->avatarWidget->setAvatar(QPixmap(QString(qApp->applicationDirPath() + "/images/watertower-%1.png").arg(id)));
ui->progressBar->setRange(0, waterTower->getHeight());
ui->progressBar->setFormat("%v");
deviceDisconnect();
connect(waterTower, SIGNAL(waterLevelRangeChanged(int,int)), ui->progressBar, SLOT(setRange(int,int)));
enableWidget = new QCheckBox();
enableWidget->setChecked(waterTower->isEnabled());
enableAlarmWidget = new QCheckBox();
enableAlarmWidget->setChecked(waterTower->isAlarmEnabled());
addressWidget = new QSpinBox();
addressWidget->setRange(0, 15);
addressWidget->setValue(waterTower->getAddress());
connect(addressWidget, SIGNAL(valueChanged(int)), this, SLOT(addressChanged(int)));
radiusWidget = new QSpinBox();
radiusWidget->setRange(20, 300);
radiusWidget->setValue(waterTower->getRadius());
connect(radiusWidget, SIGNAL(valueChanged(int)), this, SLOT(radiusChanged(int)));
levelSensorHeightWidget = new QSpinBox();
levelSensorHeightWidget->setRange(20, 100);
levelSensorHeightWidget->setValue(waterTower->getLevelSensorHeight());
connect(levelSensorHeightWidget, SIGNAL(valueChanged(int)), this, SLOT(levelSensorHeightChanged(int)));
levelSensorNumberWidget = new QSpinBox();
levelSensorNumberWidget->setRange(1, 8);
levelSensorNumberWidget->setValue(waterTower->getSensorNumber());
connect(levelSensorNumberWidget, SIGNAL(valueChanged(int)), this, SLOT(levelSensorNumberChanged(int)));
getSampleIntervalWidget();
connect(sampleIntervalWidget, SIGNAL(valueChanged(int)), this, SLOT(sampleIntervalChanged(int)));
connect(enableWidget, SIGNAL(clicked(bool)), this, SLOT(readyForUse(bool)));
connect(enableAlarmWidget, SIGNAL(clicked(bool)), this, SLOT(enableAlarm(bool)));
}
void Device::scanServices(const QString &address)
{
// We need the current device for service discovery.
for (int i = 0; i < devices.size(); i++) {
if (((DeviceInfo*)devices.at(i))->getAddress() == address )
currentDevice.setDevice(((DeviceInfo*)devices.at(i))->getDevice());
}
if (!currentDevice.getDevice().isValid()) {
qWarning() << "Not a valid device";
return;
}
qDeleteAll(m_characteristics);
m_characteristics.clear();
emit characteristicsUpdated();
qDeleteAll(m_services);
m_services.clear();
emit servicesUpdated();
setUpdate("Back\n(Connecting to device...)");
if (controller && controller->remoteAddress() != currentDevice.getDevice().address()) {
controller->disconnectFromDevice();
delete controller;
controller = 0;
}
//! [les-controller-1]
if (!controller) {
// Connecting signals and slots for connecting to LE services.
controller = new QLowEnergyController(currentDevice.getDevice().address());
connect(controller, SIGNAL(connected()),
this, SLOT(deviceConnected()));
connect(controller, SIGNAL(error(QLowEnergyController::Error)),
this, SLOT(errorReceived(QLowEnergyController::Error)));
connect(controller, SIGNAL(disconnected()),
this, SLOT(deviceDisconnected()));
connect(controller, SIGNAL(serviceDiscovered(QBluetoothUuid)),
this, SLOT(addLowEnergyService(QBluetoothUuid)));
connect(controller, SIGNAL(discoveryFinished()),
this, SLOT(serviceScanDone()));
}
if (isRandomAddress())
controller->setRemoteAddressType(QLowEnergyController::RandomAddress);
else
controller->setRemoteAddressType(QLowEnergyController::PublicAddress);
controller->connectToDevice();
//! [les-controller-1]
}
void MonitorThread::run()
{
m_monitor = new DeviceMonitor(NULL);
connect(m_monitor, SIGNAL(deviceDisconnected(QString)), parent(), SLOT(onDeviceDisconnected(QString)),Qt::QueuedConnection);
connect(m_monitor, SIGNAL(deviceConnected(QString)), parent(), SLOT(onDeviceConnected(QString)),Qt::QueuedConnection);
connect(m_monitor, SIGNAL(busyMessage(QString)), parent(), SLOT(onBusyMessage(QString)),Qt::QueuedConnection);
connect(m_monitor, SIGNAL(errorMessage(QString,QString)), parent(), SLOT(onShowErrorInfo(QString,QString)),Qt::QueuedConnection);
connect(this, SIGNAL(monitorCreated(DeviceMonitor *)), parent(), SLOT(onMonitorCreated(DeviceMonitor*)),Qt::QueuedConnection);
emit monitorCreated(m_monitor);
m_monitor->start();
exec();
}
void ConnectionManager::onConnectionClosed(QObject *obj) // Pip
{
if (!m_connectionDevice.connection || m_connectionDevice.connection != obj)
return;
m_connectionDevice.connection = NULL;
m_ioDev = NULL;
m_connectBtn->setText("Connect");
m_availableDevList->setEnabled(true);
// signal interested plugins that user is disconnecting his device
emit deviceDisconnected();
}
void RemDev::close(DisconnectReason reason, bool fromRemote) {
registered = false;
terminate(reason, fromRemote);
emit deviceDisconnected(this, reason, fromRemote);
if (reqs.size()) {
req_id_lock.lock();
QJsonObject error({{"code", E_DEVICE_DISCONNECTED},
{"message", tr("Device disconnected")},
{"data", reason}});
RequestHash::const_iterator it;
for (it = reqs.constBegin(); it != reqs.constEnd(); ++it)
(*it->handler)(it.key(), error, false);
}
deleteLater();
}
void EkosManager::processRemoteDevice(ISD::GDInterface *devInterface)
{
if (!strcmp(devInterface->getDeviceName(), Options::remoteScopeName().toLatin1()))
scope = devInterface;
else if (!strcmp(devInterface->getDeviceName(), Options::remoteCCDName().toLatin1()))
{
ccd = devInterface;
if (useGuiderFromCCD)
guider = ccd;
}
else if (!strcmp(devInterface->getDeviceName(), Options::remoteGuiderName().toLatin1()))
{
guider = devInterface;
guiderName = devInterface->getDeviceName();
}
else if (!strcmp(devInterface->getDeviceName(), Options::remoteFocuserName().toLatin1()))
focuser = devInterface;
else if (!strcmp(devInterface->getDeviceName(), Options::remoteFilterName().toLatin1()))
filter = devInterface;
else if (!strcmp(devInterface->getDeviceName(), Options::remoteAuxName().toLatin1()))
aux = devInterface;
else
return;
nDevices--;
connect(devInterface, SIGNAL(Connected()), this, SLOT(deviceConnected()));
connect(devInterface, SIGNAL(Disconnected()), this, SLOT(deviceDisconnected()));
connect(devInterface, SIGNAL(propertyDefined(INDI::Property*)), this, SLOT(processNewProperty(INDI::Property*)));
if (nDevices == 0)
{
connectB->setEnabled(true);
disconnectB->setEnabled(false);
controlPanelB->setEnabled(true);
appendLogText(i18n("Remote devices established. Please connect devices."));
}
}
EcgArea::EcgArea():
pixelDensity(100,100){
grid.setZOrder(10);
drawableList.push_back(&grid);
//Use separater for loops to avoid mixing the order of
//curves, circles and texts to eliminate unnecessary shader switches.
for (int a=0; a<ECG_CURVE_COUNT; a++) {
drawableList.push_back(&ecgCurves[a]);
ecgCurves[a].setZOrder(1);
}
for (int a=0; a<ECG_CURVE_COUNT; a++) {
drawableList.push_back(&endpointCircles[a]);
endpointCircles[a].setZOrder(0);
}
for (int a=0; a<ECG_CURVE_COUNT; a++) {
drawableList.push_back(&labels[a]);
labels[a]
.setColor(Image::BLACK)
.setTextSizeMM(2.5);
}
drawableList.push_back(&devLabel);
devLabel
.setColor(Image::GREY)
.setTextSizeMM(3.5);
padInCm=0.5;
ecgCmPerMv = 2.0;
ecgCmPerSec = 2.5;
lastSampleFrequency=0;
drawableList.push_back(&disconnectedLabel);
disconnectedLabel.setColor(Image::GREY);
disconnectedLabel.setTextSizeMM(3.5);
deviceDisconnected();
}
MountButton::MountButton(QWidget * parent, RazorPanel *panel) :
QToolButton(parent),
mPopup(this),
m_panel(panel),
mDevAction(DevActionInfo),
mPopupHideDelay(5000)
{
if (!QDBusConnection::systemBus().isConnected())
{
qWarning() << "Can't connect to dbus daemon. Some functions will be omited";
}
setIcon(XdgIcon::fromTheme(QStringList() << "device-notifier" << "drive-removable-media-usb"));
setToolTip(tr("Removable media/devices manager"));
initialScanDevices();
QDBusConnection conn = QDBusConnection::systemBus();
// TODO: Check for connection, timer for reconect
/*bool connected =*/ conn.connect("org.freedesktop.UDisks",
"/org/freedesktop/UDisks",
"org.freedesktop.UDisks",
"DeviceChanged",
this,
SLOT(onDbusDeviceChangesMessage(QDBusObjectPath)));
connect(&mPopup, SIGNAL(visibilityChanged(bool)), this, SLOT(setDown(bool)));
connect(m_panel, SIGNAL(positionChanged()), &mPopup, SLOT(hide()));
connect(this, SIGNAL(clicked()), this, SLOT(showHidePopup()));
connect(&_dm, SIGNAL(deviceConnected(DiskInfo)),
this, SLOT(onDiskAdded(DiskInfo)));
connect(&_dm, SIGNAL(deviceDisconnected(DiskInfo)),
this, SLOT(onDiskRemoved(DiskInfo)));
_dm.start();
}
/**
* Method called by plugins who want to force a disconnection.
* Used by Uploader gadget for instance.
*/
bool ConnectionManager::disconnectDevice()
{
// tell the monitor widget we're disconnected
m_monitorWidget->disconnect();
if (!m_ioDev) {
// apparently we are already disconnected: this can
// happen if a plugin tries to force a disconnect whereas
// we are not connected. Just return.
return false;
}
// We are connected - disconnect from the device
// stop our timers
if(reconnect->isActive())
reconnect->stop();
if(reconnectCheck->isActive())
reconnectCheck->stop();
// signal interested plugins that user is disconnecting his device
emit deviceAboutToDisconnect();
try {
if (m_connectionDevice.connection) {
m_connectionDevice.connection->closeDevice(m_connectionDevice.getConName());
}
} catch (...) { // handle exception
qDebug() << "Exception: m_connectionDevice.connection->closeDevice(" << m_connectionDevice.getConName() << ")";
}
m_connectionDevice.connection = NULL;
m_ioDev = NULL;
emit deviceDisconnected();
m_connectBtn->setText("Connect");
m_availableDevList->setEnabled(true);
return true;
}
void MainWidget::createTrayIcon()
{
trayIcon = createTrayObject(this);
trayIcon->init();
#ifndef Q_OS_WIN32
trayIcon->setIcon("qcma_off");
#else
trayIcon->setIcon("tray/qcma_off_16");
#endif
trayIcon->show();
connect(trayIcon, SIGNAL(openConfig()), this, SLOT(openConfig()));
connect(trayIcon, SIGNAL(openManager()), this, SLOT(openManager()));
connect(trayIcon, SIGNAL(refreshDatabase()), this, SLOT(refreshDatabase()));
connect(trayIcon, SIGNAL(showAboutDialog()), this, SLOT(showAboutDialog()));
connect(trayIcon, SIGNAL(showAboutQt()), this, SLOT(showAboutQt()));
connect(trayIcon, SIGNAL(stopServer()), this, SLOT(stopServer()));
connect(managerForm, SIGNAL(deviceConnected(QString)), this, SLOT(deviceConnect(QString)));
connect(managerForm, SIGNAL(deviceDisconnected()), this, SLOT(deviceDisconnect()));
connect(managerForm, SIGNAL(messageSent(QString)), this, SLOT(receiveMessage(QString)));
}
void DeviceAgent::onDeviceDisconnected()
{
DEBUG_INFO << "Device disconnected";
emit deviceDisconnected(this);
//delete this;
}
void MultiPointCom::run()
{
mutex.lock();
QTime timeout = lastConnectTime.addSecs(30);
if (timeout < QTime::currentTime()) {
qDebug() << "Device connected timeout" << disconnectCount++;
lastConnectTime = QTime::currentTime();
#ifdef __arm__
ioctl(device, SI4432_IOC_RESET, 1);
#endif
}
#ifdef __arm__
si4432_ioc_transfer tr;
char txBuf[64], rxBuf[64];
memcpy(txBuf, request.data(), request.size());
memset(&tr, 0, sizeof(si4432_ioc_transfer));
tr.tx_buf = (__u64)txBuf;
tr.rx_buf = (__u64)rxBuf;
tr.len = request.size();
int len = ioctl(device, SI4432_IOC_MESSAGE(1), &tr);
if (len > 0) {
response.clear();
response.append(rxBuf, len);
quint8 addr = response.at(0);
if (addr == address) {
lastConnectTime = QTime::currentTime();
disconnect = 0;
emit deviceConnected();
emit responseReceived(response.at(1), QByteArray(response.data() + 2, len - 2));
}
} else {
disconnect++;
if (disconnect > 3) {
disconnect = 0;
emit deviceDisconnected();
}
}
#else
QUdpSocket *udp = new QUdpSocket();
udp->writeDatagram(request, QHostAddress::LocalHost, 19999);
if (udp->waitForReadyRead(100) && (udp->pendingDatagramSize() > 0)) {
response.resize(udp->pendingDatagramSize());
udp->readDatagram(response.data(), response.size());
quint8 addr = response.at(0);
if (addr == address) {
lastConnectTime = QTime::currentTime();
disconnect = 0;
emit deviceConnected();
emit responseReceived(response.at(1), response.mid(2));
}
} else {
disconnect++;
if (disconnect > 3) {
disconnect = 0;
emit deviceDisconnected();
}
}
delete udp;
#endif
mutex.unlock();
}
