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: