Parallel data transferring methods in microprocessor based system

Parallel transmission of data is used for short fragment where the speed of information trade is key. This kind of data correspondence is found in more present kind of PC edges gear with change size of to one million characters for dependably. The device hardens printers, plate drives and unmistakable sorts of periphery pieces. The information exchanged between a chip and an I/O interface circuit contains data or yield data and control information.

The status information attracts the microchip screen the device and when it is engineered then send or get data. Control information is the summon by chip to recognize I/O contraption to make some move. In case the contraption works at particular speeds, then microchip can be used to pick a particular pace of operation of the device. The structures used to trade data between different rates devices and PC is called synchronizing.

There are specific techniques for synchronization procedures which are intertwined in parallel data trade, for event, direct information and yield, basic strobe I/O, single handshaking what's more, twofold handshaking.

 Simple I/O

To get prompted data from a principal switch into a microchip; switch is associated on data port line from which port can be inspected. The data is always present and composed with the objective that it can be dissected at whatever point. On a very basic level to yield data to a urgent presentation contraption like LED, the commitment of LED support is associated on a yield port pin. Besides, the reason level required turning on the light. The LED is reliably there and planned with the objective that data can be sent at whatever point.

 Simple Strobe I/O

In various applications, true blue data is accessible on an outside device exactly at a particular time and ought to be inspected in around then. Here a strobe pulse is supplied to demonstrate the time at which data is being transmitted. For an outline, we can discuss the ASCII encoded console. Decisively when a key is pummeled, equipment on console goes on ASCII code for pressed key on eight parallel data lines and a brief traverse later goes on a strobe signal on a substitute line to show that liberal data is accessible on eight data lines. The sending contraption yields parallel data on the data lines, and a brief time allotment later yields STB' sign to convey the good 'ol fashioned data is open. In this framework, microchips need to hold up until the contraption is set up for the operation otherwise called clear hold up I/O. Consider a key console containing 8 changes connected with a microchip through a parallel interface circuit (Tri-state pad).

Input Handshake

