misc.c

介绍ROCK OS操作系统.一般用于汽车电子,类似OCVX.里面是个DEMO文档,内附说明.

/******************************************************************************
    Copyright (c) 2006 by RockOS.
    All rights reserved.

    This software is supported by the Rock Software Workroom only.

    Any bugs please contact the author with e-mail or QQ:
     E-mail : [e-mail]
         QQ : 59681888
*******************************************************************************
File name   : misc.c
Description : misc functions used by RockOS.
            : 
            : 
Auther      : sunxinqiu
History     :
  2006-03-15   first release.
******************************************************************************/

#include "os.h"

/******************************************************************************
Global var  : HSEMA g_stdoutSem;
            : HSEMA g_stderrSem;
Description : semaphores for stdout and std error device.
            : 
******************************************************************************/
HSEMA g_stdoutSem;
HSEMA g_stderrSem;

/******************************************************************************
Function    : U32 sec2Tick (U32 seconds)
Params      : seconds - seconds
            : 
            : 
            : 
Return      : how many ticks in (seconds) seconds.
Description : it is easy to use, for taskDelay() etc.
            : 
******************************************************************************/
U32 sec2Tick (U32 seconds)
{
    return seconds * TICKS_PER_SECOND;
}

/******************************************************************************
Function    : void OS_putchar(const char ch)
Params      : ch - the char which to be output to stdout.
            : 
            : 
            : 
Return      : N/A
Description : the alternative function for putc() for RockOS.
            : 
******************************************************************************/
void OS_putchar(const char ch)
{
    if (g_OSRunning == OS_PHASE_SCHEDULING)
    {
        semTake(g_stdoutSem, OS_WAIT_FOR_EVER);
        OS_putch(ch);
        semGive(g_stdoutSem);
    }
    else
    {
        OS_putch(ch);
    }
}
/******************************************************************************
Function    : void OS_printf (const char * format, ...)
Params      : format - the format for informations.
            : 
            : 
            : 
Return      : N/A
Description : the alternative function for printf() for RockOS.
            : 
******************************************************************************/
void OS_printf (const char * format, ...)
{
    va_list arglist; 
    char buffer[1024];

    va_start(arglist, format); 
    vsprintf(&buffer[0], format, arglist); 
    va_end(arglist); 

    if ((g_OSRunning == OS_PHASE_SCHEDULING)&&(g_cpuIntDepth == 0))
    {
        semTake(g_stdoutSem, OS_WAIT_FOR_EVER);
        OS_putstring(&buffer[0]);
        semGive(g_stdoutSem);
    }
    else
    {
        OS_putstring(&buffer[0]);
    }
}

/******************************************************************************
Function    : void OS_error (const char * format, ...)
Params      : format - the format for error informations.
            : 
            : 
            : 
Return      : N/A
Description : same as OS_printf(), but use a well-marked color to mark that
            : this information is an error.
******************************************************************************/
void OS_error (const char * format, ...)
{
    va_list arglist; 
    char buffer[1024];

    va_start(arglist, format); 
    vsprintf(&buffer[0], format, arglist); 
    va_end(arglist); 

    if ((g_OSRunning == OS_PHASE_SCHEDULING)&&(g_cpuIntDepth == 0))
    {
        semTake(g_stderrSem, OS_WAIT_FOR_EVER);
        OS_puterror(&buffer[0]);
        semGive(g_stderrSem);
    }
    else
    {
        OS_puterror(&buffer[0]);
    }
}

/******************************************************************************
Function    : void fatalError(const char * format, ...)
Params      : format - the format for fatal error informations.
            : 
            : 
            : 
Return      : N/A
Description : enter fatal error, print error msg, and reboot the system
            : by enable watchdog.
******************************************************************************/
void fatalError(const char * format, ...)
{
    va_list arglist; 
    char buffer[1024];

    va_start(arglist, format); 
    vsprintf(&buffer[0], format, arglist); 
    va_end(arglist); 

    OS_puterror(&buffer[0]);

    enable_watchdog();
    while(1);
}

#ifdef USE_FLOAT_DATA
/******************************************************************************
Global var  : int g_floatPrecision = 15;
Description : to rule the precision when str2double() translating float number.
            : 
******************************************************************************/
int g_floatPrecision = 15;

/******************************************************************************
Function    : double str2double (const char * str)
Params      : str - the string contains the double value.
            : 
            : 
            : 
Return      : the integer value translated from string (str).
Description : only decimal float number could be translated normally.
            : constant string like 1.0E+8 is translated to constant 1.0
******************************************************************************/
double str2double (const char * str)
{
    int length;
    int precision;
    int end;

    double value;    /* the return value. */
    double sign;   /* positive or negative number. */
    double base;
    
    /* discarding the leading space and TABs. */
    length = 0;
    while(str[length] != '\0')
    {
        if ((str[length] == ' ')||(str[length] == '\t'))
        {
            length++;
        }
        else
        {
            break;
        }
    }

    /* it's a positive or negative number. */
    if (str[length] == '-')
    {
        sign = -1.0;
        length++;
    }
    else
    {
        sign = 1.0;
    }
    
    /* get value. */
    value = 0;
    base = 10.0;
    end   = 0;
    precision = 0;

    while ((str[length] != '\0')&&(end == 0))
    {
        if (precision > g_floatPrecision)
        {
            break;
        }

        switch (str[length])
        {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            if (base > 1.0)
            {
                value = value * base + (double)(str[length]-'0');
            }
            else
            {
                value = value + (double)(str[length]-'0') * base;
                base *= 0.1;
                precision++;
            }
            break;
            
        case '.':
            if (base > 1.0)
            {
                base = 0.1;
                precision = 0;
            }
            else
            {
                end = 1;
            }
            break;
        default:
            end = 1;
            break;
        }
        length++;
    }
    
    return sign * value;
}
#endif

/******************************************************************************
Function    : int str2int (const char * str)
Params      : str - the string contains the integer value.
            : 
            : 
            : 
Return      : the integer value translated from string (str).
Description : Three type constant can be recognised:
            :    * decimal number
            :    * hexadecimal number
            :    * octal number
            : constant string like 1.0E+8 is translated to constant 1.
******************************************************************************/
int str2int (const char * str)
{
    int length;
    int end;
    int value;    /* the return value. */

    int sign;   /* positive or negative number. */
    int base;
    
    /* discarding the leading space and TABs. */
    length = 0;
    while(str[length] != '\0')
    {
        if ((str[length] == ' ')||(str[length] == '\t'))
        {
            length++;
        }
        else
        {
            break;
        }
    }
    /* it's a positive or negative number. */
    if (str[length] == '-')
    {
        sign = -1;
        length++;
    }
    else
    {
        sign = 1;
    }

    /* it's in oct, hex or dec. */
    if (str[length] == '0')
    {
        if ((str[length+1] == 'x')||(str[length+1] == 'X'))
        {
            base = 16;
            length += 2;
        }
        else
        {
            base =  8;
            length += 1;
        }
    }
    else
    {
        base = 10;
    }
    
    if ((sign == -1)&&(base != 10))
    {
        return 0;
    }

    /* get value. */
    value = 0;
    end   = 0;
    while ((str[length] != '\0')&&(end == 0))
    {
        switch (str[length])
        {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
            value = value * base + (int)(str[length]-'0');
            break;

        case '9':
            if (base != 8)
            {
                value = value * base + (int)(str[length]-'0');
            }
            else
            {
                end = 1;
            }
            break;

        case 'a':
        case 'b':
        case 'c':
        case 'd':
        case 'e':
        case 'f':
            if (base == 16)
            {
                value = value * base + (int)(str[length] - 'a' + 10);
            }
            else
            {
                end = 1;
            }
            break;
        case 'A':
        case 'B':
        case 'C':
        case 'D':
        case 'E':
        case 'F':
            if (base == 16)
            {
                value = value * base + (int)(str[length] - 'A' + 10);
            }
            else
            {
                end = 1;
            }
            break;
        default:
            end = 1;
            break;
        }
        
        if (end == 0)
        {
            length++;
        }
    }
    
    return value * sign;
}