void DiagnosticsAgent::handle(const QXmppDiagnosticIq &request)
{
iq.setId(request.id());
iq.setFrom(request.to());
iq.setTo(request.from());
iq.setType(QXmppIq::Result);
/* software versions */
QList<Software> softwares;
Software os;
os.setType("os");
os.setName(osName());
os.setVersion(QSysInfo::productVersion());
softwares << os;
Software app;
app.setType("application");
app.setName(qApp->applicationName());
app.setVersion(qApp->applicationVersion());
softwares << app;
iq.setSoftwares(softwares);
/* get DNS servers */
iq.setNameServers(NetworkInfo::nameServers());
/* discover interfaces */
QList<Interface> interfaceResults;
foreach (const QNetworkInterface &interface, QNetworkInterface::allInterfaces())
{
if (!(interface.flags() & QNetworkInterface::IsRunning) ||
(interface.flags() & QNetworkInterface::IsLoopBack))
continue;
Interface result;
#if QT_VERSION >= 0x040500
result.setName(interface.humanReadableName());
#else
result.setName(interface.name());
#endif
// addresses
result.setAddressEntries(interface.addressEntries());
// wireless
WirelessInterface wireless(interface);
if (wireless.isValid())
{
QList<WirelessNetwork> networks = wireless.availableNetworks();
WirelessNetwork current = wireless.currentNetwork();
if (current.isValid())
{
networks.removeAll(current);
networks.prepend(current);
}
result.setWirelessNetworks(networks);
result.setWirelessStandards(wireless.supportedStandards());
}
interfaceResults << result;
}
iq.setInterfaces(interfaceResults);
/* try to determine gateways */
QList<QHostAddress> pingAddresses;
foreach (const QNetworkInterface &interface, QNetworkInterface::allInterfaces())
{
if (!(interface.flags() & QNetworkInterface::IsRunning) || (interface.flags() & QNetworkInterface::IsLoopBack))
continue;
foreach (const QNetworkAddressEntry &entry, interface.addressEntries())
{
if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol && !entry.netmask().isNull() && entry.netmask() != QHostAddress::Broadcast)
{
const QHostAddress gateway((entry.ip().toIPv4Address() & entry.netmask().toIPv4Address()) + 1);
if (!pingAddresses.contains(gateway))
pingAddresses.append(gateway);
break;
}
}
}
/* run DNS tests */
foreach (const QString &hostName, m_config.pingHosts)
{
QHostAddress address;
if (resolve(hostName, address)) {
if (!pingAddresses.contains(address))
pingAddresses.append(address);
}
}
/* run ping tests */
QList<Ping> pings;
foreach (const QHostAddress &address, pingAddresses)
{
const Ping ping = NetworkInfo::ping(address, 3);
pings.append(ping);
if (address == QHostAddress("8.8.8.8") && ping.sentPackets() != ping.receivedPackets())
pings.append(NetworkInfo::ping(address, 30));
}
iq.setPings(pings);
/* run traceroute */
QList<Traceroute> traceroutes;
foreach (const QString &hostName, m_config.tracerouteHosts)
{
QHostAddress address;
if (resolve(hostName, address)) {
traceroutes << NetworkInfo::traceroute(address, 3, 4);
}
}
iq.setTraceroutes(traceroutes);
/* run download */
if (m_config.transferUrl.isValid()) {
TransferTester *runner = new TransferTester(this);
connect(runner, SIGNAL(finished(QList<Transfer>)), this, SLOT(transfersFinished(QList<Transfer>)));
runner->start(m_config.transferUrl);
} else {
emit finished(iq);
}
}
int main(int argc, char** argv){
//select loggin level
logger_default_config(log4cxx::Level::getInfo());
std::string adc_id;
std::string filename;
size_t offset = 0x08000000; // 128M * 4 -> second memory bank
size_t block_size = 2048;
size_t data_size = 4096;
bool simple_mode = false;
bool halbe_mode = false;
bool statistic_mode = false;
{
namespace po = boost::program_options;
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("adc", po::value<std::string>(&adc_id)->required(), "specify ADC board")
("data_size", po::value<size_t>(&data_size), "Amount of data to read (kB), default 4096kB")
("block_size", po::value<size_t>(&block_size), "Read data in blocks of this size(kB), default 2048kB")
("simple_mode", po::bool_switch(&simple_mode), "Run forever and collect statistics.")
("halbe_mode ", po::bool_switch(&halbe_mode), "Run forever and collect statistics.")
("statistic_mode", po::bool_switch(&statistic_mode), "Run forever and collect statistics.")
;
po::variables_map vm;
po::store(po::command_line_parser(argc, argv)
.options(desc)
.run()
, vm);
if (vm.count("help")) {
std::cout << std::endl << desc << std::endl;
return 0;
}
po::notify(vm);
}
if (simple_mode)
{
//create the top of the tree
Vmoduleusb io(usbcomm::note);
if(io.open(usb_vendorid, usb_deviceid, adc_id)){
std::cout << "Open failed" << std::endl;
return -1;
}
else {
std::cout << "Board " << adc_id << " opened" << std::endl;
}
//create sp6 class tree
Vusbmaster usb(&io);
//usbmaster knows three clients, must be in this order!!!
Vusbstatus status(&usb);
Vmemory mem(&usb);
Vocpfifo ocp(&usb);
//ocpfifo clients
Vspiconfrom confrom(&ocp);
Vspigyro gyro(&ocp);
Vspiwireless wireless(&ocp);
std::cout << "Transfering " << data_size << "kB in "
<< calc_blocks(data_size * 1024, block_size * 1024)
<< " block(s) of "
<< calc_words(block_size) << " words." << std::endl;
size_t errorcnt = memtest(mem, calc_words(data_size), offset, calc_words(block_size));
std::cout << "Transmission errors: " << errorcnt << std::endl;
if (errorcnt > 0)
return -1;
}
if (halbe_mode)
{
Vmoduleusb io(usbcomm::note, usb_vendorid, usb_deviceid, adc_id);
std::cout << "Board " << adc_id << " opened" << std::endl;
Vusbmaster usb(&io);
Vusbstatus status(&usb);
Vmemory mem(&usb);
Vocpfifo ocp(&usb);
Vmux_board mux_board(&ocp, mux_board_mode(adc_id));
Vflyspi_adc adc(&ocp);
// write configuration to adc
adc.configure(0);
adc.setup_controller(0, calc_words(data_size),
0 /* single mode */, 0 /* trigger enable */, 0 /* trigger */);
const uint32_t startaddr = adc.get_startaddr();
const uint32_t endaddr = adc.get_endaddr();
const uint32_t num_words = endaddr - startaddr;
if (startaddr != 0 or endaddr != calc_words(data_size))
{
std::cout << "Invalid start or end addresses: startaddr="
<< startaddr << " endaddr=" << endaddr;
exit(-1);
}
std::cout << "Transfering " << num_words << " words in "
<< calc_blocks(data_size * 1024, block_size * 1024)
<< " block(s) of "
<< num_words << " words." << std::endl;
size_t errorcnt = memtest(mem, num_words, offset, calc_words(block_size));
std::cout << "Transmission errors: " << errorcnt << std::endl;
if (errorcnt > 0)
return -1;
}
}
