Subversion Repositories svnkaklik

#include <16F887.h>
#device *=16
#device adc=8
#device PASS_STRINGS=IN_RAM
#zero_ram
#FUSES NOWDT                     //No Watch Dog Timer
#FUSES INTRC_IO                  //Internal RC Osc, no CLKOUT
#FUSES PUT                       //Power Up Timer
#FUSES MCLR                      //Master Clear pin enabled
#FUSES NOPROTECT                 //Code protected from reads
#FUSES NOCPD                     //No EE protection
#FUSES BROWNOUT                  //Reset when brownout detected
#FUSES NOIESO                    //Internal External Switch Over mode disabled
#FUSES NOFCMEN                   //Fail-safe clock monitor disabled
#FUSES NOLVP                     //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NODEBUG                   //No Debug mode for ICD
#FUSES NOWRT                     //Program memory not write protected
#FUSES BORV21                    //Brownout reset at 2.1V
#use delay(clock=8000000,RESTART_WDT)
#use rs232(baud=BAUDRATE,parity=N,xmit=TXD,rcv=RXD,bits=8,errors)


/*$F*************************************************************************
*
* Copyright (C)pa 2004 Mark Norton
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Functional
* Description:  Implementation of sscanf() function for the CCS compiler
*
*****************************************************************************/
#include <string.h>
#include <stdlib.h>

/* Uncomment any of these to reduce the code size
   Note that the HEX is a big hog
*/
#define NO_FLOAT
// #define NO_INT
// #define NO_SIGNED_INT
// #define NO_STRING
// #define NO_HEX

/* *************************************************************************
  DESCRIPTION:  Converts string pointed to by s to an unsigned long (16 bit)
  RETURN: result of the conversion
  ALGORITHM:  none
  NOTES:  the next position in the string is returned in endptr
 *************************************************************************** */
long my_atoul(char *s, char *endptr, int base)
{
  signed long result;
  int index;
  char c;

  index = 0;
  result = 0;
  *endptr = s;

  if (( !s ) || ( !*s ))
    return ( 0 );

  c = *s;

  // increase index if positive sign is detected
  if (c == '+')
  {
    c = *(++s);
  }

  // The number is a decimal number
  if (base == 10)
  {
    while (c >= '0' && c <= '9')
    {
      result = 10*result + (c - '0');
      c = *(++s);
    }
  }
  else if (base == 16)    // The number is a hexa number
  {
    if (c == '0' && (*(s+1) == 'x' || *(s+1) == 'X'))
    {
      s += 2;
      c = *s;
    }

    c = toupper(c);
    while ( 1 )
    {
      if (c >= '0' && c <= '9')
        result = (result << 4) + (c - '0');
      else if (c >= 'A' && c <='F')
        result = (result << 4) + (c - 'A' + 10);
      else
        break;
      c = toupper(*(++s));
    }
  }
  *endptr = s;
  return(result);
}

/* *************************************************************************
  DESCRIPTION:  Converts string pointed to by s to a float
  RETURN: result of the conversion
  ALGORITHM:  none
  NOTES:  the next position in the string is returned in endptr
 *************************************************************************** */
float my_atof(char * s, char *endptr)
{
  float pow10 = 1.0;
  float result = 0.0;
  int sign = 0;
  char c;

  c = *s;

  if(c == '-')
  {
    sign = 1;
    c = *(++s);
  }
  else if(c == '+')
    c = *(++s);


  while((c >= '0' && c <= '9'))
  {
    result = 10*result + c - '0';
    c = *(++s);
  }

  if (c == '.')
  {
    c = *(++s);
    while((c >= '0' && c <= '9'))
    {
      pow10 = pow10*10;
      result += (c - '0')/pow10;
      c = *(++s);
    }
  }

   if (sign == 1)
     result = -1*result;

  *endptr = s;
  return(result);
}


/* *************************************************************************
  DESCRIPTION:  Implementation of scanf() using CCS C compiler
  RETURN: total number of arguments read
  ALGORITHM:  none
  NOTES:  none
 *************************************************************************** */
int8 sscanf(
  char  *buf,    /* pointer to the buffer that we are scanning */
  char  *fmt,    /* pointer to the format string */
  char  *pArgs)  /* pointer to array of arguments */
{

  int8        count = 0;
  char        *p;
  int1        size_long;
  int1        sign;
  char        *endptr;

  while (1)
  {
   /* Look to see if we are out of arguments */
   if ( !pArgs )
     return( count );

   /* Gobble up the fmt string */
    while (*buf == *fmt)
    {
      if ((*buf == 0) || (*fmt == 0))
        return (count);
      buf++;
      fmt++;
    }

    /* Check for the % */
    if (*fmt != '%')
      break;

    /* fmt should be '%' go to the next character */
    fmt++;

    /* get the size modifier */
    switch (*fmt)
    {
      case 'l':
      case 'L':
        fmt++;
        size_long = TRUE;
        break;
      default:
        size_long = FALSE;
        break;
    }

    /* fmt should point to our first conversion letter at this point */
    switch (*fmt)
    {
#ifndef NO_FLOAT
      case 'f':
      case 'F':
        /* Get a pointer to this argument */
        p = (float *)(*pArgs);

        /* convert to a number */
        *(float *)p = (float)my_atof(buf, &endptr);

        /* Make sure that we succeeded */
        if ( buf == endptr )
          return ( count );
        buf = endptr;

        /* count this one */
        count++;
        break;
#endif
#ifndef NO_SIGNED_INT
      case 'd':
      case 'D':
        /* Get a pointer to this argument */
        p = (signed int8 *)(*pArgs);
        if (*buf == '-')
        {
          buf++;
          sign = TRUE;
        }
        else
          sign = FALSE;

        /* convert to a number */
        if ( size_long )
        {
          *(signed int16 *)p = (signed int16)my_atoul(buf, &endptr, 10);
          if (sign)
            *(signed int16 *)p = -(*(signed int16 *)p);
        }
        else
        {
          *(signed int8 *)p = (signed int8)my_atoul(buf, &endptr, 10);
          if (sign)
            *(signed int8 *)p = -(*(signed int8 *)p);
        }
        /* Make sure that we succeeded */
        if ( buf == endptr )
          return ( count );
        buf = endptr;

        /* count this one */
        count++;
        break;
#endif
#ifndef NO_INT
      case 'u':
      case 'U':
        /* Get a pointer to this argument */
        p = (int8 *)(*pArgs);

        /* convert to a number */
        if ( size_long )
          *(int16 *)p = (int16) my_atoul(buf, &endptr, 10);
        else
          *(int8 *)p = (int8) my_atoul(buf, &endptr, 10);

        /* Make sure that we succeeded */
        if ( buf == endptr )
          return ( count );
        buf = endptr;

        /* count this one */
        count++;
        break;
#endif
#ifndef NO_STRING
      case 's':
        /* Get a pointer to this argument */
        p = (char *)(*pArgs);

        /* copy the chars */
        while (1)
        {
          if ((isspace(*buf)) || (!*buf))
          {
            *p = 0;
            break;
          }
          else
          {
            *p = *buf;
            p++;
            buf++;
          }
        }

        /* count this one */
        count++;
        break;
#endif
#ifndef NO_HEX
      case 'x':
      case 'X':
        /* Get a pointer to this argument */
        p = (int8 *)(*pArgs);

        /* convert to a number */
        if ( size_long )
          *(int16 *)p = (int16) my_atoul(buf, &endptr, 16);
        else
          *(int8 *)p = (int8) my_atoul(buf, &endptr, 16);

        /* Make sure that we succeeded */
        if ( buf == endptr )
          return ( count );
        buf = endptr;

        /* count this one */
        count++;
        break;
#endif
      /* unhandled format specifier */
      default:
        return (count);
    }
    /* Technically this is incorrect but since the size of all pointers
       are the same, who cares ;)

       point to the next argument
    */
    pArgs += sizeof(char *);
   
    /* Move to the next format char */
    fmt++;
  }

  return (count);
}



void main() {
    char x;
    char sbuffer[64];
    char cmd=0,param=0;
    long l;

    set_tris_a(0x80);
    port_b_pullups(0xFF);
    set_tris_b(0xFF);
    set_tris_d(0);
    set_tris_e(0x01);
    setup_oscillator(OSC_8MHZ);
    setup_adc_ports(sAN5|VSS_VDD);
    setup_adc(ADC_CLOCK_INTERNAL);
    set_adc_channel(5);
    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
    setup_timer_1(T1_INTERNAL|T1_DIV_BY_2);
    setup_timer_2(T2_DIV_BY_16, 155, 1);
    setup_ccp1(CCP_PWM);
    set_pwm1_duty(75);
    setup_comparator(NC_NC_NC_NC);

sprintf(sbuffer,"/S30\n\");
x = sscanf(sbuffer,"/%C%d", &cmd, &param);
printf("\n\rsscanf sez: %u found, cmd %X param %X\n\r",x,cmd,param);

}