sample calculator using simple gui tkinter in python

""" ***********************************************
programming Language :Python
Tool(IDE) used :Anaconda -> Spider
 date:03-07-2019
 created by:ANIL DURGAM

*****************************************************"""
# Python program to create a simple GUI

# calculator using Tkinter

# import everything from tkinter module

from tkinter import *


# globally declare the expression variable

expression = ""


# Function to update expressiom

# in the text entry box

def press(num):

 # point out the global expression variable

 global expression

 # concatenation of string

 expression = expression + str(num)
 # update the expression by using set method

 equation.set(expression)
# Function to evaluate the final expression

def equalpress():

 # Try and except statement is used

 # for handling the errors like zero

 # division error etc.

 # Put that code inside the try block

 # which may generate the error

 try:

  global expression

  # eval function evaluate the expression

  # and str function convert the result

  # into string

  total = str(eval(expression))



  equation.set(total)



  # initialze the expression variable

  # by empty string

  expression = ""

 # if error is generate then handle

 # by the except block

 except:

  equation.set(" error ")

  expression = ""

# Function to clear the contents

# of text entry box

def clear():

 global expression

 expression = ""

 equation.set("")

# Driver code

if __name__ == "__main__":

 # create a GUI window

 gui = Tk()
 # set the background colour of GUI window

 gui.configure(background="light green")
 # set the title of GUI window

 gui.title("Simple Calculator")
 # set the configuration of GUI window

 #gui.geometry("265x125")
 gui.geometry("360x180")

 # StringVar() is the variable class

 # we create an instance of this class

 equation = StringVar()
 # create the text entry box for

 # showing the expression .

 expression_field = Entry(gui, textvariable=equation)
 # grid method is used for placing

 # the widgets at respective positions

 # in table like structure .

 expression_field.grid(columnspan=4, ipadx=80)

 equation.set('enter your expression')

 # create a Buttons and place at a particular

 # location inside the root window .

 # when user press the button, the command or

 # function affiliated to that button is executed .

 button1 = Button(gui, text=' 1 ', fg='black', bg='white',

     command=lambda: press(1), height=1, width=7)

 button1.grid(row=2, column=0)



 button2 = Button(gui, text=' 2 ', fg='black', bg='white',

     command=lambda: press(2), height=1, width=7)

 button2.grid(row=2, column=1)



 button3 = Button(gui, text=' 3 ', fg='black', bg='white',

     command=lambda: press(3), height=1, width=7)

 button3.grid(row=2, column=2)



 button4 = Button(gui, text=' 4 ', fg='black', bg='white',

     command=lambda: press(4), height=1, width=7)

 button4.grid(row=3, column=0)



 button5 = Button(gui, text=' 5 ', fg='black', bg='white',

     command=lambda: press(5), height=1, width=7)

 button5.grid(row=3, column=1)



 button6 = Button(gui, text=' 6 ', fg='black', bg='white',

     command=lambda: press(6), height=1, width=7)

 button6.grid(row=3, column=2)



 button7 = Button(gui, text=' 7 ', fg='black', bg='white',

     command=lambda: press(7), height=1, width=7)

 button7.grid(row=4, column=0)



 button8 = Button(gui, text=' 8 ', fg='black', bg='white',

     command=lambda: press(8), height=1, width=7)

 button8.grid(row=4, column=1)



 button9 = Button(gui, text=' 9 ', fg='black', bg='white',

     command=lambda: press(9), height=1, width=7)

 button9.grid(row=4, column=2)



 button0 = Button(gui, text=' 0 ', fg='black', bg='white',

     command=lambda: press(0), height=1, width=7)

 button0.grid(row=5, column=0)



 plus = Button(gui, text=' + ', fg='black', bg='white',

    command=lambda: press("+"), height=1, width=7)

 plus.grid(row=2, column=3)



 minus = Button(gui, text=' - ', fg='black', bg='white',

    command=lambda: press("-"), height=1, width=7)

 minus.grid(row=3, column=3)



 multiply = Button(gui, text=' * ', fg='black', bg='white',

     command=lambda: press("*"), height=1, width=7)

 multiply.grid(row=4, column=3)



 divide = Button(gui, text=' / ', fg='black', bg='white',

     command=lambda: press("/"), height=1, width=7)

 divide.grid(row=5, column=3)



 equal = Button(gui, text=' = ', fg='black', bg='white',

    command=equalpress, height=1, width=7)

 equal.grid(row=5, column=2)



 clear = Button(gui, text='Clear', fg='black', bg='white',

    command=clear, height=1, width=7)

 clear.grid(row=5, column='1')



 # start the GUI

 gui.mainloop()



output:

python interview questions part 1

Question 1:
x = 6
print(6)
print("6")
what is the out put for the above code??

Question 2:

value1 = eval(input('Please enter a number: '))
value2 = eval(input('Please enter another number: '))
sum = value1 + value2
print(value1, '+', value2, '=', sum)

what is output for the above code??


Question 3:

print(10/3, 3/10, 10//3, 3//10)

out put of the above print??

input function in python

""" ***********************************************
programming Language :Python
Tool(IDE) used :Anaconda -> Spider
 date:06-06-2019
 created by:ANIL DURGAM

*****************************************************"""
print('Please enter an integer value:')
x = input()
print('Please enter another integer value:')
y = input()
num1 = int(x)
num2 = int(y)
print(num1, '+', num2, '=', num1 + num2)

output:
Please enter an integer value:

25
Please enter another integer value:

52
25 + 52 = 77

typed function use in python

print('Please enter some text:')
x = input()
print('Text entered:', x)
print('Type:', type(x))

output:
Please enter some text:

anil
Text entered: anil
Type: <class 'str'>



type is used for find the catagory of the given input

Importing functions from a module in python

Importing functions from a module
Three ways to import functions:
1.
the simplest way: import everything from a module
advantage: simple usage e.g. of math functions
disadvantage: risk of naming conflicts when a variable has the same name as a module function
from numpy import *
print sin(pi/4)
# With this import method the following would give an error:
#sin = 5 # naming conflict!
#print sin(pi/4)
2.
import module under an alias name that is short enough to enhance code clarity
advantage: it is clear to see which function belongs to which module
import numpy as np
print np.sin(np.pi/4)
3.
import only the functions that are needed
advantage: simple usage e.g. of math functions
naming conflict possible, but less probable than with 1.
disadvantage: you must keep track of all the used functions and adapt the import statement if a
new function is used
from numpy import linspace, sin, exp, pi
print sin(pi/4)

using matplot lib

""" ***********************************************
programming Language :Python
Tool(IDE) used :Anaconda -> Spider
 date:06-06-2019
 created by:ANIL DURGAM

*****************************************************"""
from numpy import linspace, sin, exp, pi
import matplotlib.pyplot as mp
# calculate 500 values for x and y without a for loop
x = linspace(0, 10*pi, 500)
y = sin(x) * exp(-x/10)
# make diagram
mp.plot(x,y)
mp.show()


output:


numpy usage in python

""" ***********************************************
programming Language :Python
Tool(IDE) used :Anaconda -> Spider
 date:06-06-2019
 created by:ANIL DURGAM

*****************************************************"""
import numpy as np
# calculate 100 values for x and y without a for loop
x = np.linspace(0, 2* np.pi, 100)
y = np.sin(x)
print(x)
print(y)

output:

[0.         0.06346652 0.12693304 0.19039955 0.25386607 0.31733259
 0.38079911 0.44426563 0.50773215 0.57119866 0.63466518 0.6981317
 0.76159822 0.82506474 0.88853126 0.95199777 1.01546429 1.07893081
 1.14239733 1.20586385 1.26933037 1.33279688 1.3962634  1.45972992
 1.52319644 1.58666296 1.65012947 1.71359599 1.77706251 1.84052903
 1.90399555 1.96746207 2.03092858 2.0943951  2.15786162 2.22132814
 2.28479466 2.34826118 2.41172769 2.47519421 2.53866073 2.60212725
 2.66559377 2.72906028 2.7925268  2.85599332 2.91945984 2.98292636
 3.04639288 3.10985939 3.17332591 3.23679243 3.30025895 3.36372547
 3.42719199 3.4906585  3.55412502 3.61759154 3.68105806 3.74452458
 3.8079911  3.87145761 3.93492413 3.99839065 4.06185717 4.12532369
 4.1887902  4.25225672 4.31572324 4.37918976 4.44265628 4.5061228
 4.56958931 4.63305583 4.69652235 4.75998887 4.82345539 4.88692191
 4.95038842 5.01385494 5.07732146 5.14078798 5.2042545  5.26772102
 5.33118753 5.39465405 5.45812057 5.52158709 5.58505361 5.64852012
 5.71198664 5.77545316 5.83891968 5.9023862  5.96585272 6.02931923
 6.09278575 6.15625227 6.21971879 6.28318531]
[ 0.00000000e+00  6.34239197e-02  1.26592454e-01  1.89251244e-01
  2.51147987e-01  3.12033446e-01  3.71662456e-01  4.29794912e-01
  4.86196736e-01  5.40640817e-01  5.92907929e-01  6.42787610e-01
  6.90079011e-01  7.34591709e-01  7.76146464e-01  8.14575952e-01
  8.49725430e-01  8.81453363e-01  9.09631995e-01  9.34147860e-01
  9.54902241e-01  9.71811568e-01  9.84807753e-01  9.93838464e-01
  9.98867339e-01  9.99874128e-01  9.96854776e-01  9.89821442e-01
  9.78802446e-01  9.63842159e-01  9.45000819e-01  9.22354294e-01
  8.95993774e-01  8.66025404e-01  8.32569855e-01  7.95761841e-01
  7.55749574e-01  7.12694171e-01  6.66769001e-01  6.18158986e-01
  5.67059864e-01  5.13677392e-01  4.58226522e-01  4.00930535e-01
  3.42020143e-01  2.81732557e-01  2.20310533e-01  1.58001396e-01
  9.50560433e-02  3.17279335e-02 -3.17279335e-02 -9.50560433e-02
 -1.58001396e-01 -2.20310533e-01 -2.81732557e-01 -3.42020143e-01
 -4.00930535e-01 -4.58226522e-01 -5.13677392e-01 -5.67059864e-01
 -6.18158986e-01 -6.66769001e-01 -7.12694171e-01 -7.55749574e-01
 -7.95761841e-01 -8.32569855e-01 -8.66025404e-01 -8.95993774e-01
 -9.22354294e-01 -9.45000819e-01 -9.63842159e-01 -9.78802446e-01
 -9.89821442e-01 -9.96854776e-01 -9.99874128e-01 -9.98867339e-01
 -9.93838464e-01 -9.84807753e-01 -9.71811568e-01 -9.54902241e-01
 -9.34147860e-01 -9.09631995e-01 -8.81453363e-01 -8.49725430e-01
 -8.14575952e-01 -7.76146464e-01 -7.34591709e-01 -6.90079011e-01
 -6.42787610e-01 -5.92907929e-01 -5.40640817e-01 -4.86196736e-01
 -4.29794912e-01 -3.71662456e-01 -3.12033446e-01 -2.51147987e-01
 -1.89251244e-01 -1.26592454e-01 -6.34239197e-02 -2.44929360e-16]

functions2 in puthon

""" ***********************************************
programming Language :Python
Tool(IDE) used :Anaconda -> Spider
 date:06-06-2019
 created by:ANIL DURGAM

*****************************************************"""
# function definition
def greeting():
    print("HELLO")
# main program using defined functions
greeting()

output:
HELLO

functions in python

""" ***********************************************
programming Language :Python
Tool(IDE) used :Anaconda -> Spider
 date:06-06-2019
 created by:ANIL DURGAM

*****************************************************"""
# function definitions
# calculate area of a rectangle
def area(b, h):
    A = b * h
    return A

#calulates perimeter of a rectangle
def perimeter(b, h):

    P = 2 * (b+h)
    return P

# main program using defined functions
width = 5
height = 3
print ("Area = ", area(width, height))
print ("Perimeter = ", perimeter(width, height))


output:
Area =  15
Perimeter =  16




example 2:


""" ***********************************************
programming Language :Python
Tool(IDE) used :Anaconda -> Spider
 date:06-06-2019
 created by:ANIL DURGAM
*****************************************************"""
# function definitions
# calculate area of a rectangle
#calulates perimeter of a rectangle
def area_perimeter(b, h):
    A = b * h
    P = 2 * (b+h)
    return A,P

# main program using defined functions
width = 5
height = 3
ar,pr=area_perimeter(width,height)
print("area=",ar)
print("perimeter=",pr)

output:
area= 15
perimeter= 16

iterating with index using python

""" Dispay resistor colour code values"""
colours = [ "black", "brown", "red", "orange", "yellow",
"green", "blue", "violet", "grey","white" ]
cv = list (enumerate (colours))
for c in cv:
    print(c[0], "\t", c[1])


output:
0        black
1        brown
2        red
3        orange
4        yellow
5        green
6        blue
7        violet
8        grey
9        white

iterating through the list

mynames = [ "Sam", "Pit", "Misch" ]
for n in mynames:
    print ("HELLO ", n)


output:

HELLO  Sam
HELLO  Pit
HELLO  Misch


Example 2:

from math import *
for i in range (0, 5):
    print(i,"\t", sqrt(i))


output:

for floating point numbers use linspace and logspace from numpy! in python

""" for floating point numbers use linspace and logspace from numpy!"""
import numpy as np
r5 = np.linspace(0,2,9)
print(r5)

output:
[0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]

The syntax for linspace is
linspace ( <startvalue>, <stopvalue>, <number_of_values> )

Calculate quare root of numbers 0 to 100 in python

""" Calculate quare root of numbers 0 to 100"""
from math import *
i = 0
while i<= 100:
    print (i, "\t\t" , sqrt(i))
    i = i + 1
print("READY!")

output:
0                0.0
1                1.0
2                1.4142135623730951
3                1.7320508075688772
4                2.0
5                2.23606797749979
6                2.449489742783178
7                2.6457513110645907
8                2.8284271247461903
9                3.0

10               3.1622776601683795

.................................
.....................................
95               9.746794344808963
96               9.797958971132712
97               9.848857801796104
98               9.899494936611665
99               9.9498743710662

100              10.0

mathematical functions in python

Example1:

from math import *
print(sqrt(2))


output:
1.4142135623730951


Example2:

from math import *
diameter = 5
perimeter = 2 * pi * diameter
print(perimeter)

output:
31.41592653589793

Example 3:

from math import *
Ueff = 230
amplitude = Ueff * sqrt(2)
print(amplitude)

output:
325.2691193458119


Example 4:

""" Calculate area of a circle"""
from math import *
d = float(input("Diameter: "))
A = pi * d**2 / 4
print( "Area = ",A)

output:
Diameter: 2.5
Area =  4.908738521234052

list in python

a = [2, " Jack", 45, "23 Wentworth Ave"]
print(a)

output:

[2, ' Jack', 45, '23 Wentworth Ave']

nested for loop in python

for n in range (2, 10):
    for x in range (2, n):
        if n % x == 0:
            print(n, "equals ", x, "*", n/x)
            break
    else:
        # loop fell through without finding a factor
        print(n, "is a prime number ")

output:

2 is a prime number
3 is a prime number
4 equals  2 * 2.0
5 is a prime number
6 equals  2 * 3.0
7 is a prime number
8 equals  2 * 4.0
9 equals  3 * 3.0

for and else loops in python

for n in [10 ,9 ,8 ,7 ,6 ,5 ,4 ,3 ,2 ,1]:
    print (n)
else:
    print(" blastoff")

output:
10
9
8
7
6
5
4
3
2
1
 blastoff

while loop in python

n = 0
while n < 10:
    print(n)
    n = n + 3



output:

0
3
6
9



while True:
    print("Hello")

output :
helloworld

prints continuously

if else and elif loops in python

# Import the modules
import sys
import random

ans = True

while ans:
    question = raw_input("Ask the magic 8 ball a question: (press enter to quit) ")
   
    answers = random.randint(1,8)
   
    if question == "":
        sys.exit()
   
    elif answers == 1:
        print("It is certain")
   
    elif answers == 2:
        print ("Outlook good")
   
    elif answers == 3:
        print ("You may rely on it")
   
    elif answers == 4:
        print ("Ask again later")
   
    elif answers == 5:
        print ("Concentrate and ask again")
   
    elif answers == 6:
        print( "Reply hazy, try again")
   
    elif answers == 7:
        print("My reply is no")
   
    elif answers == 8:
        print( "My sources say no")

keil software ..how to start coding using keil software and stm32f103C8T6

1.install the  keil software first and run the program.
2.in projects tab select the new keil project
refer below images

write your code in text editor then click on build and compiler after compltion then click 

on the load ..

after clicking on the load code will automatically uploads.

array test 4 in c language

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i, arr [8] = {1,2,3,4,5,6,7,8};
    for (i=7;i>=0;i--)
    {
         printf ("%d\t",--arr[--i]);
    }
    return 0;
}

out put:
6      4        2     0

array test 3 in c language

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i=0,sum=0,arr[6]={4,2,6,0,5,10};
     printf ("arr[0]=%d\n",arr[0]);
    while(arr[i])
    {
        sum=sum+arr[i] ;
            i++;
    }
    printf("sum=%d\n",sum) ;

    return 0;
}

array test2 in c language

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int arr[4]={2,4,8,1},i=4,j;

     printf ("arr[0]=%d\n",arr[0]);
     printf ("arr[1]=%d\n",arr[1]);
     printf ("arr[2]=%d\n",arr[2]);
    printf ("arr[3]=%d\n",arr[3]);
    printf ("arr[4]=%d\n",arr[4]);  //garbage values

    while(i)
    {
        j=arr[i]+i;
        i--;
    }
    printf ("j=%d\n",j);
   
    return 0;
}

array example1 in c programming language

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i,size=5,arr[size];
    for(i=0;i<size;i++)
        scanf("%d",&arr[i]) ;
    for(i=0;i<size;i++)
        printf("%d ",arr[i]);

  //  printf("Hello world!\n");
    return 0;
}

to find the given number is prime number or not ..c language

#include<stdio.h>
#include<math.h>

