Subversion Repositories HomeAutomation

/*********************************************************************

*

*                  Helper Functions for Microchip TCP/IP Stack

*

*********************************************************************

* FileName:         Helpers.C

* Dependencies:     Compiler.h

*                   Helpers.h

* Processor:        PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F

* Complier:         Microchip C18 v3.02 or higher

*                   Microchip C30 v2.01 or higher

* Company:          Microchip Technology, Inc.

*

* Software License Agreement

*

* This software is owned by Microchip Technology Inc. ("Microchip")

* and is supplied to you for use exclusively as described in the

* associated software agreement.  This software is protected by

* software and other intellectual property laws.  Any use in

* violation of the software license may subject the user to criminal

* sanctions as well as civil liability.  Copyright 2006 Microchip

* Technology Inc.  All rights reserved.

*

* This software is provided "AS IS."  MICROCHIP DISCLAIMS ALL

* WARRANTIES, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, NOT LIMITED

* TO MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND

* INFRINGEMENT.  Microchip shall in no event be liable for special,

* incidental, or consequential damages.

*

*

* Author               Date    Comment

*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Nilesh Rajbharti     5/17/01 Original        (Rev 1.0)

* Nilesh Rajbharti     2/9/02  Cleanup

* Nilesh Rajbharti     6/25/02 Rewritten CalcIPChecksum() to avoid

*                              multi-byte shift operation.

* Howard Schlunder      2/9/05 Added hexatob(), btohexa_high(), and

*                              btohexa_low()

********************************************************************/

#include "..\Include\Compiler.h"

#include "..\Include\Helpers.h"

#include "..\Include\MAC.h"

#if defined(__C30__) || defined(HI_TECH_C)

/*********************************************************************

* Function:     void itoa(unsigned int Value, char *Buffer)

*

* PreCondition: None

*

* Input:        Value: Unsigned integer to be converted

*               Buffer: Pointer to a location to write the string

*

* Output:       *Buffer: Receives the resulting string

*

* Side Effects: None

*

* Overview:     The function converts an unsigned integer (16 bits)

*               into a null terminated decimal string.

*

* Note:         None

********************************************************************/

void itoa(unsigned int Value, char *Buffer)

{

    unsigned char i;

    unsigned int Digit;

    unsigned int Divisor;

    enum {FALSE = 0, TRUE} Printed = FALSE;

    if(Value)

    {

        for(i = 0, Divisor = 10000; i < 5; i++)

        {

            Digit = Value/Divisor;

            if(Digit || Printed)

            {

                *Buffer++ = '0' + Digit;

                Value -= Digit*Divisor;

                Printed = TRUE;

            }

            Divisor /= 10;

        }

    }

    else

    {

        *Buffer++ = '0';

    }

    *Buffer = '\0';

}              

#endif

/*********************************************************************

* Function:        BYTE hexatob(WORD_VAL AsciiChars)

*

* PreCondition:    None

*

* Input:           Two ascii bytes; each ranged '0'-'9', 'A'-'F', or

*                       'a'-'f'

*

* Output:          The resulting packed byte: 0x00-0xFF

*

* Side Effects:    None

*

* Overview:        None

*

* Note:         None

********************************************************************/

BYTE hexatob(WORD_VAL AsciiChars)

{

    // Convert lowercase to uppercase

    if(AsciiChars.v[1] > 'F')

        AsciiChars.v[1] -= 'a'-'A';

    if(AsciiChars.v[0] > 'F')

        AsciiChars.v[0] -= 'a'-'A';

    // Convert 0-9, A-F to 0x0-0xF

    if(AsciiChars.v[1] > '9')

        AsciiChars.v[1] -= 'A' - 10;

    else

        AsciiChars.v[1] -= '0';

    if(AsciiChars.v[0] > '9')

        AsciiChars.v[0] -= 'A' - 10;

    else

        AsciiChars.v[0] -= '0';

    // Concatenate

    return (AsciiChars.v[1]<<4) |  AsciiChars.v[0];

}

/*********************************************************************

* Function:        BYTE btohexa_high(BYTE b)

*

* PreCondition:    None

*

* Input:           One byte ranged 0x00-0xFF

*

* Output:          An ascii byte (always uppercase) between '0'-'9'

*                   or 'A'-'F' that corresponds to the upper 4 bits of

*                   the input byte.

*                   ex: b = 0xAE, btohexa_high() returns 'A'

*

* Side Effects:    None

*

* Overview:        None

*

* Note:         None

********************************************************************/

BYTE btohexa_high(BYTE b)

{

    b >>= 4;

    return (b>0x9) ? b+'A'-10:b+'0';

}

/*********************************************************************

* Function:        BYTE btohexa_low(BYTE b)

*

* PreCondition:    None

*

* Input:           One byte ranged 0x00-0xFF

*

* Output:          An ascii byte (always uppercase) between '0'-'9'

*                   or 'A'-'F' that corresponds to the lower 4 bits of

*                   the input byte.

*                   ex: b = 0xAE, btohexa_low() returns 'E'

*

* Side Effects:    None

*

* Overview:        None

*

* Note:         None

********************************************************************/

BYTE btohexa_low(BYTE b)

{

    b &= 0x0F;

    return (b>9) ? b+'A'-10:b+'0';

}

WORD swaps(WORD v)

{

    WORD_VAL t;

    BYTE b;

    t.Val   = v;

    b       = t.v[1];

    t.v[1]  = t.v[0];

    t.v[0]  = b;

    return t.Val;

}

DWORD swapl(DWORD v)

