markus.lehr/vrpmdv-yocto-recipes
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added vrpmdv-rtservice, vrpmdv-mon-datafile,

Browse Source 
vrpmdv-monitoring-controler, vrpmdv-mon-tty
This commit is contained in:
Markus Lehr
2024-06-21 08:51:47 +02:00
parent 1171265db7
commit 454ae2f46e
78 changed files with 39005 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/src/RTService.cpp Normal file
View File

@@ -0,0 +1,23 @@
#include "../include/RTSMonitoringTask.h"
#include <chrono>
#include <thread>
int main([[maybe_unused]] int argc, [[maybe_unused]] char **argv) {
RTSMonitoringTask rtMon;
if (rtMon.Init()) {
// idle
while(1)
{
rtMon.CreateMonitoring(1, "Test1", 3750, 2, 10, "stopped");
// sleep 100 ms
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
return 0;
}

104
recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/src/monitoringTask/RTSMonitoringTask.cpp Normal file
View File

@@ -0,0 +1,104 @@
/*
*/
#include "../../include/RTSMonitoringTask.h"
//#include "../../include/json.hpp"//((
//#include "../../include/json_fwd.hpp"
#include <string>
#include<iostream>
#include<cstring>
RTSMonitoringTask::RTSMonitoringTask(/* args */)
{
}
RTSMonitoringTask::~RTSMonitoringTask()
{
}
bool RTSMonitoringTask::Load() {
//later load the file
int id = 1;
RTSMonFrame* rtsMonFrame = new RTSMonFrame(id, "Monitoring1", 3750, 1, 4, "started");
rtsMonFrames[id]= rtsMonFrame;
return true;
}
bool RTSMonitoringTask::Init() {
//load the Monitorings
if (this->Load()) {
printf("CA7 : Monitorings loaded\n");
}
const std::string fwPath = "home/root/elffile";
const std::string fwName = "zephyr_openamp_rsc_table.elf";
//check if the FWIsRunning
if (coproHelper.Init(fwPath, fwName) >= 0) {
printf("CA7 : Init success \n");
// if (pthread_create( &monThread, NULL, &RTSMonitoringTask::Run, this) == 0) {
// printf("CA7 : virtual_tty_thread creation fails\n");
// return true;
// }
return true;
}
printf("CA7 : starting of Zephyr.elf fails\n");
return false;
}
bool RTSMonitoringTask::CreateMonitoring(int id, std::string name, int samplerate, int sampleperiod, int downtime, std::string status){
this->rtsMonFrames[id] = new RTSMonFrame(id, name, samplerate, sampleperiod, downtime, status);
char * ch = new char[name.length() + 1];
// Copying the value of the string into the character array.
strcpy(ch, name.c_str());
this->coproHelper.Copro_writeTtyRpmsg(0,name.length()+1, ch);
return true;
}
void* RTSMonitoringTask::Run(void *obj) {
RTSMonitoringTask* rtsMonTask = static_cast<RTSMonitoringTask*>(obj);
std::string newItem;
while (1) {
// genrate data
int i = 1;
newItem = "New Item"; //new std::string("New Item: ").concat(new std::string(i));
i++;
std::map<int, RTSMonFrame*> rtsMonFrame = rtsMonTask->rtsMonFrames;
if (rtsMonFrame.size() > 0) {
RTSMonFrame* prtsMonFrame = rtsMonFrame.begin()->second;
prtsMonFrame->Add(newItem);
if (i == 200) {
//make a dictonary for the rtsMonFrame id, samplerate, sampleperiod, downtime
// boost::python::dict rtsMonFrameDict;
// rtsMonFrameDict["id"] = prtsMonFrame->GetId();
// rtsMonFrameDict["samplerate"] = prtsMonFrame->GetSampleRate();
// rtsMonFrameDict["sampleperiod"] = prtsMonFrame->GetSamplePeriod();
// rtsMonFrameDict["downtime"] = prtsMonFrame->GetDownTime();
// //make a dictonary for the sampleItems
// boost::python::list rtsMonItemsList;
// auto items = prtsMonFrame->GetItems();
// for (auto iter = items.begin(); iter!= items.end(); ++iter)
// {
// rtsMonItemsList.append(*iter);
// }
// rtsMonFrameDict["items"]= rtsMonItemsList;
// rtsMonTask->callback();
}
}
}
}

347
recipes-vrpmdv/recipes-base/vrpmdv-rtservice/files/src/utilities/RTSCoproHelper.cpp Normal file
View File

@@ -0,0 +1,347 @@
/*
*/
#include "../../include/RTSCoproHelper.h"
#include <signal.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <termios.h>
#include <fcntl.h>
#include <inttypes.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h> // for usleep
#include <math.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/eventfd.h>
#include <sys/poll.h>
#include <regex.h>
#include <sched.h>
#include <assert.h>
#include <errno.h>
#include <error.h>
#define MAX_BUF 80
#define TTY_CTRL_OPTS (CS8 | CLOCAL | CREAD)
#define TTY_INPUT_OPTS IGNPAR
#define TTY_OUTPUT_OPTS 0
#define TTY_LOCAL_OPTS 0
#define CMDCHANNEL 0
#define DATACHANNEL 1
RTSCoproHelper::RTSCoproHelper(/* args */)
{
}
RTSCoproHelper::~RTSCoproHelper()
{
}
int RTSCoproHelper::Init(std::string fwPath, std::string fwName) {
int res = -1;
if (this->Copro_isFwRunning() != 0){
//copro is already Runnibng nothing TODO
//res = this->Copro_openTtyRpmsg(CMDCHANNEL, 0);
this->Copro_stopFw();
//return res;
//return 0;
}
//load Firmware
//set firmware path
res = this->Copro_setFwPath(fwPath.c_str());
if (res >= 0) {
printf("CA7 : Success setting the fwpath, res=%d\n", res);
res = this->Copro_setFwName(fwName.c_str());
if (res >= 0) {
printf("CA7 : Success setting the fwname, res=%d\n", res);
res = this->Copro_startFw();
if (res >= 0) {
printf("CA7 : Success starting Copro, err=%d\n", res);
res = this->Copro_openTtyRpmsg(CMDCHANNEL, 1);
if (res >= 0 ){
printf("CA7 : Success opening Cmdchannel, err=%d\n", res);
}
else {
printf("CA7 : Error opening Cmdchannel, err=%d\n", res);
}
}
else {
printf("CA7 : Error could not start the firmware, res=-%d\n", res);
}
}
else {
printf("CA7 : Error setting the fwName, err=-%d\n", res);
}
}
else {
printf("CA7 : Error setting the fwpath, err=-%d\n", res);
}
return res;
}
/********************************************************************************
Copro functions allowing to manage a virtual TTY over RPMSG
*********************************************************************************/
int RTSCoproHelper::Copro_isFwRunning(void)
{
int fd;
size_t byte_read;
bool result = 0;
unsigned char bufRead[MAX_BUF];
// char *user = getenv("USER");
// if (user && strncmp(user, "root", 4)) {
// system("XTERM=xterm su root -c 'cat /sys/class/remoteproc/remoteproc0/state' > /tmp/remoteproc0_state");
// fd = open("/tmp/remoteproc0_state", O_RDONLY);
// } else {
fd = open("/sys/class/remoteproc/remoteproc0/state", O_RDONLY);
// }
if (fd < 0) {
printf("CA7 : Error opening remoteproc0/state, err=-%d\n", errno);
return (errno * -1);
}
byte_read = (size_t) read (fd, bufRead, MAX_BUF);
if (byte_read >= strlen("running")) {
char* pos = strstr((char*)bufRead, "running");
if(pos) {
result = 1;
}
}
close(fd);
return result;
}
int RTSCoproHelper::Copro_stopFw(void)
{
int fd;
// char *user = getenv("USER");
// if (user && strncmp(user, "root",4)) {
// system("su root -c 'echo stop > /sys/class/remoteproc/remoteproc0/state'");
// return 0;
// }
fd = open("/sys/class/remoteproc/remoteproc0/state", O_RDWR);
if (fd < 0) {
printf("CA7 : Error opening remoteproc0/state, err=-%d\n", errno);
return (errno * -1);
}
write(fd, "stop", strlen("stop"));
close(fd);
return 0;
}
int RTSCoproHelper::Copro_startFw(void)
{
int fd;
// char *user = getenv("USER");
// if (user && strncmp(user, "root",4)) {
// system("su root -c 'echo start > /sys/class/remoteproc/remoteproc0/state'");
// return 0;
// }
fd = open("/sys/class/remoteproc/remoteproc0/state", O_RDWR);
if (fd < 0) {
printf("CA7 : Error opening remoteproc0/state, err=-%d\n", errno);
return (errno * -1);
}
write(fd, "start", strlen("start"));
close(fd);
return 0;
}
int RTSCoproHelper::Copro_getFwPath(char* pathStr)
{
int fd;
int byte_read;
// char *user = getenv("USER");
// if (user && strncmp(user, "root",4)) {
// system("XTERM=xterm su root -c 'cat /sys/module/firmware_class/parameters/path' > /tmp/parameters_path");
// fd = open("/tmp/parameters_path", O_RDONLY);
// } else {
fd = open("/sys/module/firmware_class/parameters/path", O_RDONLY);
// }
if (fd < 0) {
printf("CA7 : Error opening firmware_class/parameters/path, err=-%d\n", errno);
return (errno * -1);
}
byte_read = read (fd, pathStr, MAX_BUF);
close(fd);
return byte_read;
}
int RTSCoproHelper::Copro_setFwPath(const char* pathStr)
{
int fd;
int result = 0;
// char *user = getenv("USER");
// if (user && strncmp(user, "root",4)) {
// char cmd[1024];
// snprintf(cmd, 1024, "echo %s > /sys/module/firmware_class/parameters/path", pathStr);
// //snprintf(cmd, 1024, "su root -c 'echo %s > /sys/module/firmware_class/parameters/path'", pathStr);
// system(cmd);
// return strlen(pathStr);
// }
fd = open("/sys/module/firmware_class/parameters/path", O_RDWR);
if (fd < 0) {
printf("CA7 : Error opening firmware_class/parameters/path, err=-%d\n", errno);
return (errno * -1);
}
result = write(fd, pathStr, strlen(pathStr));
close(fd);
return result;
}
int RTSCoproHelper::Copro_getFwName(char* pathStr)
{
int fd;
int byte_read;
// char *user = getenv("USER");
// if (user && strncmp(user, "root",4)) {
// system("XTERM=xterm su root -c 'cat /sys/class/remoteproc/remoteproc0/firmware' > /tmp/remoteproc0_firmware");
// fd = open("/tmp/remoteproc0_firmware", O_RDONLY);
// } else {
fd = open("/sys/class/remoteproc/remoteproc0/firmware", O_RDWR);
// }
if (fd < 0) {
printf("CA7 : Error opening remoteproc0/firmware, err=-%d\n", errno);
return (errno * -1);
}
byte_read = read (fd, pathStr, MAX_BUF);
close(fd);
return byte_read;
}
int RTSCoproHelper::Copro_setFwName(const char* nameStr)
{
int fd;
int result = 0;
// char *user = getenv("USER");
// if (user && strncmp(user, "root",4)) {
// char cmd[1024];
// snprintf(cmd, 1024, "su root -c 'echo %s > /sys/class/remoteproc/remoteproc0/firmware'", nameStr);
// system(cmd);
// return strlen(nameStr);
// }
fd = open("/sys/class/remoteproc/remoteproc0/firmware", O_RDWR);
if (fd < 0) {
printf("CA7 : Error opening remoteproc0/firmware, err=-%d\n", errno);
return (errno * -1);
}
result = write(fd, nameStr, strlen(nameStr));
close(fd);
return result;
}
int RTSCoproHelper::Copro_openTtyRpmsg(int ttyNb, [[maybe_unused]]int modeRaw)
{
//struct termios tiorpmsg;
char devName[50];
sprintf(devName, "/dev/ttyRPMSG%d", ttyNb%2);
mFdRpmsg[ttyNb%2] = open(devName, O_RDWR | O_NOCTTY | O_NONBLOCK);
// mFdRpmsg[ttyNb%2] = open("rpmsg-client-sample", O_RDWR | O_NOCTTY | O_NONBLOCK);
if (mFdRpmsg[ttyNb%2] < 0) {
printf("CA7 : Error opening ttyRPMSG%d, err=-%d\n", ttyNb%2, errno);
return (errno * -1);
}
printf("CA7 : Success opening ttyRPMSG%d \n", ttyNb%2);
// #if 1
// /* get current port settings */
// tcgetattr(mFdRpmsg[ttyNb%2],&tiorpmsg);
// if (modeRaw) {
// #if 0
// tiorpmsg.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
// | INLCR | IGNCR | ICRNL | IXON);
// tiorpmsg.c_oflag &= ~OPOST;
// tiorpmsg.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
// tiorpmsg.c_cflag &= ~(CSIZE | PARENB);
// tiorpmsg.c_cflag |= CS8;
// #else
// memset(&tiorpmsg, 0, sizeof(tiorpmsg));
// tiorpmsg.c_cflag = TTY_CTRL_OPTS;
// tiorpmsg.c_iflag = TTY_INPUT_OPTS;
// tiorpmsg.c_oflag = TTY_OUTPUT_OPTS;
// tiorpmsg.c_lflag = TTY_LOCAL_OPTS;
// tiorpmsg.c_cc[VTIME] = 0;
// tiorpmsg.c_cc[VMIN] = 1;
// cfmakeraw(&tiorpmsg);
// #endif
// } else {
// /* ECHO off, other bits unchanged */
// tiorpmsg.c_lflag &= ~ECHO;
// /*do not convert LF to CR LF */
// tiorpmsg.c_oflag &= ~ONLCR;
// }
// if (tcsetattr(mFdRpmsg[ttyNb%2], TCSANOW, &tiorpmsg) < 0) {
// printf("Error %d in copro_openTtyRpmsg(%d) tcsetattr\n", errno, ttyNb);
// return (errno * -1);
// }
// #endif
return 0;
}
int RTSCoproHelper::Copro_closeTtyRpmsg(int ttyNb)
{
close(mFdRpmsg[ttyNb%2]);
mFdRpmsg[ttyNb%2] = -1;
return 0;
}
int RTSCoproHelper::Copro_writeTtyRpmsg(int ttyNb, int len, char* pData)
{
int result = 0;
if (mFdRpmsg[ttyNb%2] < 0) {
printf("CA7 : Error writing ttyRPMSG%d, fileDescriptor is not set\n", ttyNb%2);
return mFdRpmsg[ttyNb%2];
}
result = write(mFdRpmsg[ttyNb%2], pData, len);
if (result >= 0) {
printf("CA7 : Succes writing ttyRPMSG%d, result=%d\n", ttyNb%2, result);
}
else {
printf("CA7 : Error writing ttyRPMSG%d, err=-%d\n", ttyNb%2, result);
}
return result;
}
int RTSCoproHelper::Copro_readTtyRpmsg(int ttyNb, int len, char* pData)
{
int byte_rd, byte_avail;
int result = 0;
if (mFdRpmsg[ttyNb%2] < 0) {
printf("CA7 : Error reading ttyRPMSG%d, fileDescriptor is not set\n", ttyNb%2);
return mFdRpmsg[ttyNb%2];
}
ioctl(mFdRpmsg[ttyNb%2], FIONREAD, &byte_avail);
if (byte_avail > 0) {
if (byte_avail >= len) {
byte_rd = read (mFdRpmsg[ttyNb%2], pData, len);
} else {
byte_rd = read (mFdRpmsg[ttyNb%2], pData, byte_avail);
}
//printf("CA7 : read successfully %d bytes to %p, [0]=0x%x\n", byte_rd, pData, pData[0]);
result = byte_rd;
} else {
result = 0;
}
return result;
}
/********************************************************************************
End of Copro functions
*********************************************************************************/