void main()
{
    int i,num,flag=1;
    printf("Enter a number \n");
    scanf("%d",&num) ;
    for(i=2;i<= sqrt(num);i++)
    {
        if (num%i==0)
        {
            printf("%d is not prime\n",num);
            flag=0;
            break;
        }
    }
    if (flag==1)
        printf ("%d is prime\n", num);
}

sum of the digits in given number using C and Python

//Program to print the sum of digits -of any number using for loop

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n,sum=0,rem;
    printf ("Enter the number ") ;
    scanf ("%d",&n) ;
    for( ;n>0;n/=10)
    {
        rem=n%10; /*taking last digit of number*/
        sum+=rem;
    }
    printf("Sum of digits = %d\n",sum) ;
    //printf("Hello world!\n");
    return 0;
}


program2:
#include<stdio.h>

int sum(int n);
void main()
{
    int num;
    printf ("Enter the number ") ;
    scanf("%d",&num) ;
    printf("Sum of digits of %d is %d\n", num, sum(num));
}
int sum (int n)
{
    int i, sum=0, rem;
    while(n>0)
    {
        rem=n%10;
        sum+=rem;
        n/=10;

    }
    return(sum);
/*rem takes the value of last digit*/
/*skips the last, digi t of number*/
}

output:

enter the number:12

sum of the digits of the 12 is 3

3

PYTHON code:

def main():

sum1=rem=0

n=int(input("enter the number"))

for i in range(n):

if n>0:

rem=n%10

sum1=sum1+rem

n=n//10

print(sum1)

if __name__ == '__main__':

main()

output:

enter the number:264

output:10

fibanocci series in c language

#include <stdio.h>
#include <stdlib.h>

int main()
{
    long x, y,z;
    int i,n;
    x=0;
    y=1;

    printf("Enter the number of terms\n") ;
    scanf ("%d",&n);
    //printf("%d",y);
    for(i=1;i<n;i++)
    {
        z=x+y;
        printf("%d",z);
        x=y;
        y=z;
        printf("\n") ;
    }
    return 0;
}

find the program to find the sum of the given series upto n terms

#include <stdio.h>
#include <stdlib.h>


void main()
{
    int i, n, sum=0,term=1;
    printf ("Enter number of terms ") ;
    scanf ("%d" ,&n) ;
    for(i=1;i<=n;i++)
    {
        sum+=term;
        term=term+i;
    }
    printf ("The sum of series upto %d terms is %d\n", n, sum) ;
}

multification of the two numbers with out using " * " operator

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a,b,i;
    int result=0;
    printf("enter two numbers to be multiplied\n");
    scanf("%d%d",&a,&b);
    for(i=1;i<=b;i++)
    {
        result = result+a;
         //printf("%d\n",result);
    }
    printf("%d * %d = %d \n",a,b,result);

    return 0;
}

own memcpy function...in c language

// A C implementation of memcpy()
#include<stdio.h>
#include<string.h>

void myMemCpy(void *dest, void *src, size_t n)
{
// Typecast src and dest addresses to (char *)
char *csrc = (char *)src;
char *cdest = (char *)dest;

// Copy contents of src[] to dest[]
for (int i=0; i<n; i++)
cdest[i] = csrc[i];
}

// Driver program
int main()
{
char csrc[] = "GeeksforGeeks";
char cdest[100];
myMemCpy(cdest, csrc, strlen(csrc)+1);
printf("Copied string is %s\n", cdest);

int isrc[] = {10, 20, 30, 40, 50};
int n = sizeof(isrc)/sizeof(isrc[0]);
int idest[n], i;
myMemCpy(idest, isrc, sizeof(isrc));
printf("\nCopied array is ");
for (i=0; i<n; i++)
printf("%d ", idest[i]);
printf("\n\n");
return 0;
}

memcpy with fixed length printing in c language

/* A C program to demonstrate working of memcpy */
#include <stdio.h>
#include <string.h>

int main ()
{
char str1[] = "Geeks";
char str2[] = "Quiz";

puts("str1 before memcpy ");
puts(str1);

/* Copies contents of str2 to sr1 */
memcpy (str1+5, str2, sizeof(str2));

puts("\nstr1 after memcpy ");
puts(str1);

return 0;
}

gt06 ldp without lbs information in c program

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef unsigned char u8;

static const unsigned int crctab16[] =
{
 0X0000, 0X1189, 0X2312, 0X329B, 0X4624, 0X57AD, 0X6536, 0X74BF,
 0X8C48, 0X9DC1, 0XAF5A, 0XBED3, 0XCA6C, 0XDBE5, 0XE97E, 0XF8F7,
 0X1081, 0X0108, 0X3393, 0X221A, 0X56A5, 0X472C, 0X75B7, 0X643E,
 0X9CC9, 0X8D40, 0XBFDB, 0XAE52, 0XDAED, 0XCB64, 0XF9FF, 0XE876,
 0X2102, 0X308B, 0X0210, 0X1399, 0X6726, 0X76AF, 0X4434, 0X55BD,
 0XAD4A, 0XBCC3, 0X8E58, 0X9FD1, 0XEB6E, 0XFAE7, 0XC87C, 0XD9F5,
 0X3183, 0X200A, 0X1291, 0X0318, 0X77A7, 0X662E, 0X54B5, 0X453C,
 0XBDCB, 0XAC42, 0X9ED9, 0X8F50, 0XFBEF, 0XEA66, 0XD8FD, 0XC974,
 0X4204, 0X538D, 0X6116, 0X709F, 0X0420, 0X15A9, 0X2732, 0X36BB,
 0XCE4C, 0XDFC5, 0XED5E, 0XFCD7, 0X8868, 0X99E1, 0XAB7A, 0XBAF3,
 0X5285, 0X430C, 0X7197, 0X601E, 0X14A1, 0X0528, 0X37B3, 0X263A,
 0XDECD, 0XCF44, 0XFDDF, 0XEC56, 0X98E9, 0X8960, 0XBBFB, 0XAA72,
 0X6306, 0X728F, 0X4014, 0X519D, 0X2522, 0X34AB, 0X0630, 0X17B9,
 0XEF4E, 0XFEC7, 0XCC5C, 0XDDD5, 0XA96A, 0XB8E3, 0X8A78, 0X9BF1,
 0X7387, 0X620E, 0X5095, 0X411C, 0X35A3, 0X242A, 0X16B1, 0X0738,
 0XFFCF, 0XEE46, 0XDCDD, 0XCD54, 0XB9EB, 0XA862, 0X9AF9, 0X8B70,
 0X8408, 0X9581, 0XA71A, 0XB693, 0XC22C, 0XD3A5, 0XE13E, 0XF0B7,
 0X0840, 0X19C9, 0X2B52, 0X3ADB, 0X4E64, 0X5FED, 0X6D76, 0X7CFF,
 0X9489, 0X8500, 0XB79B, 0XA612, 0XD2AD, 0XC324, 0XF1BF, 0XE036,
 0X18C1, 0X0948, 0X3BD3, 0X2A5A, 0X5EE5, 0X4F6C, 0X7DF7, 0X6C7E,
 0XA50A, 0XB483, 0X8618, 0X9791, 0XE32E, 0XF2A7, 0XC03C, 0XD1B5,
 0X2942, 0X38CB, 0X0A50, 0X1BD9, 0X6F66, 0X7EEF, 0X4C74, 0X5DFD,
 0XB58B, 0XA402, 0X9699, 0X8710, 0XF3AF, 0XE226, 0XD0BD, 0XC134,
 0X39C3, 0X284A, 0X1AD1, 0X0B58, 0X7FE7, 0X6E6E, 0X5CF5, 0X4D7C,
 0XC60C, 0XD785, 0XE51E, 0XF497, 0X8028, 0X91A1, 0XA33A, 0XB2B3,
 0X4A44, 0X5BCD, 0X6956, 0X78DF, 0X0C60, 0X1DE9, 0X2F72, 0X3EFB,
 0XD68D, 0XC704, 0XF59F, 0XE416, 0X90A9, 0X8120, 0XB3BB, 0XA232,
 0X5AC5, 0X4B4C, 0X79D7, 0X685E, 0X1CE1, 0X0D68, 0X3FF3, 0X2E7A,
 0XE70E, 0XF687, 0XC41C, 0XD595, 0XA12A, 0XB0A3, 0X8238, 0X93B1,
 0X6B46, 0X7ACF, 0X4854, 0X59DD, 0X2D62, 0X3CEB, 0X0E70, 0X1FF9,
 0XF78F, 0XE606, 0XD49D, 0XC514, 0XB1AB, 0XA022, 0X92B9, 0X8330,
 0X7BC7, 0X6A4E, 0X58D5, 0X495C, 0X3DE3, 0X2C6A, 0X1EF1, 0X0F78,
};
// calculate the 16-bit CRC of data with predetermined length.
unsigned int GetCrc16(const unsigned char* pData, int nLength)
{
    unsigned int fcs = 0xffff; // initialization
    while(nLength>0)
    {
        fcs = (fcs >> 8) ^ crctab16[(fcs ^ *pData) & 0xff];
        nLength--;
        pData++;
    }
 return ~fcs; // negated
 }

u8 gt06_protocol3[40];
u8 gt06_protocol4[50];
//unsigned char* information_content;