{

    BYTE b;

    DWORD myV;

    DWORD_VAL *myP;

    myV     = v;

    myP     = (DWORD_VAL*)&myV;

    b       = myP->v[3];

    myP->v[3] = myP->v[0];

    myP->v[0] = b;

    b       = myP->v[2];

    myP->v[2] = myP->v[1];

    myP->v[1] = b;

    return myV;

}

WORD CalcIPChecksum(BYTE* buffer, WORD count)

{

    WORD i;

    WORD *val;

    union

    {

        DWORD Val;

        struct

        {

            WORD_VAL LSB;

            WORD_VAL MSB;

        } words;

    } tempSum, sum;

    sum.Val = 0;

    i = count >> 1;

    val = (WORD *)buffer;

    while( i-- )

        sum.Val += *val++;

    if ( count & 1 )

        sum.Val += *(BYTE *)val;

    tempSum.Val = sum.Val;

    while( (i = tempSum.words.MSB.Val) != 0u )

    {

        sum.words.MSB.Val = 0;

        sum.Val = (DWORD)sum.words.LSB.Val + (DWORD)i;

        tempSum.Val = sum.Val;

    }

    return (~sum.words.LSB.Val);

}

/*********************************************************************

* Function:        WORD CalcIPBufferChecksum(WORD len)

*

* PreCondition:    TCPInit() is already called     AND

*                  MAC buffer pointer set to starting of buffer

*

* Input:           len     - Total number of bytes to calculate

*                          checksum for.

*

* Output:          16-bit checksum as defined by rfc 793.

*

* Side Effects:    None

*

* Overview:        This function performs checksum calculation in

*                  MAC buffer itself.

*

* Note:            None

********************************************************************/

#if defined(NON_MCHP_MAC)

WORD CalcIPBufferChecksum(WORD len)

{

    BOOL lbMSB;

    WORD_VAL checkSum;

    BYTE Checkbyte;

    lbMSB = TRUE;

    checkSum.Val = 0;

    while( len-- )

    {

        Checkbyte = MACGet();

        if ( !lbMSB )

        {

            if ( (checkSum.v[0] = Checkbyte+checkSum.v[0]) < Checkbyte)

            {

                if ( ++checkSum.v[1] == 0 )

                    checkSum.v[0]++;

            }

        }

        else

        {

            if ( (checkSum.v[1] = Checkbyte+checkSum.v[1]) < Checkbyte)

            {

                if ( ++checkSum.v[0] == 0 )

                    checkSum.v[1]++;

            }

        }

        lbMSB = !lbMSB;

    }

    checkSum.v[1] = ~checkSum.v[1];

    checkSum.v[0] = ~checkSum.v[0];

    return checkSum.Val;

}

#endif

/*********************************************************************

* Function:     char *strupr(char *s)

*

* PreCondition: None

*

* Input:        s: Pointer to a null terminated string to convert.

*

* Output:       char* return: Pointer to the initial string

*               *s: String is updated in to have all upper case

*                   characters

*

* Side Effects: None

*

* Overview:     The function sequentially converts all lower case

*               characters in the input s string to upper case

*               characters.  Non a-z characters are skipped.

*

* Note:         None

********************************************************************/

#if defined(__C30__) || defined(HI_TECH_C)

char *strupr(char *s)

{

    char c;

    char *t;

    t = s;

    while( (c = *t) )

    {

        if(c >= 'a' && c <= 'z')

        {

            *t -= ('a' - 'A');

        }

        t++;

    }

    return s;

}

#endif

void dwordToHex(DWORD c,char *str)

{

    BYTE b;

    str[0]='0';

    str[1]='x';

    b = c>>24;

    str[2]=btohexa_high(b);

    str[3]=btohexa_low(b);

    b = c>>16;

    str[4]=btohexa_high(b);

    str[5]=btohexa_low(b);

    b = c>>8;

    str[6]=btohexa_high(b);

    str[7]=btohexa_low(b);

    b = c;

    str[8]=btohexa_high(b);

    str[9]=btohexa_low(b);

    str[10]='\0';

}

void timestampToString(DWORD t, char *str)

{

        DWORD days=t/86400;

        DWORD day_sec=t%86400+7200;

        int year = days/365+1970;

        int dy = days%365; //left in year

        int month=0;

        int day=0;

        int daysOfMonth = 31;

        int i;

        int hh;

        int mm;

        int ss;

        int skottar = (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0));

        dy-=9; // corr!!

        for(i = 1; i <= 12; ++i)

        {

                if(dy <= daysOfMonth) { day=dy; break; }

                else { dy -= daysOfMonth; }

                if(daysOfMonth==31) daysOfMonth=30; else daysOfMonth=31;

                if (i==1) daysOfMonth=(skottar?29:28);

        }

        month=i;

        hh = day_sec/3600;

        mm = (day_sec%3600)/60;

        ss = (day_sec%3600)%60;

        str[0]=(year/1000)+48;

        str[1]=(year-(str[0]-48)*1000)/100+48;

        str[2]=(year-(str[0]-48)*1000-(str[1]-48)*100)/10+48;

        str[3]=(year-(str[0]-48)*1000-(str[1]-48)*100-(str[2]-48)*10)+48;

        str[4]='-';

        str[5]=month/10+48;

        str[6]=(month-(str[5]-48)*10)+48;

        str[7]='-';

        str[8]=day/10+48;

        str[9]=(day-(str[8]-48)*10)+48;

        str[10]=' ';

        str[11]=hh/10+48;

        str[12]=(hh-(str[11]-48)*10)+48;   

        str[13]=':';

        str[14]=mm/10+48;

        str[15]=(mm-(str[14]-48)*10)+48;

        str[16]=':';

        str[17]=ss/10+48;

        str[18]=(ss-(str[17]-48)*10)+48;

        str[19]='\0';

}