#include <stdio.h>
int main() {
    printf("Hello, QNX Neutrino!\n");
    return 0;
}

Basic Hello World program for QNX Neutrino RTOS.

#include <stdio.h>
#include <pthread.h>

void* threadFunc(void* arg) {
    printf("Thread running\n");
    return NULL;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, threadFunc, NULL);
    pthread_join(tid, NULL);
    return 0;
}

Shows how to create a thread using pthreads in QNX.

#include <stdio.h>
#include <sys/neutrino.h>
#include <unistd.h>

int main() {
    int chid = ChannelCreate(0);
    int coid = ConnectAttach(0, 0, chid, 0, 0);
    MsgSend(coid, "Hello", 6, NULL, 0);
    ChannelDestroy(chid);
    return 0;
}

Demonstrates message passing between processes in QNX.

#include <stdio.h>
#include <time.h>

int main() {
    struct itimerspec ts;
    ts.it_value.tv_sec = 1;
    ts.it_value.tv_nsec = 0;
    ts.it_interval.tv_sec = 1;
    ts.it_interval.tv_nsec = 0;

timer_t timerid;
    timer_create(CLOCK_REALTIME, NULL, &timerid);
    timer_settime(timerid, 0, &ts, NULL);
    printf("Timer started\n");
    while(1);
    return 0;
}

Sets up a periodic timer in QNX Neutrino.

#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd = shm_open("/myshm", O_CREAT | O_RDWR, 0666);
    ftruncate(fd, 1024);
    char* ptr = mmap(NULL, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    sprintf(ptr, "Hello from shared memory");
    printf("%s\n", ptr);
    munmap(ptr, 1024);
    shm_unlink("/myshm");
    return 0;
}

Demonstrates use of shared memory between processes in QNX.

#include <stdio.h>
#include <semaphore.h>
#include <pthread.h>

sem_t sem;

void* worker(void* arg) {
    sem_wait(&sem);
    printf("Inside critical section\n");
    sem_post(&sem);
    return NULL;
}

int main() {
    sem_init(&sem, 0, 1);
    pthread_t tid;
    pthread_create(&tid, NULL, worker, NULL);
    pthread_join(tid, NULL);
    sem_destroy(&sem);
    return 0;
}

Using a POSIX semaphore in QNX Neutrino.

#include <stdio.h>
#include <signal.h>

void handler(int signo) {
    printf("Interrupt received\n");
}

int main() {
    signal(SIGINT, handler);
    printf("Press Ctrl+C to trigger interrupt\n");
    while(1);
    return 0;
}

Registers a simple interrupt handler in QNX.

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>

int main() {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(5000);
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    connect(sock, (struct sockaddr*)&addr, sizeof(addr));
    send(sock, "Hello QNX", 10, 0);
    close(sock);
    return 0;
}

Basic TCP client example for QNX.

#include <stdio.h>
#include <sys/neutrino.h>
#include <unistd.h>

int main() {
    int chid = ChannelCreate(0);
    char buf[128];
    MsgReceive(chid, buf, sizeof(buf), NULL);
    printf("Received: %s\n", buf);
    ChannelDestroy(chid);
    return 0;
}

Receive a message from another process using QNX message passing.

#include <stdio.h>
#include <process.h>

int main() {
    pid_t pid = spawnlp(P_NOWAIT, "/bin/echo", "echo", "Hello QNX", NULL);
    waitpid(pid, NULL, 0);
    return 0;
}

Spawns a child process in QNX Neutrino.