unsigned char gt06_ldp_packet_framing(unsigned short int get06_ldp_pack_len, unsigned char *information_content,unsigned short int counter)
{
    u8 get06_ldp_start_bytes[2]={0x78,0x78,0x00};
    //u8 protocol_num;
    //unsigned short int serial_num = 0x1F;
    unsigned short int gt06_ldp_len = 0;
    unsigned short int gt06_ldp_check_sum = 0;
    unsigned char stop_bytes[2]={0x0D,0x0A,0x00};
    unsigned char gt06_ldp_protocol[100]={0};
    unsigned char gt06_ldp_protocol2[40]={0};
    unsigned char gt06_ldp_protocol5[40]={0};
     unsigned char *gt06_ldp_protocol6;

   // printf("inside fn gt06 ldp packet\n");
    //memset(gt06_ldp_protocol,0,sizeof(gt06_ldp_protocol));

    strcat(gt06_ldp_protocol,get06_ldp_start_bytes);
   // printf("%x \n",gt06_ldp_protocol);
    gt06_ldp_protocol[2] = 5 + strlen((char *)information_content);// 38;// packect length
    gt06_ldp_protocol[3] = 0x12;// protocol number

    strncat(gt06_ldp_protocol,information_content,strlen((char *)information_content));// information content ex : imei

    gt06_ldp_len = strlen((char *)gt06_ldp_protocol);
    gt06_ldp_protocol[gt06_ldp_len++] =counter>>8;
    gt06_ldp_protocol[gt06_ldp_len++] = counter;
    gt06_ldp_check_sum = GetCrc16(gt06_ldp_protocol+2,gt06_ldp_len-2);
    //printf("cnt = %x \n",gt06_ldp_check_sum);
    gt06_ldp_protocol[gt06_ldp_len++] = gt06_ldp_check_sum>>8;
    gt06_ldp_protocol[gt06_ldp_len++] = gt06_ldp_check_sum;
    gt06_ldp_protocol[gt06_ldp_len++] = stop_bytes[0];
    gt06_ldp_protocol[gt06_ldp_len++] = stop_bytes[1];

    //memcpy(gt06_protocol3,gt06_ldp_protocol,gt06_ldp_len);

    for(char i=0;i<gt06_ldp_len;i++)
    {
      printf("%x ",gt06_ldp_protocol[i]);
     // sprintf(gt06_ldp_protocol2,"%x",gt06_ldp_protocol[i]);
      //strcat(gt06_ldp_protocol5,gt06_ldp_protocol2);
   }
   memcpy(gt06_protocol3,gt06_ldp_protocol,gt06_ldp_len);
   gt06_ldp_protocol6=gt06_protocol3;
    return gt06_ldp_protocol6;
}

void main()
{
    //unsigned char information_content[30]={0x1F,0x12,0x0B,0x08,0x1D,0x11,0x2E,0x10,0xcf,0x02,0x7A,0xC7,0xEB,0x0C,0x46,0x58,0x49,0x01,0x14,0x8F,0x01,0x95,0x31,0x28,0x7D,0x01,0x1F,0xB8,0x00};
    unsigned char information_content[100]={0};
    unsigned char packet_reply;
    unsigned short int get06_ldp_pack_len=0;
    unsigned short int counter=3;

u8 get06_ldp_proto_num[1]={0x12,0x00};
    u8 get06_ldp_datetime[6]={0x0B,0x08,0x1D,0x11,0x2E,0x10,0x00};
    u8 get06_ldp_sat[1]={0xcf,0x00};
    u8 get06_ldp_lat[4]={0x02,0x7A,0xC7,0xEB,0x00};
    u8 get06_ldp_long[4]={0x0C,0x46,0x58,0x49,0x00};
    u8 get06_ldp_speed[1]={0x01,0x00};
    u8 get06_ldp_course[2]={0x14,0x8F,0x00};
   // u8 get06_ldp_mcc[2]={0x01,0x95,0x00};//country code::india:404,405,406
  //  u8 get06_ldp_mnc[1]={0x31,0x00};//airtel 49
   // u8 get06_ldp_lac[2]={0x28,0x7D,0x00};
   // u8 get06_ldp_cell_id[3]={0x01,0x1F,0xB8,0x00};

    memset(information_content,0,sizeof(information_content));

memcpy(information_content,get06_ldp_datetime,6);
get06_ldp_pack_len += 6;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_sat,1);
        get06_ldp_pack_len += 1;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_lat,4);
        get06_ldp_pack_len += 4;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_long,4);
        get06_ldp_pack_len += 4;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_speed,1);
        get06_ldp_pack_len += 1;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_course,2);
        get06_ldp_pack_len += 2;
/*
memcpy(information_content+get06_ldp_pack_len,get06_ldp_mcc,2);
        get06_ldp_pack_len += 2;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_mnc,1);
        get06_ldp_pack_len += 1;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_lac,2);
        get06_ldp_pack_len += 2;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_cell_id,3);
        get06_ldp_pack_len += 3;
*/
packet_reply = gt06_ldp_packet_framing(0x12,information_content,counter);

// printf("\ngt06_protocol3=%x\n",gt06_protocol3);
  // printf("\packet_reply=%d\n",packet_reply);
   return 0;
}

gt06_ldp perfect working code in c language

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef unsigned char u8;

static const unsigned int crctab16[] =
{
 0X0000, 0X1189, 0X2312, 0X329B, 0X4624, 0X57AD, 0X6536, 0X74BF,
 0X8C48, 0X9DC1, 0XAF5A, 0XBED3, 0XCA6C, 0XDBE5, 0XE97E, 0XF8F7,
 0X1081, 0X0108, 0X3393, 0X221A, 0X56A5, 0X472C, 0X75B7, 0X643E,
 0X9CC9, 0X8D40, 0XBFDB, 0XAE52, 0XDAED, 0XCB64, 0XF9FF, 0XE876,
 0X2102, 0X308B, 0X0210, 0X1399, 0X6726, 0X76AF, 0X4434, 0X55BD,
 0XAD4A, 0XBCC3, 0X8E58, 0X9FD1, 0XEB6E, 0XFAE7, 0XC87C, 0XD9F5,
 0X3183, 0X200A, 0X1291, 0X0318, 0X77A7, 0X662E, 0X54B5, 0X453C,
 0XBDCB, 0XAC42, 0X9ED9, 0X8F50, 0XFBEF, 0XEA66, 0XD8FD, 0XC974,
 0X4204, 0X538D, 0X6116, 0X709F, 0X0420, 0X15A9, 0X2732, 0X36BB,
 0XCE4C, 0XDFC5, 0XED5E, 0XFCD7, 0X8868, 0X99E1, 0XAB7A, 0XBAF3,
 0X5285, 0X430C, 0X7197, 0X601E, 0X14A1, 0X0528, 0X37B3, 0X263A,
 0XDECD, 0XCF44, 0XFDDF, 0XEC56, 0X98E9, 0X8960, 0XBBFB, 0XAA72,
 0X6306, 0X728F, 0X4014, 0X519D, 0X2522, 0X34AB, 0X0630, 0X17B9,
 0XEF4E, 0XFEC7, 0XCC5C, 0XDDD5, 0XA96A, 0XB8E3, 0X8A78, 0X9BF1,
 0X7387, 0X620E, 0X5095, 0X411C, 0X35A3, 0X242A, 0X16B1, 0X0738,
 0XFFCF, 0XEE46, 0XDCDD, 0XCD54, 0XB9EB, 0XA862, 0X9AF9, 0X8B70,
 0X8408, 0X9581, 0XA71A, 0XB693, 0XC22C, 0XD3A5, 0XE13E, 0XF0B7,
 0X0840, 0X19C9, 0X2B52, 0X3ADB, 0X4E64, 0X5FED, 0X6D76, 0X7CFF,
 0X9489, 0X8500, 0XB79B, 0XA612, 0XD2AD, 0XC324, 0XF1BF, 0XE036,
 0X18C1, 0X0948, 0X3BD3, 0X2A5A, 0X5EE5, 0X4F6C, 0X7DF7, 0X6C7E,
 0XA50A, 0XB483, 0X8618, 0X9791, 0XE32E, 0XF2A7, 0XC03C, 0XD1B5,
 0X2942, 0X38CB, 0X0A50, 0X1BD9, 0X6F66, 0X7EEF, 0X4C74, 0X5DFD,
 0XB58B, 0XA402, 0X9699, 0X8710, 0XF3AF, 0XE226, 0XD0BD, 0XC134,
 0X39C3, 0X284A, 0X1AD1, 0X0B58, 0X7FE7, 0X6E6E, 0X5CF5, 0X4D7C,
 0XC60C, 0XD785, 0XE51E, 0XF497, 0X8028, 0X91A1, 0XA33A, 0XB2B3,
 0X4A44, 0X5BCD, 0X6956, 0X78DF, 0X0C60, 0X1DE9, 0X2F72, 0X3EFB,
 0XD68D, 0XC704, 0XF59F, 0XE416, 0X90A9, 0X8120, 0XB3BB, 0XA232,
 0X5AC5, 0X4B4C, 0X79D7, 0X685E, 0X1CE1, 0X0D68, 0X3FF3, 0X2E7A,
 0XE70E, 0XF687, 0XC41C, 0XD595, 0XA12A, 0XB0A3, 0X8238, 0X93B1,
 0X6B46, 0X7ACF, 0X4854, 0X59DD, 0X2D62, 0X3CEB, 0X0E70, 0X1FF9,
 0XF78F, 0XE606, 0XD49D, 0XC514, 0XB1AB, 0XA022, 0X92B9, 0X8330,
 0X7BC7, 0X6A4E, 0X58D5, 0X495C, 0X3DE3, 0X2C6A, 0X1EF1, 0X0F78,
};
// calculate the 16-bit CRC of data with predetermined length.
unsigned int GetCrc16(const unsigned char* pData, int nLength)
{
    unsigned int fcs = 0xffff; // initialization
    while(nLength>0)
    {
        fcs = (fcs >> 8) ^ crctab16[(fcs ^ *pData) & 0xff];
        nLength--;
        pData++;
    }
 return ~fcs; // negated
 }

