The project involved configuring Apache server(alongwith SElinux configuration for apache),writing CGI applications, interfacing the CGI application with the device( which involved the linux IPC mechanism also).

video attached to this post shows how the device is controlled through a web browser on a tablet phone while the USB device was attached to a laptop.

What is Inter-process Communication?

Inter-process communication as the name suggests is the exchange of information between two dependent /independent processes.

Why it is required?

There are cases when processes may need to work together;for example a process may need to compress an image that is to be performed by some other process,in that case the first process must tell the second process that it needs its services and hence send image and receive the compressed image. Thus the requirement of inter-process communication.

How inter-process communication is needed?

In Linux,inter-process communication is achieved using:-

->Signals

->Pipes

->FIFO’s

->Message queues

->Shared memory

->Semaphores

Signals,Shared memory and Message queues are mostly used as synchronization techniques rather than as Inter-process Communication mechanism.

Project Implementation:-

Aim:-To achieve inter-process communication between multiple client(requesting and processing) processes and a single server using Inter-process communication techniques.

Explanation:-

In this project multiple requesting clients requests a server process to get their respective results

Requesting Client 1———->S V————->Processing Client 1

Requesting Client 2———->E E————->Processing Client 2

Requesting Client 3———->R R————>Processing Client 3

Server is always runing in the background.

Firstly requesting client requests the server by sending the data along with the data it wants to get performed.

Next the server receives the request and it sends the same request to the processing client.

Now the processing client processes the data and should return the result to the server.

Meanwhile the procesing client is processing the request, the requesting client and the server should wait.

After the processing client sends the result to the server,the server sends the result to the requesting client.

There can be many requesting clients thus the server should be prepared for it.

Implementation:-

The project was implemented using Pipes,FIFOs and Pipes,Message queues, FIFOs and shared memory and FIFOs and message queues.

Challenges:-

->The major challenge during the project implementation was the synchronization between the requesting client and the server And server and processing client.

When implemented using pipes,synchronization was acheived using the signals mechanism. The requesting clients after sending the request waits for a signal from the server indicating that result is available.

At the same time the server waits for the result from processing client using signal.

In case of implementation using FIFOs and pipes,synchronization was acheived using signals.

For message queues,synchronization was acheived using the tokens only.

And semaphores were used for the other implementations of the same project.

->The next challenge was the encapsulating of the requests and the results into a single packet that would be exchanges between the processes. Since request consisted of many things,they were converted to a single packet of data using sprintf() function.

Same method was used for the result.

INTRODUCTION TO PROJECT
All digital data is stored in form of binary 0s and 1s internally. Working on embedded devices that are memory constrained these files need to be managed efficiently and effectively. Also when transferring file over the network, larger the file size larger is the bandwidth requirement to transfer the same. Hence the requirement of some technique that could take less space and less bandwidth for transmission.

One such technique that can be used for saving memory is compressing the files using some algorithm so that they acquire less space on disk. This technique not only serves the purpose of consuming less space but also provides data security since the file that will be generated after the compression is usually not in human-readable form. Since a normal file does not use all the 255 characters of ASCII table,representing each character by one byte consumes a lot more space. Thus if each distinct character in a file can be represented by fewer bits same data can be saved in much less space;hence accomplishing the purpose.

Here’s the simple stepwise working of the project:-
COMPRESSION
1.) Open the file to be compressed.
2.) Find the distinct characters in the file and store it in an array(master array).
3.) From the master array find the maximum number of bits required to represent each distinct character in compressed file.
4.) Read the file character by character.
5.) Replace each character with the index of the corresponding character in master array.
6.) Manipulate the indexes in the form of 1 byte using shift operations.
7.) Write the manipulated indexes to the compressed file.
8.) Store the master array in other file so that it could be used at the time of decompression.

DECOMPRESSION
1.) Open the compressed file.
2.) Open the file containing master array and store it in array.
3.) Form the master array find out the number of bits used to represent each character.
4.) Read the compressed file character by character.
5.) From this read characters filter out the actual ASCII characters using shift operations and indexes.
6.) Save the filtered out ASCII characters to new file.

Besides this the project can further be enhanced if the master array is also encrypted and this master array is used as the decryption key between the compressing and decompressing programs.

Finally the project was successfully implemented with the very good compression ratio. Also the project was implemented using two techniques;one was using the structured approach based on the number of bits required and the other was a general purpose program in which only a single piece of code could compress or decompress the file.

Kamal :- Completed IPC project using shared memory and semaphores.

Harpreet Singh :- Completed IPC project using shared memory,semaphores,FIFO and Pipes.

Rahul Singh :- Working on IPC project using FIFO(working on getting result by second FIFO)

Rekha:- Implemented IPC project uisng pipes and FIFOs.
Working on IPC project using MEssage Queues.

Kamal:- Implemented IPC between two processes using shared memory.
Working on IPC project using shared memory and semaphores.

Harpreet Singh :- Implemented IPC between two processes using Shared memory.
Working on IPC project using shared memory,semaphores,FIFO and                                       Pipes

Prabhjot Singh:- Completed IPC project using shared memory,semaphores,FIFO and                                         Pipes

Harpreet Singh : 1) Successfully implemented IPC using pipes with and without using signals.
2) Successfully implemented IPC using pipes and FIFOs with and without using signals.

Prabhjot Singh  : Successfully implemented IPC using :-
1) pipes(Synchronized using  Signals)
2) FIFOs and pipes(Synchronised using Signals)
3) Message Queues, FIFOs and Pipes.

Other Team members are requested to please mail there progress in project ASAP as no mails were received.

And how arithmetic operations are manipulated with integers/numbers, if they are stored as strings(or ASCII values)????