EmbLogic » Project 6: Client Server using Inter Process Communication Mechanism

Socket programming based Home Automation

Raghu Nath — Fri, 09 Dec 2016 12:04:21 +0000

The main aim of this project is to implement Socket programming using Embedded linux based boards using beagle bone as server and pc as a client. The entire electrical system like home appliances are interfaced to Server (Beagle bone black) using relay electronics system.There will be authentication system for accessing the server like user id and password which will be provided by user through client.The enhancement of authentication system will be based on shell scripts.The user can control any appliance at any time from linux terminal.The user will run application based code which is interfaced to the Client program by providing basic authentication. An acknowledgement is also provided to user to monitor the status of the Appliance by server.The protocol used here is TCP (Transmission Control protocol)Client Server model, The Client will send the request to server.The Server process takes a request from the client. After getting a request from the client, this process will perform the required processing, gather the requested information, and send it to the requester client. The user will provide some input data by command line arguments to application Client.The beagle bone Server application will be automated after initial boot power-on with the help of bashRC Scripting.

Three different thread exclusively work to open, read and write operation.

Vishal Chopra — Tue, 21 Apr 2015 16:50:00 +0000

RCS file: multi_thread.c,v
Working file: multi_thread.c
head: 1.1
branch:
locks: strict
vishal: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
Three different thread is created to open a file read the data from the file and write on some other file exclusively.
—————————-
revision 1.1 locked by: vishal;
date: 2015/04/21 16:46:47; author: vishal; state: Exp;
Initial revision

client server communication using FIFO is implemented successfully.

Amardeep Rawat — Thu, 19 Mar 2015 12:38:00 +0000

RCS file: client1.c,v
Working file: client1.c
head: 1.3
branch:
locks: strict
root: 1.3
access list:
symbolic names:
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
This is client1.c file
opened SERVER_FIFO in O_WRONLY mode.
prepare a request.
—————————-
revision 1.3 locked by: root;
date: 2015/03/19 06:53:15; author: root; state: Exp; lines: +9 -1
open CLIENT1_FIFO in O_RDONLY mode
read result from server through CLIENT1_FIFO from server.
—————————-
revision 1.2
date: 2015/03/19 06:19:21; author: root; state: Exp; lines: +1 -0
print pid
—————————-
revision 1.1
date: 2015/03/19 06:12:02; author: root; state: Exp;
Initial revision
=============================================================================

deepanshuemblinux — Tue, 13 May 2014 11:06:58 +0000

What are processes and threads??

A process is a program (object code stored on some media) in execution.
Processes are, however, more than just the executing program code (often called the text section in Unix). They also include a set of resources such as open files and pending signals, internal kernel data, processor state, an address space, one or more threads of execution, and a data section containing global variables. Processes, in effect, are the living result of running program code.

Threads of execution, often shortened to threads, are the objects of activity within the process.
Each thread includes a unique program counter, process stack, and set of processor registers. The kernel schedules individual threads, not processes.
In traditional Unix systems, each process consists of one thread. In modern systems, however, multithreaded programs those that consist of more than one thread are common.
But,to Linux, a thread is just a special kind of process.
People generally are confused that a program is a process but a process is an active program and related resources. Indeed, two or more processes can exist that are executing the same program. In fact, two or more processes can exist that share various resources, such as open files or an address space.
A process begins its life when, not surprisingly, it is created. In Linux, this occurs by means of the fork() system call, which creates a new process by duplicating an existing one.
The new process is an exact copy of the old process. (Now, a question might come immediately to our mind- who creates the first process?? The first process is the init process which is literally created from scratch during booting).
The process that calls fork() is the parent, whereas the new process is the child. The parent resumes execution and the child starts execution at the same place, where the call returns. The fork() system call returns from the kernel twice: once in the parent process and again in the newborn child.
Often, immediately after a fork it is desirable to execute a new, different, program. The exec*() family of function calls is used to create a new address space and load a new program into it. In modern Linux kernels, fork() is actually implemented via the clone() system call,
Finally, a program exits via the exit() system call. This function terminates the process and frees all its resources.
A parent process can inquire about the status of a terminated child via the wait4()system call, which enables a process to wait for the termination of a specific process.
When a process exits, it is placed into a special zombie state that is used to represent terminated processes until the parent calls wait() or waitpid().
The kernel implements the wait4() system call. Linux systems, via the C library, typically provide the wait(),waitpid(),wait3() , and wait4() functions. All these functions return status about a terminated process, albeit with slightly different semantics.
Another name for a process is a task. although when we say task we generally mean a process from the kernel’s point of view

IPC

Jatinder Kumar — Wed, 10 Apr 2013 15:08:56 +0000

Today i learned how to save file descriptor, how to use PIPE.

Project 6: Client Server using Inter-process Communication Mechanism

admin — Tue, 02 Oct 2012 14:18:47 +0000

The purpose of this discussion is to get the participants familiar with the different mechanisms that are available for communicating between two or more processes. Inter-Process Communication, which in short is known as IPC, deals mainly with the techniques and mechanisms that facilitate communication between processes. Now, why do we need special separate mechanisms or techniques for communicating between processes? Why isn’t it possible to have information shared between two processes without using such special mechanisms?