u8 gt06_protocol3[40];
u8 gt06_protocol4[50];
//unsigned char* information_content;

unsigned char gt06_ldp_packet_framing(unsigned short int get06_ldp_pack_len, unsigned char *information_content,unsigned short int counter)
{
    u8 get06_ldp_start_bytes[2]={0x78,0x78,0x00};
    //u8 protocol_num;
    //unsigned short int serial_num = 0x1F;
    unsigned short int gt06_ldp_len = 0;
    unsigned short int gt06_ldp_check_sum = 0;
    unsigned char stop_bytes[2]={0x0D,0x0A,0x00};
    unsigned char gt06_ldp_protocol[100]={0};
    unsigned char gt06_ldp_protocol2[40]={0};
    unsigned char gt06_ldp_protocol5[40]={0};
     unsigned char *gt06_ldp_protocol6;

   // printf("inside fn gt06 ldp packet\n");
    //memset(gt06_ldp_protocol,0,sizeof(gt06_ldp_protocol));

    strcat(gt06_ldp_protocol,get06_ldp_start_bytes);
   // printf("%x \n",gt06_ldp_protocol);
    gt06_ldp_protocol[2] = 5 + strlen((char *)information_content);// 38;// packect length
gt06_ldp_protocol[3] = 0x12;// protocol number

    strncat(gt06_ldp_protocol,information_content,strlen((char *)information_content));// information content ex : imei

    gt06_ldp_len = strlen((char *)gt06_ldp_protocol);
    gt06_ldp_protocol[gt06_ldp_len++] =counter>>8;
    gt06_ldp_protocol[gt06_ldp_len++] = counter;
    gt06_ldp_check_sum = GetCrc16(gt06_ldp_protocol+2,gt06_ldp_len-2);
    //printf("cnt = %x \n",gt06_ldp_check_sum);
    gt06_ldp_protocol[gt06_ldp_len++] = gt06_ldp_check_sum>>8;
    gt06_ldp_protocol[gt06_ldp_len++] = gt06_ldp_check_sum;
    gt06_ldp_protocol[gt06_ldp_len++] = stop_bytes[0];
    gt06_ldp_protocol[gt06_ldp_len++] = stop_bytes[1];

    //memcpy(gt06_protocol3,gt06_ldp_protocol,gt06_ldp_len);

    for(char i=0;i<gt06_ldp_len;i++)
    {
      printf("%x ",gt06_ldp_protocol[i]);
     // sprintf(gt06_ldp_protocol2,"%x",gt06_ldp_protocol[i]);
      //strcat(gt06_ldp_protocol5,gt06_ldp_protocol2);
   }
   memcpy(gt06_protocol3,gt06_ldp_protocol,gt06_ldp_len);
   gt06_ldp_protocol6=gt06_protocol3;
    return gt06_ldp_protocol6;
}

void main()
{
    //unsigned char information_content[30]={0x1F,0x12,0x0B,0x08,0x1D,0x11,0x2E,0x10,0xcf,0x02,0x7A,0xC7,0xEB,0x0C,0x46,0x58,0x49,0x01,0x14,0x8F,0x01,0x95,0x31,0x28,0x7D,0x01,0x1F,0xB8,0x00};
      unsigned char information_content[100]={0};
      unsigned char packet_reply;

    unsigned short int get06_ldp_pack_len=0;
    unsigned short int counter=3;

u8 get06_ldp_proto_num[1]={0x12,0x00};
    u8 get06_ldp_datetime[6]={0x0B,0x08,0x1D,0x11,0x2E,0x10,0x00};
    u8 get06_ldp_sat[1]={0xcf,0x00};
    u8 get06_ldp_lat[4]={0x02,0x7A,0xC7,0xEB,0x00};
    u8 get06_ldp_long[4]={0x0C,0x46,0x58,0x49,0x00};
    u8 get06_ldp_speed[1]={0x01,0x00};
    u8 get06_ldp_course[2]={0x14,0x8F,0x00};
    u8 get06_ldp_mcc[2]={0x01,0x95,0x00};//country code::india:404,405,406
    u8 get06_ldp_mnc[1]={0x31,0x00};//airtel 49
    u8 get06_ldp_lac[2]={0x28,0x7D,0x00};
    u8 get06_ldp_cell_id[3]={0x01,0x1F,0xB8,0x00};

    memset(information_content,0,sizeof(information_content));

memcpy(information_content,get06_ldp_datetime,6);
get06_ldp_pack_len += 6;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_sat,1);
        get06_ldp_pack_len += 1;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_lat,4);
        get06_ldp_pack_len += 4;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_long,4);
        get06_ldp_pack_len += 4;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_speed,1);
        get06_ldp_pack_len += 1;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_course,2);
        get06_ldp_pack_len += 2;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_mcc,2);
        get06_ldp_pack_len += 2;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_mnc,1);
        get06_ldp_pack_len += 1;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_lac,2);
        get06_ldp_pack_len += 2;

memcpy(information_content+get06_ldp_pack_len,get06_ldp_cell_id,3);
        get06_ldp_pack_len += 3;

packet_reply = gt06_ldp_packet_framing(0x12,information_content,counter);

// printf("\ngt06_protocol3=%x\n",gt06_protocol3);
  // printf("\packet_reply=%d\n",packet_reply);
   return 0;
}

gt06 ldp data test2 in c language

#include<stdio.h>
typedef unsigned char u8;
unsigned char gt06_protocol5[40];

static const unsigned int crctab16[] =
{
 0X0000, 0X1189, 0X2312, 0X329B, 0X4624, 0X57AD, 0X6536, 0X74BF,
 0X8C48, 0X9DC1, 0XAF5A, 0XBED3, 0XCA6C, 0XDBE5, 0XE97E, 0XF8F7,
 0X1081, 0X0108, 0X3393, 0X221A, 0X56A5, 0X472C, 0X75B7, 0X643E,
 0X9CC9, 0X8D40, 0XBFDB, 0XAE52, 0XDAED, 0XCB64, 0XF9FF, 0XE876,
 0X2102, 0X308B, 0X0210, 0X1399, 0X6726, 0X76AF, 0X4434, 0X55BD,
 0XAD4A, 0XBCC3, 0X8E58, 0X9FD1, 0XEB6E, 0XFAE7, 0XC87C, 0XD9F5,
 0X3183, 0X200A, 0X1291, 0X0318, 0X77A7, 0X662E, 0X54B5, 0X453C,
 0XBDCB, 0XAC42, 0X9ED9, 0X8F50, 0XFBEF, 0XEA66, 0XD8FD, 0XC974,
 0X4204, 0X538D, 0X6116, 0X709F, 0X0420, 0X15A9, 0X2732, 0X36BB,
 0XCE4C, 0XDFC5, 0XED5E, 0XFCD7, 0X8868, 0X99E1, 0XAB7A, 0XBAF3,
 0X5285, 0X430C, 0X7197, 0X601E, 0X14A1, 0X0528, 0X37B3, 0X263A,
 0XDECD, 0XCF44, 0XFDDF, 0XEC56, 0X98E9, 0X8960, 0XBBFB, 0XAA72,
 0X6306, 0X728F, 0X4014, 0X519D, 0X2522, 0X34AB, 0X0630, 0X17B9,
 0XEF4E, 0XFEC7, 0XCC5C, 0XDDD5, 0XA96A, 0XB8E3, 0X8A78, 0X9BF1,
 0X7387, 0X620E, 0X5095, 0X411C, 0X35A3, 0X242A, 0X16B1, 0X0738,
 0XFFCF, 0XEE46, 0XDCDD, 0XCD54, 0XB9EB, 0XA862, 0X9AF9, 0X8B70,
 0X8408, 0X9581, 0XA71A, 0XB693, 0XC22C, 0XD3A5, 0XE13E, 0XF0B7,
 0X0840, 0X19C9, 0X2B52, 0X3ADB, 0X4E64, 0X5FED, 0X6D76, 0X7CFF,
 0X9489, 0X8500, 0XB79B, 0XA612, 0XD2AD, 0XC324, 0XF1BF, 0XE036,
 0X18C1, 0X0948, 0X3BD3, 0X2A5A, 0X5EE5, 0X4F6C, 0X7DF7, 0X6C7E,
 0XA50A, 0XB483, 0X8618, 0X9791, 0XE32E, 0XF2A7, 0XC03C, 0XD1B5,
 0X2942, 0X38CB, 0X0A50, 0X1BD9, 0X6F66, 0X7EEF, 0X4C74, 0X5DFD,
 0XB58B, 0XA402, 0X9699, 0X8710, 0XF3AF, 0XE226, 0XD0BD, 0XC134,
 0X39C3, 0X284A, 0X1AD1, 0X0B58, 0X7FE7, 0X6E6E, 0X5CF5, 0X4D7C,
 0XC60C, 0XD785, 0XE51E, 0XF497, 0X8028, 0X91A1, 0XA33A, 0XB2B3,
 0X4A44, 0X5BCD, 0X6956, 0X78DF, 0X0C60, 0X1DE9, 0X2F72, 0X3EFB,
 0XD68D, 0XC704, 0XF59F, 0XE416, 0X90A9, 0X8120, 0XB3BB, 0XA232,
 0X5AC5, 0X4B4C, 0X79D7, 0X685E, 0X1CE1, 0X0D68, 0X3FF3, 0X2E7A,
 0XE70E, 0XF687, 0XC41C, 0XD595, 0XA12A, 0XB0A3, 0X8238, 0X93B1,
 0X6B46, 0X7ACF, 0X4854, 0X59DD, 0X2D62, 0X3CEB, 0X0E70, 0X1FF9,
 0XF78F, 0XE606, 0XD49D, 0XC514, 0XB1AB, 0XA022, 0X92B9, 0X8330,
 0X7BC7, 0X6A4E, 0X58D5, 0X495C, 0X3DE3, 0X2C6A, 0X1EF1, 0X0F78,
};
// calculate the 16-bit CRC of data with predetermined length.
unsigned int GetCrc16(const unsigned char* pData, int nLength)
{
    unsigned int fcs = 0xffff; // initialization
    while(nLength>0)
    {
        fcs = (fcs >> 8) ^ crctab16[(fcs ^ *pData) & 0xff];
        nLength--;
        pData++;
    }
 return ~fcs; // negated
 }


