/**
* free memory reserved by demultiplexer's instance
*/
Demultiplexer::~Demultiplexer() {
#ifdef DEBUG_
cout << "Demultiplexer deleted" << endl;
#endif
delete demultiplexer_instance_;
// detach connection channel if it has been created
if (con_id_) {
ConnectDetach(con_id_);
ChannelDestroy(channel_id_);
}
}
void
omap_fini(void *hdl)
{
omap_dev_t *dev = hdl;
out16(dev->regbase + OMAP_I2C_CON, 0);
out16(dev->regbase + OMAP_I2C_IE, 0);
InterruptDetach(dev->iid);
ConnectDetach(dev->coid);
ChannelDestroy(dev->chid);
munmap_device_io (dev->regbase, dev->reglen);
free (hdl);
}
void Sensorik::stop() {
HAWThread::stop(); // super.stop();
if (-1 == ConnectDetach(isr_coid)) {
perror("SensorCtrl: ConnectDetach isr_coid failed");
}
if (-1 == ChannelDestroy(isr_Chid)) {
perror("SensorCtrl: ChannelDestroy isr_chid failed");
}
// in Simulation: bleibt hier haengen
// if (-1 == InterruptDetach(interruptId)) {
// perror("SensorCtrl: InterruptDetach failed");
// }
}
void
SocketDestroy(TSocket * const socketP) {
assert(socketP->signature == socketSignature);
if (socketP->channelP) {
ChannelDestroy(socketP->channelP);
free(socketP->channelInfoP);
}
if (socketP->chanSwitchP)
ChanSwitchDestroy(socketP->chanSwitchP);
socketP->signature = 0; /* For debuggability */
free(socketP);
}
void SensorHAL::stopInterrupt() {
if (-1 == ThreadCtl(_NTO_TCTL_IO, 0)) {
printf("ThreadCtl access failed\n");
exit(EXIT_FAILURE);
}
if (InterruptDetach(interruptId) == -1) {
printf("SensorHAL: Error InterruptDetach\n");
}
if (ConnectDetach(coid) == -1) {
printf("SensorHAL: Error in ConnectDetach\n");
}
if (ChannelDestroy(chid) == -1) {
printf("SensorHAL: Error in ChannelDestroy\n");
}
}
inline int
isr_setup(omapl1xx_context_t *omapl1xx)
{
int err;
if ((omapl1xx->lcd_chid = ChannelCreate(_NTO_CHF_DISCONNECT |
_NTO_CHF_UNBLOCK)) == -1) {
return -1;
}
if ((omapl1xx->lcd_coid = ConnectAttach(0, 0,
omapl1xx->lcd_chid, _NTO_SIDE_CHANNEL, 0)) == -1) {
err = errno;
goto fail;
}
SIGEV_PULSE_INIT(&omapl1xx->lcd_event, omapl1xx->lcd_coid,
omapl1xx->adapter->pulseprio, OMAPL1xx_LCD_INTERRUPT_PULSE, 0);
omapl1xx->lcd_iid = InterruptAttach(_NTO_INTR_CLASS_EXTERNAL |
omapl1xx->irq, omapl1xx_lcd_isr, (void *)omapl1xx, sizeof(*omapl1xx), _NTO_INTR_FLAGS_END |
_NTO_INTR_FLAGS_TRK_MSK | _NTO_INTR_FLAGS_PROCESS);
if (omapl1xx->lcd_iid == -1) {
err = errno;
goto fail2;
}
return 0;
fail2:
ConnectDetach(omapl1xx->lcd_coid);
fail:
ChannelDestroy(omapl1xx->lcd_chid);
errno = err;
return -1;
}
int _waitfor( __const char *path, int delay_ms, int poll_ms, int (*checkfunc)(__const char *, void *), void *handle )
{
int notify_id = -1;
struct sigevent event;
int chid = -1, coid = -1;
struct _pulse pulse;
int ret_val = -1;
uint64_t polltimeout = 100 * (uint64_t)1000000;
uint64_t timeout_nsec;
timeout_nsec = _syspage_time(CLOCK_MONOTONIC);
timeout_nsec += delay_ms * (uint64_t)1000000;
/* Check to make sure we don't wait for something already there... */
ret_val = checkfunc( path, handle );
if ( ret_val >= 0 || ret_val == WAITFOR_CHECK_ABORT ) {
return ret_val;
}
if ( poll_ms > 0 ) {
polltimeout = poll_ms * (uint64_t)1000000;
}
/*
* We make the channel fixed since we want to remain at the current
* thread's priority
*/
chid = ChannelCreate(_NTO_CHF_FIXED_PRIORITY);
if ( chid == -1 ) {
goto fail1;
}
coid = ConnectAttach( ND_LOCAL_NODE, 0, chid, _NTO_SIDE_CHANNEL, 0 );
if ( coid == -1 ) {
goto fail2;
}
SIGEV_PULSE_INIT( &event, coid, SIGEV_PULSE_PRIO_INHERIT, PULSE_CODE_PATHSPACE, 0 );
notify_id = procmgr_event_notify_add( PROCMGR_EVENT_PATHSPACE, &event );
if ( notify_id == -1 ) {
goto fail3;
}
while(_syspage_time(CLOCK_MONOTONIC) < timeout_nsec) {
/* we need to poll in case we are checking for a subdirectory/file,
* since we won't get a pathmgr event for those.
*/
SIGEV_UNBLOCK_INIT(&event);
if ( TimerTimeout( CLOCK_MONOTONIC, _NTO_TIMEOUT_RECEIVE, &event, &polltimeout, NULL) == -1 ) {
ret_val = -1;
break;
}
if ( MsgReceivePulse( chid, &pulse, sizeof(pulse), NULL ) != -1 || errno == ETIMEDOUT ) {
ret_val = checkfunc( path, handle );
if ( ret_val >= 0 || ret_val == WAITFOR_CHECK_ABORT ) {
break;
}
} else {
break;
}
}
(void)procmgr_event_notify_delete( notify_id );
fail3:
(void)ConnectDetach(coid);
fail2:
(void)ChannelDestroy(chid);
fail1:
return ret_val;
}
int asyncmsg_connect_attach(uint32_t nd, pid_t pid, int chid, unsigned index, unsigned flags, const struct _asyncmsg_connection_attr *attr)
{
struct _asyncmsg_connect_context *acc;
struct _asyncmsg_connection_descriptor *acd;
int id, size;
static pthread_mutex_t _async_init_mutex = PTHREAD_MUTEX_INITIALIZER;
_mutex_lock(&_async_init_mutex);
if (!_async_ev) {
int chid;
if ((_async_ev = malloc(sizeof(*_async_ev))) == NULL) {
_mutex_unlock(&_async_init_mutex);
return -1;
}
if ((chid = ChannelCreate(0)) == -1)
{
free(_async_ev);
_async_ev = NULL;
_mutex_unlock(&_async_init_mutex);
return -1;
}
if ((_async_ev->sigev_coid = ConnectAttach(0, 0, chid, _NTO_SIDE_CHANNEL, 0)) == -1)
{
ChannelDestroy(chid);
free(_async_ev);
_async_ev = NULL;
_mutex_unlock(&_async_init_mutex);
return -1;
}
_async_ev->sigev_notify = SIGEV_PULSE;
_async_ev->sigev_priority = SIGEV_PULSE_PRIO_INHERIT;
if ((errno = pthread_create(&_async_ev_tid, NULL, _async_event_thread, (void *)chid)) != EOK)
{
ConnectDetach(_async_ev->sigev_coid);
ChannelDestroy(chid);
free(_async_ev);
_async_ev = NULL;
_mutex_unlock(&_async_init_mutex);
return -1;
}
}
_mutex_unlock(&_async_init_mutex);
size = sizeof(*acc) + sizeof(struct _asyncmsg_put_header) * attr->max_num_buffer;
acc = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_PHYS, NOFD, 0);
if (acc == (struct _asyncmsg_connect_context *)MAP_FAILED) {
return -1;
}
memset(acc, 0, sizeof(*acc));
acd = &acc->acd;
flags |= _NTO_COF_NOSHARE;
acd->attr = *attr;
acd->flags = flags;
acd->sendq_size = attr->max_num_buffer;
acd->sendq = (struct _asyncmsg_put_header *)((char *)acc + sizeof(*acc));
if ((id = ConnectAttachExt(nd, pid, chid, index, flags, acd)) == -1) {
return -1;
}
acd->sendq_head = acd->sendq_tail = acd->sendq_free = 0;
acd->ev = *_async_ev;
acd->ev.sigev_value.sival_int = id;
acd->ev.sigev_code = 'T';
if ((acd->ttimer = TimerCreate(CLOCK_REALTIME, &acd->ev)) == (timer_t)-1) {
asyncmsg_connect_detach(id);
return -1;
}
acc->flags = _ASYNCMSG_CONNECT_TIMEROFF;
acd->ev.sigev_code = 'P';
if ((errno = pthread_mutex_init(&acd->mu, 0)) != EOK)
{
asyncmsg_connect_detach(id);
return -1;
}
if ((errno = pthread_cond_init(&acd->block_con, 0)) != EOK)
{
asyncmsg_connect_detach(id);
return -1;
}
if (_asyncmsg_handle(id, _ASYNCMSG_HANDLE_ADD, acc) == NULL) {
asyncmsg_connect_detach(id);
return -1;
}
return id;
}
void
zz_xr_serverRunOnce (TServer * const serverP) {
/*----------------------------------------------------------------------------
Accept a connection from the channel switch and do the HTTP
transaction that comes over it.
If no connection is presently waiting at the switch, wait for one.
But return immediately if we receive a signal during the wait.
-----------------------------------------------------------------------------*/
struct _TServer * const srvP = serverP->srvP;
const char * error;
TChannel * channelP;
void * channelInfoP;
extern void ChanSwitchAccept ();
extern void ChannelFormatPeerInfo ();
extern void ServerSetKeepaliveMaxConn ();
extern void serverRunChannel ();
extern void xmlrpc_strfree ();
/*
ServerSetKeepaliveMaxConn (serverP, 1);
ChanSwitchAccept (srvP->chanSwitchP, &channelP, &channelInfoP, &error);
*/
if (error) {
TraceMsg ("Failed to accept the next connection from a client "
"at the channel level. %s", error);
xmlrpc_strfree (error);
} else {
/* Handle connection in the background.
*/
switch (fork ()) {
case 0:
break; /* We are the child */
default:
return; /* We are the parent */
}
if (channelP) {
const char * error;
serverRunChannel (serverP, channelP, channelInfoP, &error);
if (error) {
const char * peerDesc;
ChannelFormatPeerInfo (channelP, &peerDesc);
TraceExit ("Got a connection from '%s', but failed to "
"run server on it. %s", peerDesc, error);
xmlrpc_strfree (peerDesc);
xmlrpc_strfree (error);
}
ChannelDestroy (channelP);
free (channelInfoP);
}
}
exit (0);
}
main (void)
{
pid_t pid_gui;
pid_t pid_sim;
pid_t pid_pport;
int simChid;
int kill_gui;
int kill_sim;
int kill_pport;
int s_return;
//---thread paramters--------------//
pthread_attr_t attr;
pthread_t timerThreadID;
pthread_t keyboardThreadID;
pthread_t blockIDThreadID;
do
{
printf("\n=========================================================\n");
printf("Please Selet the Operating Mode:\n");
printf("1: Basic Orientation Mode for Block: 0-10).\n");
printf("2: Rotated Orientation Mode for Block:0-6). (alaph version)\n");
printf("===========================================================\n");
flushall();
scanf ("%c",&programMode);
printf("You have selected: Mode %c.\n\n",programMode);
flushall();
if((programMode != '1' )&&(programMode !='2'))
{
printf("Invalid Selection, Please Enter!\n");
flushall();
}
}
while(programMode != '1'&&programMode !='2');
// ----------------Share Memory----------------------------------------
shMem=shm_open("shared_memory", OFLAGS, 0777);
if (shMem == -1)
{
printf("shared_memory failed to open...\n");
flushall();
}
else
{
if (ftruncate (shMem,SIZE) == -1)
{
printf ("Failed to set size for -- shmem -- \n");
flushall();
}
else
{
//mapping a shared memory location
memLocation = mmap (0, SIZE, PROT, MFLAGS, shMem, 0);
if (memLocation == MAP_FAILED)
{
printf (" Failed to map to shared memory...\n");
flushall();
}
}
}
// ---------------Semorphore-------------------------------------
// semorphore for shared memory
sem = sem_open ("shared_sem", O_CREAT, S_IRWXG | S_IRWXO | S_IRWXU, 0);
if (sem == (sem_t *)(-1))
{
printf ("User: Memory Semaphore failed to open....\n");
flushall();
}
else
{
sem_post(sem);
}
// -----------------------channel creation---------------------------
// Create a channels for the simulator and Gui
// The ChannelCreate function returns the channel ID
ChannelCreate(0);
ChannelCreate(0);
//ChannelCreate(0);//for pport
simChid = 1;
sleep(1);
// Spawing a process for the GUI and Simulator
pid_gui = spawnl(P_NOWAIT, "/usr/local/bin/gui_g", "gui_g", NULL);
pid_sim = spawnl(P_NOWAIT, "/usr/local/bin/newGUIPport_g", "sim", NULL);
pid_pport = spawnl(P_NOWAIT, "/usr/local/bin/testPport_g", "pport",NULL);
sleep(1);
//The Gui process automatically connect to the channel
//Thus we only need to attach the simulator process to the created channel
coidsim = ConnectAttach(0,pid_sim,simChid,0,0);
// Display error message if connection failed
if (coidsim == -1)
{
printf("coidsim error\n");
flushall();
exit(EXIT_FAILURE);
}
coidpport = ConnectAttach(0,pid_pport,simChid,0,0);
// Display error message if connection failed
if (coidpport == -1)
{
printf("coidpport error\n");
flushall();
exit(EXIT_FAILURE);
}
// --------------------------timer code----------------------------------
// Create a channel for sending a pulse to myself when timer expires
timerChid = ChannelCreate(_NTO_CHF_UNBLOCK);
if(timerChid == -1)
{
printf("timer Channel create failed\n");
flushall();
}
timerCoid = ConnectAttach ( 0, getpid ( ), timerChid, 0, 0);
if(timerCoid == -1 )
{
printf ("Channel attach failed!\n");
flushall();
perror ( NULL );
exit ( EXIT_FAILURE);
}
// Set up pulse event for delivery when the first timer expires; pulse code = 8, pulse value = 0;
SIGEV_PULSE_INIT (&timerEvent, timerCoid, SIGEV_PULSE_PRIO_INHERIT, 8, 0);
// Create Timer
if (timer_create (CLOCK_REALTIME, &timerEvent, &timerid) == -1)
{
printf ( "Failed to create a timer for pulse delivery\n");
flushall();
perror (NULL);
exit ( EXIT_FAILURE);
}
// Setup one time timer for 2 second
timer.it_value.tv_sec = 2;
timer.it_value.tv_nsec = 0;
timer.it_interval.tv_sec = 0;
timer.it_interval.tv_nsec = 0;
// --------------------------timer2 code----------------------------------
// Create a channel for sending a pulse to myself when timer expires
timerChid2 = ChannelCreate(_NTO_CHF_UNBLOCK);
if(timerChid2 == -1)
{
printf("timer Channel create failed\n");
flushall();
}
timerCoid2 = ConnectAttach ( 0, getpid ( ), timerChid2, 0, 0);
if(timerCoid2 == -1 )
{
printf ("Channel attach failed!\n");
flushall();
perror ( NULL );
exit ( EXIT_FAILURE);
}
// Set up pulse event for delivery when the first timer expires; pulse code = 8, pulse value = 0;
SIGEV_PULSE_INIT (&timerEvent2, timerCoid2, SIGEV_PULSE_PRIO_INHERIT, 8, 0);
// Create Timer
if (timer_create (CLOCK_REALTIME, &timerEvent2, &timerid2) == -1)
{
printf ( "Failed to create a timer for pulse delivery\n");
flushall();
perror (NULL);
exit ( EXIT_FAILURE);
}
//-------------------timer monitor thread--------------------
pthread_attr_init(&attr);
pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
pthread_create(&timerThreadID,&attr,timer_thread,NULL);
if(timerThreadID == -1)
{
printf("Fail to create timer thread!");
flushall();
}
else
{
printf("The timer thread ID is %i \n",timerThreadID);
flushall();
}
pthread_create(&timerThreadID,&attr,timer2_thread,NULL);
if(timerThreadID == -1)
{
printf("Fail to create timer thread2!");
flushall();
}
else
{
printf("The timer thread2 ID is %i \n",timerThreadID);
flushall();
}
//
//----start the block Identification thread-----------------
// pFile = fopen("Blocks.txt","w+");
pthread_create(&blockIDThreadID,&attr,blockID,NULL);
if(blockIDThreadID == -1)
{
printf("Fail to create block indeptification thread!");
flushall();
}
else
{
printf("The BlockID's thread ID is %i \n",blockIDThreadID);
flushall();
}
delay(10);
//---------------------keyboard thread------------------------
pthread_create(&keyboardThreadID,&attr,keyboard_input,NULL);
if(keyboardThreadID == -1)
{
printf("Fail to create keyboard input!");
flushall();
}
else
{
printf("The keyboard_input ID is %i \n",timerThreadID);
flushall();
}
delay(10);
//----------------GUI Monitor Thread---------------------
pthread_create(NULL,&attr,GUI_thread,NULL);
delay(10);
// --------------------SIM pulse Handler Loop Thread----------
pthread_create(NULL,&attr,Handlerloop_thread,NULL);
delay(10);
// --------------------SIM Monitor Thread---------------------
pthread_create(NULL,&attr,SIM_thread,NULL);
delay(10);
// --------------------Auto mode thread-----------------------
pthread_create(NULL,&attr,auto_thread,NULL);
delay(10);
// --------------------others---------------------------------
// call mainLoop()
mainLoop();
// sleep for 10sec
printf("Sleep the program for 10 seconds\n");
flushall;
sleep(10);
// start release system resourse
printf("Clean up and release system resourse\n");
flushall;
// Kill the existing processes
kill_gui = kill(pid_gui, 0);
kill_sim = kill(pid_sim, 0);
kill_pport = kill(pid_pport, 0);
if (kill_gui == -1)
{
printf("GUI Kill failed\n");
flushall();
}
if (kill_sim == -1)
{
printf("SIM Kill failed\n");
flushall();
}
if (kill_pport == -1)
{
printf("PPort Kill failed\n");
flushall();
}
// Close and unlink Semorphore
sem_close(sem);
s_return = sem_unlink("/dev/sem/home/quad6/workspace/Project_S1/shared_sem");
// Display error messae if semorphonre unlink is failed
if (s_return == -1)
{
printf("a: %s\n", strerror( errno ));
flushall();
}
// Close, unmap, and unlink shared memory
shm_close(shMem);
munmap(shmLocation,SIZE);
shm_unlink("shared_memory");
// Detach the connections and destroy the channels
ConnectDetach(coidGui);
ConnectDetach(coidsim);
ConnectDetach(coidpport);
ChannelDestroy(guiChid);
ChannelDestroy(simChid);
// fclose(pFile);
}
PeriodicThreadImplQNX::~PeriodicThreadImplQNX()
{
ChannelDestroy(m_chid);
}
