I am a new hand in driveworks development work,so i try to begin with driveworks samples.I want to implement the function that can read gps information and send it to the client port.These are my codes(almost the combination of sample_gps_logger and sample_ipc_socketclientserver):
#include
#include <signal.h>
#include
#include
#include <stdio.h>
#include <stdlib.h>
#include
#ifdef LINUX
#include <execinfo.h>
#include <unistd.h>
#endif
#include
#include
#include
#include
#include
#include
#include <condition_variable>
#include
#include <framework/ProgramArguments.hpp>
#include <framework/DataPath.hpp>
#include <framework/Log.hpp>
#include <framework/Checks.hpp>
// CORE
#include <dw/core/Logger.h>
#include <dw/core/Context.h>
#include <dw/core/VersionCurrent.h>
#include <dw/ipc/SocketClientServer.h>
// HAL
#include <dw/sensors/Sensors.h>
#include <dw/sensors/gps/GPS.h>
//for json communication
// for zmq:
#include <zmq.h>
//#include <zmq_api.h>
// for json:
#include <jsoncpp/json/json.h>
//------------------------------------------------------------------------------
// Variables
//------------------------------------------------------------------------------
static bool gRun = true;
//------------------------------------------------------------------------------
void sig_int_handler(int)
{
gRun = false;
}
//communication-----------------------------
dwStatus runServer(ProgramArguments const &arguments, dwContextHandle_t ctx)
{
auto status = DW_FAILURE;
auto port = static_cast<uint16_t>(std::stoul(arguments.get("port")));
auto socketServer = dwSocketServerHandle_t{DW_NULL_HANDLE};
CHECK_DW_ERROR(dwSocketServer_initialize(&socketServer, port, 2, ctx));
// accept two connections (use two connections for illustration,
// a single connection can also be used bi-directionally)
auto socketConnectionRead = dwSocketConnectionHandle_t{DW_NULL_HANDLE},
socketConnectionWrite = dwSocketConnectionHandle_t{DW_NULL_HANDLE};
do {
status = dwSocketServer_accept(&socketConnectionRead, 10000, socketServer);
} while (status == DW_TIME_OUT);
do {
status = dwSocketServer_accept(&socketConnectionWrite, 10000, socketServer);
} while (status == DW_TIME_OUT);
if (status != DW_FAILURE) {
while (g_run) {
size_t data;
auto size = sizeof(decltype(data));
// receive data
std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 500));
if ((status = dwSocketConnection_recv(reinterpret_cast<uint8_t *>(&data), &size,
socketConnectionRead)) == DW_END_OF_STREAM)
break;
CHECK_DW_ERROR(status);
if (size != sizeof(decltype(data)))
break;
std::cout << "Socket Server received " << data << std::endl;
// send data back
std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 500));
if ((status = dwSocketConnection_send(reinterpret_cast<uint8_t *>(&data), &size,
socketConnectionWrite)) == DW_END_OF_STREAM)
break;
CHECK_DW_ERROR(status);
if (size != sizeof(decltype(data)))
break;
std::cout << "Socket Server send " << data << std::endl;
}
}
CHECK_DW_ERROR(dwSocketConnection_release(&socketConnectionWrite));
CHECK_DW_ERROR(dwSocketConnection_release(&socketConnectionRead));
CHECK_DW_ERROR(dwSocketServer_release(&socketServer));
return DW_SUCCESS;
}
dwStatus runClient(ProgramArguments const &arguments, dwContextHandle_t ctx)
{
auto status = DW_FAILURE;
auto ip = arguments.get("ip");
auto port = static_cast<uint16_t>(std::stoul(arguments.get("port")));
auto socketClient = dwSocketClientHandle_t{DW_NULL_HANDLE};
CHECK_DW_ERROR(dwSocketClient_initialize(&socketClient, 2, ctx));
// connect two connections (use two connections for illustration,
// a single connection can also be used bi-directionally)
auto socketConnectionWrite = dwSocketConnectionHandle_t{DW_NULL_HANDLE},
socketConnectionRead = dwSocketConnectionHandle_t{DW_NULL_HANDLE};
do {
status = dwSocketClient_connect(&socketConnectionWrite, ip.c_str(), port, 10000, socketClient);
} while (status == DW_TIME_OUT);
do {
status = dwSocketClient_connect(&socketConnectionRead, ip.c_str(), port, 10000, socketClient);
} while (status == DW_TIME_OUT);
if (status != DW_FAILURE) {
while (g_run) {
// send some data
static size_t dataRef = 0;
++dataRef;
decltype(dataRef) data;
auto size = sizeof(decltype(data));
// send data
std::this_thread::sleep_for(std::chrono::milliseconds(std::frame.latitude));
if ((status = dwSocketConnection_send(reinterpret_cast<uint8_t *>(&dataRef), &size,
socketConnectionWrite)) == DW_END_OF_STREAM)
break;
CHECK_DW_ERROR(status);
if (size != sizeof(decltype(data)))
break;
std::cout << "Socket Client send " << dataRef << std::endl;
// receive data
std::this_thread::sleep_for(std::chrono::milliseconds(std::frame.latitude));
if ((status = dwSocketConnection_recv(reinterpret_cast<uint8_t *>(&data), &size,
socketConnectionRead)) == DW_END_OF_STREAM)
break;
CHECK_DW_ERROR(status);
if (size != sizeof(decltype(data)))
break;
std::cout << "Socket Client received " << data << std::endl;
}
}
CHECK_DW_ERROR(dwSocketConnection_release(&socketConnectionWrite));
CHECK_DW_ERROR(dwSocketConnection_release(&socketConnectionRead));
CHECK_DW_ERROR(dwSocketClient_release(&socketClient));
return DW_SUCCESS;
}
//------------------------------------------------------------------------------
int main(int argc, const char **argv)
{
#ifndef WINDOWS
struct sigaction action = {};
action.sa_handler = sig_int_handler;
sigaction(SIGHUP, &action, NULL); // controlling terminal closed, Ctrl-D
sigaction(SIGINT, &action, NULL); // Ctrl-C
sigaction(SIGQUIT, &action, NULL); // Ctrl-\, clean quit with core dump
sigaction(SIGABRT, &action, NULL); // abort() called.
sigaction(SIGTERM, &action, NULL); // kill command
gRun = true;
ProgramArguments arguments(
{
ProgramArguments::Option_t("driver", "gps.virtual"),
ProgramArguments::Option_t("params", (std::string("file=") +
DataPath::get() + "/samples/sensors/gps/1.gps").c_str())
});
if (!arguments.parse(argc, argv) || (!arguments.has("driver") && !arguments.has("params"))) {
std::cout << "Usage: " << argv[0] << std::endl;
std::cout << "\t--driver=gps.virtual \t\t\t: one of the available GPS drivers "
<< "(see sample_sensors_info)\n";
std::cout << "\t--params=file=file.gps,arg2=value \t: comma separated "
<< "key=value parameters for the sensor "
<< "(see sample_sensor_info for a set of supported parameters)\n";
return -1;
}
ProgramArguments arguments2(
{
ProgramArguments::Option_t("role", "server", "client or server"),
ProgramArguments::Option_t("ip", "127.0.0.1", "The server IP the client connects to"),
ProgramArguments::Option_t("port", "49252","The port the server will listen on / the client will connect to")});
if (!arguments2.parse(argc, argv))
exit(-1); // Exit if not all require arguments2 are provided
else
std::cout << "Program Arguments2:\n" << arguments2.printList() << std::endl;
dwContextHandle_t sdk = DW_NULL_HANDLE;
dwSALHandle_t hal = DW_NULL_HANDLE;
// create a Logger to log to console
// we keep the ownership of the logger at the application level
dwLogger_initialize(getConsoleLoggerCallback(true));
dwLogger_setLogLevel(DW_LOG_VERBOSE);
// instantiate Driveworks SDK context
dwContextParameters sdkParams = {};
dwInitialize(&sdk, DW_VERSION, &sdkParams);
// create HAL module of the SDK
dwSAL_initialize(&hal, sdk);
// open same GPS sensor twice, to demonstrate capability of sensor data sharing
dwSensorHandle_t gpsSensor[2] = {DW_NULL_HANDLE, DW_NULL_HANDLE};
for (int32_t i=0; i < 2; i++)
{
dwSensorParams params;
std::string parameterString = arguments.get("params");
params.parameters = parameterString.c_str();
params.protocol = arguments.get("driver").c_str();
if (dwSAL_createSensor(&gpsSensor[i], params, hal) != DW_SUCCESS) {
std::cout << "Cannot create sensor " << params.protocol
<< " with " << params.parameters << std::endl;
dwSAL_release(&hal);
dwRelease(&sdk);
dwLogger_release();
return -1;
}
}
gRun = gRun && dwSensor_start(gpsSensor[0]) == DW_SUCCESS;
gRun = gRun && dwSensor_start(gpsSensor[1]) == DW_SUCCESS;
// Message msg;
bool sensorRun[2] = {gRun, gRun};
while (gRun) {
if (!sensorRun[0] && !sensorRun[1]) break;
for (int i=0; i < 2; i++)
{
if (!sensorRun[i]) continue;
dwGPSFrame frame;
dwStatus status = DW_FAILURE;
status = dwSensorGPS_readFrame(&frame, 50000, gpsSensor[i]);
if (status == DW_END_OF_STREAM) {
std::cout << "GPS[" << i << "] end of stream reached" << std::endl;
sensorRun[i] = false;
break;
} else if (status == DW_TIME_OUT)
continue;
// log message
std::cout << "GPS[" << i <<"] - " << frame.timestamp_us;
if (status != DW_SUCCESS) // msg.is_error)
{
std::cout << " ERROR " << dwGetStatusName(status); // msg.frame.id;
}else {
std::cout << std::setprecision(10);
if(frame.flags & DW_GPS_LAT)
std::cout << " lat: " << frame.latitude;
if(frame.flags & DW_GPS_LON)
std::cout << " lon: " << frame.longitude;
if(frame.flags & DW_GPS_ALT)
std::cout << " alt: " << frame.altitude;
if(frame.flags & DW_GPS_COURSE)
std::cout << " course: " << frame.course;
if(frame.flags & DW_GPS_SPEED)
std::cout << " speed: " << frame.speed;
if(frame.flags & DW_GPS_CLIMB)
std::cout << " climb: " << frame.climb;
if(frame.flags & DW_GPS_HDOP)
std::cout << " hdop: " << frame.hdop;
if(frame.flags & DW_GPS_VDOP)
std::cout << " vdop: " << frame.vdop;
}
std::cout << std::endl;
}
}
dwSensor_stop(gpsSensor[0]);
dwSensor_stop(gpsSensor[1]);
dwSAL_releaseSensor(&gpsSensor[0]);
dwSAL_releaseSensor(&gpsSensor[1]);
// Run client / server
auto const role = arguments2.get("role");
auto status = DW_FAILURE;
if (role == "server")
status = runServer(arguments2, sdk);
else if (role == "client")
status = runClient(arguments2, sdk);
else {
std::cerr << "Invalid role parameter '" << role << "' provided (use either 'client' or 'server')"
<< std::endl;
}
dwSAL_release(&hal);
dwRelease(&sdk);
dwLogger_release();
return status == DW_SUCCESS;
}
And this is my CMakelists.txt:
cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
project(newgpsDriver)
ADD_DEFINITIONS(-std=c++11)
include_directories (/usr/local/driveworks-1.2/sample/src)
set(SOURCES
newgpsDriver.cpp
)
set(LIBRARIES
dw_samples_framework
${Driveworks_LIBRARIES}
)
add_executable(newgpsDriver ${SOURCES})
target_link_libraries(${PROJECT_NAME} PRIVATE ${LIBRARIES})
set_property(TARGET ${PROJECT_NAME} PROPERTY FOLDER “Samples”)
when i make it, it shows an error like this:
/home/nvidia/Downloads/E30/autopilot/gps/test/newgpsDriver.cpp:24:42: fatal error: framework/ProgramArguments.hpp: No such file or directory
compilation terminated.
CMakeFiles/newgpsDriver.dir/build.make:54: recipe for target ‘CMakeFiles/newgpsDriver.dir/newgpsDriver.cpp.o’ failed
make[2]: *** [CMakeFiles/newgpsDriver.dir/newgpsDriver.cpp.o] Error 1
CMakeFiles/Makefile2:60: recipe for target ‘CMakeFiles/newgpsDriver.dir/all’ failed
make[1]: *** [CMakeFiles/newgpsDriver.dir/all] Error 2
Makefile:75: recipe for target ‘all’ failed
make: *** [all] Error 2
I don’t know what happened, so i need your help. Thanks