unsigned char packet_framing(unsigned char protocol_num,unsigned char *infomation_content,unsigned short int counter)
{
    u8 start_bytes[2]={0x78,0x78,0x00};
    u8 stop_bytes[2]={0x0d,0x0a,0x00};
    u8 u8_protocol_len = 0;
    u8 gt06_protocol[100]={0};
    u8 gt06_protocol2[40];

    unsigned short int gt06_len = 0;
    unsigned short int u8_check_cum = 0;


    memset(gt06_protocol,0x00,sizeof(gt06_protocol));

    strcpy(gt06_protocol,start_bytes);
    gt06_protocol[2] = protocol_num;// protocol number
    //gt06_protocol[3] = 5 + strlen((char *)infomation_content);// packect length


    strncat(gt06_protocol,infomation_content,strlen((char *)infomation_content));

     gt06_len = strlen((char *)gt06_protocol);

    gt06_protocol[gt06_len++] = counter>>8;
    gt06_protocol[gt06_len++] = counter;

    u8_check_cum = GetCrc16(gt06_protocol+2,gt06_len-2);
   // printf("cnt = %x ",u8_check_cum);

    gt06_protocol[gt06_len++] = u8_check_cum>>8;

    gt06_protocol[gt06_len++] = u8_check_cum;

    gt06_protocol[gt06_len++] = stop_bytes[0];

    gt06_protocol[gt06_len++] = stop_bytes[1];


   // memcpy(gt06_protocol3,gt06_protocol,gt06_len);

    for(char i=0;i<gt06_len;i++)
    {
        printf("%x ",gt06_protocol[i]);
        sprintf(gt06_protocol2,"%x",gt06_protocol[i]);
        strcat(gt06_protocol5,gt06_protocol2);
    }

    //memcpy(gt06_protocol3,gt06_protocol,gt06_len);
    //gt06_protocol4 = gt06_protocol3;
    //printf("\nin fn=%s",gt06_protocol3);
    return gt06_protocol5;
}

int main()
{
    unsigned short int check_sum = 0;
     char *packet_reply;

    unsigned short int serial_num = 0x1F;
  //  78 78 1F 12 08 69 86 70 33 30 80 42 00 01 8C DD 0D 0A
    unsigned char gt06_lbs_info[40]={0x12,0x0B,0x08,0x1D,0x11,0x2E,0x10,0xcf,0x02,0x7A,0xC7,0xEB,0x0C,0x46,0x58,0x49,0x01,0x14,0x8F,0x01,0x95,0x31,0x28,0x7D,0x01,0x1F,0xB8,0x00};

   // check_sum = GetCrc16(test,12);
    packet_reply = packet_framing(serial_num,gt06_lbs_info,serial_num);

   // printf("\n main=%s\n",packet_reply);
     printf("\nin main=%s",gt06_protocol5);

    return 0;
}

output:

gt06 location data packet sending test

#include<stdio.h>
typedef unsigned char u8;
unsigned char gt06_protocol3[40];

static const unsigned int crctab16[] =
{
 0X0000, 0X1189, 0X2312, 0X329B, 0X4624, 0X57AD, 0X6536, 0X74BF,
 0X8C48, 0X9DC1, 0XAF5A, 0XBED3, 0XCA6C, 0XDBE5, 0XE97E, 0XF8F7,
 0X1081, 0X0108, 0X3393, 0X221A, 0X56A5, 0X472C, 0X75B7, 0X643E,
 0X9CC9, 0X8D40, 0XBFDB, 0XAE52, 0XDAED, 0XCB64, 0XF9FF, 0XE876,
 0X2102, 0X308B, 0X0210, 0X1399, 0X6726, 0X76AF, 0X4434, 0X55BD,
 0XAD4A, 0XBCC3, 0X8E58, 0X9FD1, 0XEB6E, 0XFAE7, 0XC87C, 0XD9F5,
 0X3183, 0X200A, 0X1291, 0X0318, 0X77A7, 0X662E, 0X54B5, 0X453C,
 0XBDCB, 0XAC42, 0X9ED9, 0X8F50, 0XFBEF, 0XEA66, 0XD8FD, 0XC974,
 0X4204, 0X538D, 0X6116, 0X709F, 0X0420, 0X15A9, 0X2732, 0X36BB,
 0XCE4C, 0XDFC5, 0XED5E, 0XFCD7, 0X8868, 0X99E1, 0XAB7A, 0XBAF3,
 0X5285, 0X430C, 0X7197, 0X601E, 0X14A1, 0X0528, 0X37B3, 0X263A,
 0XDECD, 0XCF44, 0XFDDF, 0XEC56, 0X98E9, 0X8960, 0XBBFB, 0XAA72,
 0X6306, 0X728F, 0X4014, 0X519D, 0X2522, 0X34AB, 0X0630, 0X17B9,
 0XEF4E, 0XFEC7, 0XCC5C, 0XDDD5, 0XA96A, 0XB8E3, 0X8A78, 0X9BF1,
 0X7387, 0X620E, 0X5095, 0X411C, 0X35A3, 0X242A, 0X16B1, 0X0738,
 0XFFCF, 0XEE46, 0XDCDD, 0XCD54, 0XB9EB, 0XA862, 0X9AF9, 0X8B70,
 0X8408, 0X9581, 0XA71A, 0XB693, 0XC22C, 0XD3A5, 0XE13E, 0XF0B7,
 0X0840, 0X19C9, 0X2B52, 0X3ADB, 0X4E64, 0X5FED, 0X6D76, 0X7CFF,
 0X9489, 0X8500, 0XB79B, 0XA612, 0XD2AD, 0XC324, 0XF1BF, 0XE036,
 0X18C1, 0X0948, 0X3BD3, 0X2A5A, 0X5EE5, 0X4F6C, 0X7DF7, 0X6C7E,
 0XA50A, 0XB483, 0X8618, 0X9791, 0XE32E, 0XF2A7, 0XC03C, 0XD1B5,
 0X2942, 0X38CB, 0X0A50, 0X1BD9, 0X6F66, 0X7EEF, 0X4C74, 0X5DFD,
 0XB58B, 0XA402, 0X9699, 0X8710, 0XF3AF, 0XE226, 0XD0BD, 0XC134,
 0X39C3, 0X284A, 0X1AD1, 0X0B58, 0X7FE7, 0X6E6E, 0X5CF5, 0X4D7C,
 0XC60C, 0XD785, 0XE51E, 0XF497, 0X8028, 0X91A1, 0XA33A, 0XB2B3,
 0X4A44, 0X5BCD, 0X6956, 0X78DF, 0X0C60, 0X1DE9, 0X2F72, 0X3EFB,
 0XD68D, 0XC704, 0XF59F, 0XE416, 0X90A9, 0X8120, 0XB3BB, 0XA232,
 0X5AC5, 0X4B4C, 0X79D7, 0X685E, 0X1CE1, 0X0D68, 0X3FF3, 0X2E7A,
 0XE70E, 0XF687, 0XC41C, 0XD595, 0XA12A, 0XB0A3, 0X8238, 0X93B1,
 0X6B46, 0X7ACF, 0X4854, 0X59DD, 0X2D62, 0X3CEB, 0X0E70, 0X1FF9,
 0XF78F, 0XE606, 0XD49D, 0XC514, 0XB1AB, 0XA022, 0X92B9, 0X8330,
 0X7BC7, 0X6A4E, 0X58D5, 0X495C, 0X3DE3, 0X2C6A, 0X1EF1, 0X0F78,
};
// calculate the 16-bit CRC of data with predetermined length.
unsigned int GetCrc16(const unsigned char* pData, int nLength)
{
    unsigned int fcs = 0xffff; // initialization
    while(nLength>0)
    {
        fcs = (fcs >> 8) ^ crctab16[(fcs ^ *pData) & 0xff];
        nLength--;
        pData++;
    }
 return ~fcs; // negated
 }