The periphery yields a few data and sends some strobe sign to chip. Chip sees imparted strobe signal (STB') and looks at the byte of the data. Processor then sends confirmation signal (ACK) to periphery to show that the data has been reviewed and can send next byte of data.

Output Handshake

Microchip yields data to edges and takes the stand concerning a strobe (STB') signal. If edges is readied it answers back with solicitation (ACK) sign to microchip.

8255 microprocessor Programming and Operation

A high on the RESET pin causes every one of the 24 lines of the three 8-bit ports to be in the information mode. All flip-lemon are cleared and the counteracts are reset. This condition is kept up even after the RESET goes low. The ports of the 8255 can then be revamped for some other mode by sending out a solitary yield making a beeline for the control register. Additionally, the present system for operation can be changed by framing a solitary mode word onto the control register, when required.

Modes for Group A and Group B can be self-governing portrayed with Port C taking care of responsibilities as managed by the mode definitions or Ports An and B. In the event that Group A is altered for Mode 0, and Bunch B is revamped for Mode 1, Port An and PC4–PC7 can be changed for either enter or yield, while Port B can be balanced for information or yield with PC0–PC2 utilized for handshaking.

The mode definition blueprint and bit set-reset setup are examined in above core interests. The control words for both mode definition and Bit Set-Reset are stacked into the same control register, with bit D7 utilized for making sense of if the word stacked into the control register is a mode definition word or Bit Set-Reset word. In the event that D7 is high, the word is taken as a mode definition word, and in the event that it is low, it is taken as a Bit Set-Reset word. The most ideal bits are set of reset ward upon the sort of operation pined for, and stacked into the control register (which is gotten to when A1 and A0 both are '1'; W/R and CS both are '0'. It is to be seen that Group B does not have procurement for operation in Mode 2.

The eight conceivable mixes of the conditions of bits D1 - D3 (B2 B1 B0) in the Bit Set-Reset position (from this time forward inferred as BSR) pick the specific piece in PC0-PC7 being set or reset as demonstrated by the status of bit D0. A BSR word is to be made for every piece that is to be set or reset. For case, if bit PC2 is to be set and bit PC7 is to be reset, the most ideal BSR words that will must be stacked into the control register will be, 0XXX001 and 0XXX1110, only, where X can be either "0" or '1'.

The BSR, word can in like way be utilized for empowering or debilitating meddle with signs conveyed by Port C right when the 8255 is changed for Mode 1 or Mode 2 operation. This is finished by setting or resetting the related bits of the intrudes.

Microprocessor Based Instrumentation System

Microprocessor

A Microprocessor is a multipurpose programmable, clock driven, register based electronic gadget delivered utilizing signal bargains from SSI to VLSI that examines twofold standards from a breaking point gadget called memory, perceives joined information as information, strategies information as indicated by those headings and give results as yield.

Instrumentation System

The framework which is characterized as the get together of different instruments and different parts interconnected to quantify, break down and control physical amounts, for example, electrical, warm, mechanical and so forth.

Microprocessor Based Instrumentation System

The system which is defined as the assembly of various instruments and other components interconnected to measure, analyze and control physical quantities such as electrical, thermal, mechanical etc. Any instrumentation systems centered around a microprocessor are known as microprocessor based system. Logical and computing power of microprocessor has extended the capabilities of many basic instruments, improving accuracy and efficiency of use. Microprocessor is versatile device for use in any instrumentation system. Examples are ATM, automatic washing machine, fuel control, oven etc.

Importance of microprocessor

·        Can be used in any system.

·        Can be used in specific applications and specific design.

·        Logical and computational power of microprocessor has been used to develop more accurate and efficient system.

Disadvantages of microprocessor

·        Complexity in interfacing.

·        Need to learn complex machine subordinate dialect.

·        Need of a costly microchip advancement framework.

·   Yet, every one of these issues is acknowledged if framework planned offers various units so that the advancement cost spreads out.

Features of Microprocessor Based System

·        Three fragments: Microprocessor, I/O, and memory.

·        Decision making power in light of past entered values.

·        Repeatability of readings.

·        User pleasant (Signal readout).

·        Parallel taking care of.

·        Timeshare and multiprocessing.

·        Data storage, retrieval and transmission.

·        Effective control of multiple equipments on time sharing basis.

·        A lot of processing capability.

Dynamic Memory Allocation

Dynamic memory allocation (DMA) technique is used to allocate or deallocate the memory dynamically i.e. whenever we need the memory size. Using this concept space size can be saved.

Syntax:

datatype *array = (type casting ) malloc (num * sizeof (type));

datatype *array = (type casting ) calloc (num * sizeof (type));

array = realloc (array);

free (array);

Program to enter name and roll number of student and display it using Dynamic Memory Allocation Concept

#include<stdio.h>

#include<string.h>

int main()

{

    char name[5][10], tname[10];

    int roll[5],temp,i,j;

    for (i=0;i<5;i++)

    {

        printf("Enter the roll number and name : ");

        scanf("%d %s",&roll[i],name[i]);

    }

    for(i=0;i<4;i++)

    {

        for (j=i+1;j<5;j++)

        {

            if (strcmp(name[i],name[j])>0)

            {

                temp=roll[i];

                roll[i]=roll[j];

                roll[j]=temp;

                strcpy(tname,name[i]);

                strcpy(name[i],name[j]);

                strcpy(name[j],tname);

            }

        }

    }

    for(i=0;i<5;i++)

    {

        printf("%d\t%s\n",roll[i],name[i]);

    }

    return 0;

}

Program to calculate sum and average of entered numbers

#include<stdio.h>

int main()

{

    int a[10],*b,i;

    float sum=0,avg;

    b=a;

    printf("Enter 10 numbers : ");

    for (i=0;i<10;i++)

    {

        scanf(" %d",a+i);

        sum+=*(a+i);

    }

    avg=sum/10;

    printf("%d %2f",sum,avg);

    return 0;

}

Program to calculate sum and average of entered numbers using Dynamic Memory Allocation Concept

#include<stdio.h>

void calculate(float a[]);

int main()

{

    float a[10];

    int j;

    printf("Enter 10 numbers");

    for(j=0;j<10;j++)

    {                                                                 

        scanf("%f",&a[j]);

    }

    calculate(a);

    return 0;

}

void calculate(float a[10])

{

    int i;

    float sum=0,avg;

    for(i=0;i<10;i++)

    {

        sum+=a[i];

    }

    avg=sum/10;

    printf("The sum of 10 numbers is %f",sum);

    printf("\n");

    printf("The average is %2f",avg);

}

BRESENHAM’S LINE DRAWING ALGORITHM

An accurate and efficient raster line generating algorithm developed by Bresenham, scan converts lines using only incremental integer calculation that can be adopted to display circles and other curves.

          To illustrate Bresenham’s approach, we consider the scan conversion process for lines with slopes greater and less than unity. In the former case, pixels positions along the line path are determined by sampling at a unit ‘y’ intervals. Starting from first end point (x₀,y₀) of the given line, we step to each successive y-position and plot the pixel whose scan-line x-value is closest to the line path. Assuming we have determined that the pixel at (x_k, y_k) is to be displayed, we next need to decide which pixel to plot in y_k+1^th row. Our choices are the pixels at (x_k, y_k+1) and (x_k +1, y_k +1).

Source code

#include<graphics.h>

#include<stdio.h>

#include<conio.h>

#include<math.h>

#include<stdlib.h>

void main()

{

          int x1,y1,x2,y2,xi,yi,dx,dy,k,p;

          int gdrive=DETECT, gmode;

          initgraph(&gdrive, &gmode, "c:\\tc\\bgi");

          printf("Enter two end points (x1,y1) and (x2,y2):");

          scanf("%d%d%d%d",&x1,&y1,&x2,&y2);

          dx=abs(x2-x1);

          dy=abs(y2-y1);

          if (x2>x1)

          {

                   xi=1;

          }

          else

          {

                   xi=-1;

          }

          if (y2>y1)

          {

                   yi=1;

          }

          else

          {

                   yi=-1;

          }

          putpixel(x1,y1,RED);

          if (dx>dy)

          {

                   p=(2*dy)-dx;

                   k=0;

                   do

                   {

                       if(p<0)

                       {

                             x1=x1+xi;

                             p=p+(2*dy);

                       }

                       else

                       {

                             x1=x1+xi;

                             y1=y1+yi;

                             p=p+(2*dy)-(2*dx);

                       }

                       putpixel(x1,y1,RED);

                       k++;

                   }while(k<=dx);

          }

          else

          {

                   p=(2*dx)-dy;

                 // k=0;

                    for(k=0;k<=dy;k++)

                   {

                             if(p<0)

                             {

                                      y1=y1+yi;

                                      p=p+(2*dx);

                             }

                             else

                             {

                                      x1=x1+xi;

                                      y1=y1+yi;

                                      p=p+(2*dx)-(2*dy);

                             }

                             putpixel(x1,y1,RED);

                   }

          }

          getch();

          closegraph();

}

Note: Above source code is implanted in c++ programming language and witten using  turboC++   libraries.

HUFFMAN ALGORITHM

The Huffman algorithm is a basic algorithm to represent the data stream in a tree. It is arranged according to the frequencies of the data.

Source code for Huffman Algorithm implemented in C++

#include<iostream>

#include<queue>

using namespace std;

class Node {

    private:

        float m_pro;

        bool m_value;

        Node* m_father;

        string m_sym;

    public:

        Node(string& sym,float pro):m_pro(pro),m_value(false),m_father(NULL),m_sym(sym){}

        Node(Node& a,Node& b,bool value=0):m_father(NULL),m_value(false),m_sym(""){

            m_pro = a.m_pro+b.m_pro;

            a.m_father = b.m_father = this;

            a.m_value = false;

            b.m_value = true;

        }

        float probability() const {

            return m_pro;

        }

        bool value() const{

            return m_value;

        }

        string symbol() const{

            return m_sym;

        }

        Node* father() const{

            return m_father;

        }

};

class NodeCompare {

    public:

        // Acts a < for determining priority

        bool operator()(Node* n1,Node* n2) const {

            if( n1->probability() > n2->probability() ) return true;

            return false;

        }

};

int main(){

    unsigned n;

    std::cout << "Enter the no. of entries: ";

    std::cin >> n;

    if( n == 1){

        std::cout << "1! You're joking, right?";

        return 0;

    }

    Node** list = new Node*[2*n];

    priority_queue<Node*, vector<Node*>, NodeCompare> pq;

    unsigned j;

    for(j=0;j<n;j++){

        string symbol;

        float pro;

        std::cout << "Enter the Symbol and Probability: ";

        std::cin >> symbol >> pro;

        list[j] = new Node(symbol,pro);

        pq.push(list[j]);

    }

    while(pq.size() > 1) {

        Node* one = const_cast<Node*>(pq.top());

        pq.pop();

        Node* two = const_cast<Node*>(pq.top());

        pq.pop();

        list[j] = new Node(*one,*two);

        pq.push(list[j]);

        j++;

    }

    pq.pop();

    for(int i=0;i<n;i++){

        std::cout << list[i]->symbol() << ": ";

        Node one = *list[i];

        while( one.father() != NULL){

            std::cout << one.value();

            one = *one.father();

        }

        std::cout << std::endl;

    }

    for(int i=0;i<j;i++)

        delete list[j];

    delete []list;

    return 0;

}

DIJKSTRA ALGORITHM

Dijkstra algorithm is a shortest path algorithm to find the shortest path from source and destination in a weighted graph. In this algorithm, we began with a initial node and calculate the short distance from each node and updated the shortest path. This process continues until we reach to a destination node.

Program code of dijkstra algorithm implemented in C++

#include<iostream>

#include<vector>

#include<climits>

using namespace std;

class Node{

    unsigned m_name;

    public:

    Node(unsigned name):m_name(name){}

    int name() const { return m_name;}

    bool operator==(Node a){

        return m_name == a.m_name;

    }

    operator unsigned(){

        return m_name;

    }

};

class Arc {

    private:

        unsigned m_weight;

        Node m_from,m_to;

    public:

        Arc(Node a,Node b,unsigned weight=0):m_from(a),m_to(b),m_weight(weight){}

        unsigned weight() const { return m_weight;}

        Node to() const { return m_to; }

        Node from() const {return m_from;}

        bool operator==(const Arc& a){

            if(m_from == a.m_from && m_to == a.m_to )

                return true;

            return false;

        }

};

class Graph{

    private:

        vector<Arc> m_arc;

        int m_max;

    public:

        Graph():m_max(0){}

        void add(Node a,Node b,unsigned weight=0){

            if( a.name() > m_max-1 ) m_max = a+1;

            else if ( b.name() > m_max-1 ) m_max = b+1;

            m_arc.push_back(Arc(a,b,weight));

        }

        unsigned distance(Node a,Node b){

            if (a == b) return 0;

            Arc one(a,b),two(b,a);

            for(int i=0;i<m_arc.size();i++){

                if( m_arc[i] == one || m_arc[i] == two )

                    return m_arc[i].weight();

            }

            return UINT_MAX;

        }

        unsigned minpath(Node a,Node b){

            bool *complete = new bool[m_max];

            unsigned *dist = new unsigned[m_max];

            for(int i=0;i<m_max;i++){

                complete[i] = false;

                dist[i] = UINT_MAX;

            }

            unsigned current = a;

            dist[current] = 0;

            complete[current] = true;

            while ( current != b ){

                unsigned leastindex;

                unsigned least = UINT_MAX;

                for(int i=0;i < m_max;i++){

                    if( complete[i] == true ) continue;

                    unsigned newdist = distance(current,i);

                    newdist += (newdist==UINT_MAX)?0:dist[current];

                    if( newdist < dist[i] )

                        dist[i] = newdist;

                    if( dist[i] < least ){

                        least = dist[i];

                        leastindex = i;

                    }

                }

                current = leastindex;

                complete[current] = true;

            }

            unsigned r = dist[b];

            delete []dist;

            delete []complete;

            return r;

        }

};

int main(){

    Graph g;

    g.add(5,1,1);

    g.add(5,2,4);

    g.add(5,3,3);

    g.add(1,2,1);

    g.add(1,4,7);

    g.add(2,3,2);

    g.add(3,4,2);

    cout << "Shortest path is: " << g.minpath(2,4) << endl; // 4

    return 0;

}