unsigned char packet_framing(unsigned char protocol_num,unsigned char *infomation_content,unsigned short int counter)
{
    u8 start_bytes[2]={0x78,0x78,0x00};
    u8 stop_bytes[2]={0x0d,0x0a,0x00};
    u8 u8_protocol_len = 0;
    u8 gt06_protocol[100]={0};
    u8 gt06_protocol2[40];

    u8 *gt06_protocol4;
    unsigned short int gt06_len = 0;
    unsigned short int u8_check_cum = 0;

    gt06_protocol4 = malloc(sizeof (char) * 30);

    memset(gt06_protocol,0x00,sizeof(gt06_protocol));
    strcpy(gt06_protocol,start_bytes);
    gt06_protocol[2] = 5 + strlen((char *)infomation_content);// packect length
    gt06_protocol[3] = protocol_num;// protocol number

    strncat(gt06_protocol,infomation_content,strlen((char *)infomation_content));// information content ex : imei

     gt06_len = strlen((char *)gt06_protocol);

    gt06_protocol[gt06_len++] = counter>>8;
    gt06_protocol[gt06_len++] = counter;

    u8_check_cum = GetCrc16(gt06_protocol+2,gt06_len-2);
   // printf("cnt = %x ",u8_check_cum);

    gt06_protocol[gt06_len++] = u8_check_cum>>8;
    // printf("cnt = %x ",u8_check_cum);
    gt06_protocol[gt06_len++] = u8_check_cum;
    //printf("cnt = %x ",u8_check_cum);
    gt06_protocol[gt06_len++] = stop_bytes[0];
    //printf("stop byte = %x ",gt06_protocol);
    gt06_protocol[gt06_len++] = stop_bytes[1];
     //printf("stop byte = %x ",gt06_protocol);

   // memcpy(gt06_protocol3,gt06_protocol,gt06_len);

    for(char i=0;i<gt06_len;i++)
    {
        printf("%x ",gt06_protocol[i]);
        sprintf(gt06_protocol2,"%x",gt06_protocol[i]);
        strcat(gt06_protocol3,gt06_protocol2);
    }

    //memcpy(gt06_protocol3,gt06_protocol,gt06_len);
    //gt06_protocol4 = gt06_protocol3;
    //printf("\nin fn=%s",gt06_protocol3);
    return gt06_protocol3;
}

int main()
{
    unsigned short int check_sum = 0;
     char *packet_reply;

    unsigned short int serial_num = 0x1F;
  //  78 78 1F 12 08 69 86 70 33 30 80 42 00 01 8C DD 0D 0A
    unsigned char gt06_lbs_info[40]={0x12,0x0B,0x08,0x1D,0x11,0x2E,0x10,0xcf,0x02,0x7A,0xC7,0xEB,0x0C,0x46,0x58,0x49,0x01,0x14,0x8F,0x01,0x95,0x31,0x28,0x7D,0x01,0x1F,0xB8,0x00};

   // check_sum = GetCrc16(test,12);
    packet_reply = packet_framing(serial_num,gt06_lbs_info,serial_num);

   // printf("\n main=%s\n",packet_reply);
     printf("\nin main=%s",gt06_protocol3);

    return 0;
}

output:

crc check sum test in c language

#include<stdio.h>

static const unsigned int crctab16[] =
{
 0X0000, 0X1189, 0X2312, 0X329B, 0X4624, 0X57AD, 0X6536, 0X74BF,
 0X8C48, 0X9DC1, 0XAF5A, 0XBED3, 0XCA6C, 0XDBE5, 0XE97E, 0XF8F7,
 0X1081, 0X0108, 0X3393, 0X221A, 0X56A5, 0X472C, 0X75B7, 0X643E,
 0X9CC9, 0X8D40, 0XBFDB, 0XAE52, 0XDAED, 0XCB64, 0XF9FF, 0XE876,
 0X2102, 0X308B, 0X0210, 0X1399, 0X6726, 0X76AF, 0X4434, 0X55BD,
 0XAD4A, 0XBCC3, 0X8E58, 0X9FD1, 0XEB6E, 0XFAE7, 0XC87C, 0XD9F5,
 0X3183, 0X200A, 0X1291, 0X0318, 0X77A7, 0X662E, 0X54B5, 0X453C,
 0XBDCB, 0XAC42, 0X9ED9, 0X8F50, 0XFBEF, 0XEA66, 0XD8FD, 0XC974,
 0X4204, 0X538D, 0X6116, 0X709F, 0X0420, 0X15A9, 0X2732, 0X36BB,
 0XCE4C, 0XDFC5, 0XED5E, 0XFCD7, 0X8868, 0X99E1, 0XAB7A, 0XBAF3,
 0X5285, 0X430C, 0X7197, 0X601E, 0X14A1, 0X0528, 0X37B3, 0X263A,
 0XDECD, 0XCF44, 0XFDDF, 0XEC56, 0X98E9, 0X8960, 0XBBFB, 0XAA72,
 0X6306, 0X728F, 0X4014, 0X519D, 0X2522, 0X34AB, 0X0630, 0X17B9,
 0XEF4E, 0XFEC7, 0XCC5C, 0XDDD5, 0XA96A, 0XB8E3, 0X8A78, 0X9BF1,
 0X7387, 0X620E, 0X5095, 0X411C, 0X35A3, 0X242A, 0X16B1, 0X0738,
 0XFFCF, 0XEE46, 0XDCDD, 0XCD54, 0XB9EB, 0XA862, 0X9AF9, 0X8B70,
 0X8408, 0X9581, 0XA71A, 0XB693, 0XC22C, 0XD3A5, 0XE13E, 0XF0B7,
 0X0840, 0X19C9, 0X2B52, 0X3ADB, 0X4E64, 0X5FED, 0X6D76, 0X7CFF,
 0X9489, 0X8500, 0XB79B, 0XA612, 0XD2AD, 0XC324, 0XF1BF, 0XE036,
 0X18C1, 0X0948, 0X3BD3, 0X2A5A, 0X5EE5, 0X4F6C, 0X7DF7, 0X6C7E,
 0XA50A, 0XB483, 0X8618, 0X9791, 0XE32E, 0XF2A7, 0XC03C, 0XD1B5,
 0X2942, 0X38CB, 0X0A50, 0X1BD9, 0X6F66, 0X7EEF, 0X4C74, 0X5DFD,
 0XB58B, 0XA402, 0X9699, 0X8710, 0XF3AF, 0XE226, 0XD0BD, 0XC134,
 0X39C3, 0X284A, 0X1AD1, 0X0B58, 0X7FE7, 0X6E6E, 0X5CF5, 0X4D7C,
 0XC60C, 0XD785, 0XE51E, 0XF497, 0X8028, 0X91A1, 0XA33A, 0XB2B3,
 0X4A44, 0X5BCD, 0X6956, 0X78DF, 0X0C60, 0X1DE9, 0X2F72, 0X3EFB,
 0XD68D, 0XC704, 0XF59F, 0XE416, 0X90A9, 0X8120, 0XB3BB, 0XA232,
 0X5AC5, 0X4B4C, 0X79D7, 0X685E, 0X1CE1, 0X0D68, 0X3FF3, 0X2E7A,
 0XE70E, 0XF687, 0XC41C, 0XD595, 0XA12A, 0XB0A3, 0X8238, 0X93B1,
 0X6B46, 0X7ACF, 0X4854, 0X59DD, 0X2D62, 0X3CEB, 0X0E70, 0X1FF9,
 0XF78F, 0XE606, 0XD49D, 0XC514, 0XB1AB, 0XA022, 0X92B9, 0X8330,
 0X7BC7, 0X6A4E, 0X58D5, 0X495C, 0X3DE3, 0X2C6A, 0X1EF1, 0X0F78,
};
// calculate the 16-bit CRC of data with predetermined length.
unsigned int GetCrc16(const unsigned char* pData, int nLength)
{
    unsigned int fcs = 0xffff; // initialization
    while(nLength>0)
    {
        fcs = (fcs >> 8) ^ crctab16[(fcs ^ *pData) & 0xff];
        nLength--;
        pData++;
    }
 return ~fcs; // negated
 }

 //78 78 0D 01 01 23 45 67 89 01 23 45 00 01 8C DD 0D 0A
char* packet_framing(unsigned char protocol_num,unsigned char *infomation_content,unsigned short int counter)
{
    unsigned char start_bytes[2]={0x78,0x78,0x00};
    unsigned char stop_bytes[2]={0x0d,0x0a,0x00};
    unsigned char u8_protocol_len = 0;
    unsigned char gt06_protocol[100]={0};
    unsigned char gt06_protocol2[18];
    unsigned char gt06_protocol3[18];
    unsigned char *gt06_protocol4;
    unsigned short int u8_len = 0;
    unsigned short int u8_check_cum = 0;

    gt06_protocol4 = malloc(sizeof (char) * 30);

    memset(gt06_protocol,0x00,sizeof(gt06_protocol));
    strcpy(gt06_protocol,start_bytes);
    gt06_protocol[2] = 5 + strlen((char *)infomation_content);// packect length
    gt06_protocol[3] = protocol_num;// protocol number

    strncat(gt06_protocol,infomation_content,strlen((char *)infomation_content));// information content ex : imei

     u8_len = strlen((char *)gt06_protocol);

    gt06_protocol[u8_len++] = counter>>8;
    gt06_protocol[u8_len++] = counter;

    u8_check_cum = GetCrc16(gt06_protocol+2,u8_len-2);
   // printf("cnt = %x ",u8_check_cum);

    gt06_protocol[u8_len++] = u8_check_cum>>8;
    // printf("cnt = %x ",u8_check_cum);
    gt06_protocol[u8_len++] = u8_check_cum;
    //printf("cnt = %x ",u8_check_cum);
    gt06_protocol[u8_len++] = stop_bytes[0];
    //printf("stop byte = %x ",gt06_protocol);
    gt06_protocol[u8_len++] = stop_bytes[1];
     //printf("stop byte = %x ",gt06_protocol);

    for(char i=0;i<u8_len;i++)
    {
        printf("%x ",gt06_protocol[i]);
        sprintf(gt06_protocol2,"%x ",gt06_protocol[i]);
        strcat(gt06_protocol3,gt06_protocol2);
    }
    gt06_protocol4 = gt06_protocol3;
   //printf("in fun=%x ",gt06_protocol4);
    return gt06_protocol4;
}

int main()
{
    unsigned short int check_sum = 0;
     char *packet_reply;

    unsigned short int serial_num = 0x01;
  //  78 78 1F 12 08 69 86 70 33 30 80 42 00 01 8C DD 0D 0A
    unsigned char imei_num[10]={0x08,0x69,0x86,0x70,0x33,0x30,0x80,0x42,0x00};
   // check_sum = GetCrc16(test,12);
    packet_reply = packet_framing(serial_num,imei_num,serial_num);

    printf("\n main=%s\n",packet_reply);

    return 0;
}

elements access using index in python

mylist = ["black", "red", "orange"]
print( mylist[0])
print( mylist[1])
print( mylist[2])

output:

len(length) function in python

The number of elements can be determined with the len (length) function:

a=[0,1,2]

print(len(a))

output:

example 2:


a=[0,1,2,3,4]

print(len(a))

output:

list arrays in python

nameslist = ["Sam", "Lisy", "Pit"]
numberslist = [1, 2, 3.14]
mixedlist = ["ham", 'eggs', 3.14, 5]

and append function in python

a=[0,1,2]
print(a)
a.append(5)
a.append( "Zapzoo")
print(a)

output:

empty array is created like this
x=[]

array with zero initialisation values

y= [0]*10 # array of integers with 10 zero elements
z = [0.0]*20 # array of floats with 20 zero elements

Tuple in python

Tuple is similar to list but
list is indicate in '[]'square brackets and tuples indicates in "()" parenthesis(optional)
another difference is list in mutable
tuple is immutable

empty tuple
 t=()


example 1:
list=[10,20,30,40]
tuple=(10,20,30,40)
print(list)
print(tuple)


output:
[10, 20, 30, 40]
(10, 20, 30, 40)

example 2:

list=[10,20,30,40]
tuple=(10,20,30,40)
tuple2=10,20,30,40

print(list)
print(tuple)
print(type(tuple2))
print(tuple2)

output:
[10, 20, 30, 40]
(10, 20, 30, 40)
<class 'tuple'>
(10, 20, 30, 40)

example 3:

(x,y) = (5, 3)
coordinates = (x,y)
print(coordinates)

dimensions = (8, 5.0, 3.14)
print(dimensions)
print(dimensions[0])
print(dimensions[1])
print(dimensions[2])

output::

(5, 3)
(8, 5.0, 3.14)
8
5.0
3.14

if elif and else loop in python

s = input ("Input your name: ")
if s == "Tom":
    print("Hello ", s)
elif s == "Carmen":
    print("I'm so glad to see you ", s)
elif s == "Sonia":
    print("I didn't expect you ",s)
else:
    print("Hello unknown")


output::

if and else loops in python

s = input ("Input your name: ")
if s == "Tom":
    print("Hello ", s)
else:
    print("Hello unknown")

output:

note:

after if and else statements ":" is mandatory ,other wise compiler gives an error

if loop in python

s = input ("Input your name:")
if s == "Tom":
    print("HELLO ", s)

output::

note:after "if " statement ":" is mandatory other wise ,compiler through the error

while test in python

i = 0
while i<= 5:
    print("*");
    i = i + 1;


output:

while loop in python

i = 0
while i<= 20:
    print(i, "\t" ,i*i)
    i = i + 1
print("READY!\n")

Taking input from user using python

Example 1:

s = input("What is your name?\n");
print("HELLO ", s);

output:
What is your name?
anil
HELLO  anil



Example 2:

x = int(input("Input an integer: "))
y = float(input("Input a float: "))
print(x, y)

output:

Input an integer: 2
Input a float: 2.5

2 2.5

reading hex values from char array

#include <stdio.h>
#include <stdlib.h>

int main()
{
    unsigned char start[2]={0x01,0x02,0x00};
    printf("start[0]=%x\n",start[0]);
     printf("start[1]=%x\n",start[1]);
       // printf("start[2]=%x\n",start[2]);
    return 0;
}

right shift and left shift operator in c

#include<stdio.h>
int main()
{
// a = 5(00000101), b = 9(00001001)
unsigned char a = 5, b = 9;

// The result is 00001010
printf("a<<1 = %d\n", a<<3);

// The result is 00010010
printf("b<<1 = %d\n", b<<3);


// a = 5(00000101), b = 9(00001001)
        a = 5, b = 9;

    // The result is 00000010
    printf("a>>1 = %d\n", a>>1);

    // The result is 00000100
    printf("b>>1 = %d\n", b>>1);
return 0;
}

string test in c

#include <stdio.h>

int main ()
 {

   char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
   printf("Greeting message: %s\n", greeting );
   return 0;
}

output::::

null pointer in c

#include <stdio.h>

int main () {

   int  *ptr = NULL;
   printf("The value of ptr is : %x\n", ptr  );
   return 0;
}

output:::

little change in program:

#include <stdio.h>

int main () {

   int  *ptr = NULL;

   printf("The value of ptr is : %d\n", ptr  );

   return 0;

}

out put is same as above.

pointer in c

#include <stdio.h>

int main () {

   int  var = 20;   /* actual variable declaration */
   int  *ip;        /* pointer variable declaration */

   ip = &var;  /* store address of var in pointer variable*/

   printf("Address of var variable: %x\n", &var  );

   /* address stored in pointer variable */
   printf("Address stored in ip variable: %x\n", ip );

   /* access the value using the pointer */
   printf("Value of *ip variable: %d\n", *ip );

   return 0;
}

output:::

Note:

please send the questions which you are facing problem in C Language.

also write interview questions which are you faced in during interview related to C Language.

so i can try to solve them and send you back.

finding the address of variables in c

#include <stdio.h>

int main () {

   int  var1;
   char var2[10];

   printf("Address of var1 variable: %x\n", &var1  );
   printf("Address of var2 variable: %x\n", &var2  );

   return 0;
}

output:::

accessing array elements in c

#include <stdio.h>

int main () {

   int n[ 10 ]; /* n is an array of 10 integers */
   int i,j;

   /* initialize elements of array n to 0 */
   for ( i = 0; i < 10; i++ ) {
      n[ i ] = i + 100; /* set element at location i to i + 100 */
   }

   /* output each array element's value */
   for (j = 0; j < 10; j++ ) {
      printf("Element[%d] = %d\n", j, n[j] );
   }

   return 0;
}

output::

Note:

please send the questions which you are facing problem in C Language.

also write interview questions which are you faced in during interview related to C Language.

so i can try to solve them and send you back.

global variable values not considered in function calling from main in c

#include <stdio.h>

/* global variable declaration */
int a = 20;

int main () {

  /* local variable declaration in main function */
  int a = 10;
  int b = 20;
  int c = 0;

  printf ("value of a in main() = %d\n",  a);
  c = sum( a, b);
  printf ("value of c in main() = %d\n",  c);

  return 0;
}

/* function to add two integers */
int sum(int a, int b) {

   printf ("value of a in sum() = %d\n",  a);
   printf ("value of b in sum() = %d\n",  b);

   return a + b;
}

output:::

Note:

please send the questions which you are facing problem in C Language.

also write interview questions which are you faced in during interview related to C Language.

so i can try to solve them and send you back.