示例#1
0
int CAimProto::aim_set_avatar_hash(HANDLE hServerConn, unsigned short &seqno, char flags, unsigned short bart_type, unsigned short &id, char size, const char* hash)
{
    unsigned short offset = 0;

    char bart_type_txt[8];
    ultoa(bart_type, bart_type_txt, 10);
    unsigned short bart_type_len = (unsigned short)mir_strlen(bart_type_txt);

    unsigned short req = 0x09;
    if (id == 0) {
        id = get_random();
        req = 0x08;
    }

    char* buf = (char*)alloca(SNAC_SIZE + TLV_HEADER_SIZE * 2 + 20 + size + bart_type_len);
    aim_writesnac(0x13, req, offset, buf, get_random());               // SSI Edit/Add
    aim_writeshort(bart_type_len, offset, buf);                       // name length
    aim_writegeneric(bart_type_len, bart_type_txt, offset, buf);       // name
    aim_writeshort(0, offset, buf);                                   // group id
    aim_writeshort(id, offset, buf);                                  // buddy id
    aim_writeshort(0x14, offset, buf);                                // buddy type: Buddy Icon
    aim_writeshort(2 + size + TLV_HEADER_SIZE, offset, buf);              // length of extra data

    char* buf2 = (char*)alloca(2 + size);
    buf2[0] = flags;
    buf2[1] = (char)size;
    memcpy(&buf2[2], hash, size);
    aim_writetlv(0xd5, 2 + size, buf2, offset, buf);                  // BART

    return aim_sendflap(hServerConn, 0x02, offset, buf, seqno);
}
示例#2
0
trap_retval ReqGet_err_text( void )
/******************************/
{
    static char *DosErrMsgs[] = {
        #define pick(a,b)   b,
        #include "dosmsgs.h"
        #undef pick
    };
    get_err_text_req    *acc;
    char                *err_txt;

    _DBG( "AccErrText\r\n" );
    acc = GetInPtr( 0 );
    err_txt = GetOutPtr( 0 );
    if( acc->err < ERR_LAST ) {
        strcpy( err_txt, DosErrMsgs[ acc->err ] );
        _DBG( "After strcpy\r\n" );
    } else {
        _DBG( "After acc->error_code > MAX_ERR_CODE" );
        strcpy( err_txt, TRP_ERR_unknown_system_error );
        ultoa( acc->err, err_txt + strlen( err_txt ), 16 );
        _DBG( "After utoa()\r\n" );
    }
    return( strlen( err_txt ) + 1 );
}
示例#3
0
String::String(unsigned long value, unsigned char base)
{
	init();
	char buf[33];
	ultoa(value, buf, base);
	*this = buf;
}
示例#4
0
condcode    scr_c2d( parm parms[MAX_FUN_PARMS], size_t parmcount, char * * result, int32_t ressize )
{
    char            *   pval;
    char            *   pend;
    condcode            cc;
    uint32_t            n;
    char                linestr[MAX_L_AS_STR];
    char            *   p;

    if( (parmcount < 1) || (parmcount > 2) ) {// accept 2. parm, but ignore it
        cc = neg;
        return( cc );
    }

    pval = parms[0].a;
    pend = parms[0].e;

    unquote_if_quoted( &pval, &pend );


    n = 0;
    while( pval <= pend ) {
        n *= 256;                      // ignore overflow, let it wrap around
        n += (unsigned char)*pval;
        pval++;
    }
    ultoa( n, linestr, 10 );
    p = linestr;
    while( *p && ressize > 0) {
        **result = *p++;
        *result += 1;
        ressize--;
    }
    return( pos );
}
示例#5
0
static void ensureBufferReflectsCurToken( void )
{
    if( TokenUsesBuffer( CurToken ) ) {
        if( CurToken == T_CONSTANT ) {
            switch( ConstType ) {
            case TYP_UCHAR:
            case TYP_UINT:
            case TYP_ULONG:
                ultoa( U32Fetch( Constant64 ), Buffer, 10 );
                break;
            case TYP_SCHAR:
            case TYP_SINT:
            case TYP_SLONG:
                ltoa( U32Fetch( Constant64 ), Buffer, 10 );
                break;
            case TYP_ULONG64:
            case TYP_SLONG64:
                sti64cpy( Buffer, Constant64 );
                break;
            }
        }
    } else {
        strcpy( Buffer, Tokens[ CurToken ] );
    }

}
int mmc_std_inquiry( SIM_HBA *hba, CCB_SCSIIO *ccb )
{
	SIM_MMC_EXT		*ext;
	SCSI_INQUIRY	*iptr;
	char			buf[8];

	ext		= (SIM_MMC_EXT *)hba->ext;
	iptr	= (SCSI_INQUIRY *)ccb->cam_data.cam_data_ptr;

	memset(iptr, 0, sizeof(*iptr));

	iptr->peripheral	= D_DIR_ACC;
	iptr->rmb			= ext->normval ? CAM_FALSE : CAM_TRUE;
	iptr->version		= INQ_VER_SPC3;			// SPC-3
	iptr->adlen			= 32;

	if (ext->version < MMC_VERSION_1) {
		/* Vendor ID */
		strcpy((char *)&iptr->vend_id[0], "SD:");
		ultoa(ext->cid.sd_cid.mid, buf, 10);
		iptr->vend_id[3] = buf[0];
		iptr->vend_id[4] = buf[1];
		iptr->vend_id[5] = buf[2];

		/* Product ID */
		strcpy((char *)&iptr->prod_id[0], (char *)ext->cid.sd_cid.pnm);

		/* Product revision level, BCD code */
		iptr->prod_rev[0] = (ext->cid.sd_cid.prv >> 4) + '0';
		iptr->prod_rev[1] = '.';
		iptr->prod_rev[2] = (ext->cid.sd_cid.prv & 0x0F) + '0';
	} else {
示例#7
0
文件: HEADER.CPP 项目: hkaiser/TRiAS
Bool Header :: _GetMerkmalsKode (ulong &MK, char *pText) 
{

#if _MSC_VER >= 1100
	HPROJECT hPr = DEX_GetDataSourceHandle();
	HeaderEntryX HD (pText,hPr);
#else
	HeaderEntryX HD (pText);
#endif

	if (HD.Status () != HE_INVALID)
	{
		MK = HD.EntryLong ();

// KK000608 -----------------------------------
#if _MSC_VER >= 1100
		long lMKode = MK;
		MK = DEX_MapMCodeToHandle(hPr,lMKode);
// --------------------------------------------
#endif
		return True;
	}		

//  sonst neuen Eintrag erzeugen und speichern
	char Buffer [20] = "";
	ultoa (MK, Buffer, DEX_GetMkBase ());
	HD.SetEntryText (Buffer);
	if (HD.WriteBack () != EC_OKAY)  // Wert speichern
		return False;

	return True;
}
示例#8
0
static void syspgnumadfun( symvar *e ) // pagenumber.
{
    e = e;
    ultoa( page, syspgnumadstr, 10 );
    strcat( syspgnumadstr, "." );
    return;
};
示例#9
0
文件: str.cpp 项目: ChenYingChou/clib
// unsigned long to string
void StrPP::ultos(const unsigned long n)
{
  char num[15];
  ultoa(n, num, 10);

  SetStr(num);
}
示例#10
0
///////////////////////////////////////////////////////////////////////////
//
//	US_PrintUnsigned() - Prints an unsigned long
//
///////////////////////////////////////////////////////////////////////////
void
US_PrintUnsigned(longword n)
{
	char	buffer[32];

	US_Print(ultoa(n,buffer,10));
}
示例#11
0
unsigned ReqGet_err_text( void )
{
    static char *DosErrMsgs[] = {
        #define pick(a,b)   b,
        #include "dosmsgs.h"
        #undef pick
    };
    get_err_text_req    *acc;
    char                *err_txt;

    if( !TaskLoaded ) {
        acc = GetInPtr( 0 );
        err_txt = GetOutPtr( 0 );
        if( LoadError != NULL ) {
            strcpy( err_txt, LoadError );
            LoadError = NULL;
        } else if( acc->err < ERR_LAST ) {
            strcpy( err_txt, DosErrMsgs[ acc->err ] );
        } else {
            strcpy( err_txt, TRP_ERR_unknown_system_error );
            ultoa( acc->err, err_txt + strlen( err_txt ), 16 );
        }
        return( strlen( err_txt ) + 1 );
    }
    return( DoAccess() );
}
示例#12
0
文件: lcdktms.c 项目: bluefix/picsdr
void loop()                     // run over and over again
{
     
  ultoa( encoder0Pos, msg1, 10);
  //ultoa ( second, msg1, 10);
  digitalWrite(12, 0); //delay(1);
  lcd.print( msg1);
  digitalWrite(12, 1);
 
  delay(100);



/*  if (oldSecond != second) {
    Serial.print(second);
    Serial.print(". ->");
    Serial.print(millis() - starttime);
    Serial.println(".");

    delay(100);

    oldSecond = second;
  }
*/

}
byte ESP8266_Simple::startHttpServer(unsigned port, unsigned long (* requestHandler)(char *buffer, int bufferLength), unsigned int maxBufferSize)
{
  char cmdBuffer[64];
  byte responseCode;
  
  this->httpServerRequestHandler = requestHandler;
  this->httpServerMaxBufferSize = maxBufferSize;
  
  // Enter MUX mode
  responseCode = this->sendCommand(F("AT+CIPMUX=1"));
  if(responseCode != ESP8266_OK) return responseCode;
  
  // Set Server Timeout
  memset(cmdBuffer,0,sizeof(cmdBuffer));
  strcpy_P(cmdBuffer, PSTR("AT+CIPSTO=,"));
  ultoa(this->generalCommandTimeoutMicroseconds/1000/1000, cmdBuffer+strlen(cmdBuffer), 10);    
  this->sendCommand(cmdBuffer);
  
  // Start Server
  memset(cmdBuffer,0,sizeof(cmdBuffer));
  strcpy_P(cmdBuffer, PSTR("AT+CIPSERVER=1,"));
  itoa(port, cmdBuffer+strlen(cmdBuffer), 10);    
  responseCode = this->sendCommand(cmdBuffer);
  if(responseCode != ESP8266_OK) return responseCode;
    
  return ESP8266_OK;
}
示例#14
0
文件: printf.c 项目: a-darwish/cuteOS
/*
 * Convert given signed long integer (@num) to ascii using
 * desired radix. Return the number of ascii chars printed.
 * @size: output buffer size
 */
static int ltoa(signed long num, char *buf, int size, int radix)
{
	printk_assert(radix > 2 && radix <= PRINTK_MAX_RADIX);

	if (num < 0) {
		/* Make room for the '-' */
		printk_assert(size >= 2);

		num *= -1;
		buf[0] = '-';

		return ultoa(num, buf+1, size-1, radix) + 1;
	}

	return ultoa(num, buf, size, radix);
}
//---------------------------------------------------------------------------
UINT GetTempFileName(char *PathName,char *Prefix,UINT Unique,char *TempFileName)
{
  EasyStr Ret;
  WORD Num=WORD(Unique ? WORD(Unique):WORD(rand() & 0xffff));
  for(;;){
    Ret=PathName;
    Ret+=SLASH;
    Ret+=Prefix;
    Ret.SetLength(MAX_PATH+4);
    char *StartOfNum=Ret.Right()+1;
    ultoa(Num,StartOfNum,16);
    strupr(StartOfNum);
    Ret+=".TMP";
    if (Ret.Length()<MAX_PATH){
      if (Unique==0){
        if (access(Ret,0)==0){ //File exists
          Num++;
        }else{
          strcpy(TempFileName,Ret);
          fclose(fopen(TempFileName,"wb"));
          return Num;
        }
      }else{
        strcpy(TempFileName,Ret);
        return Num;
      }
    }else{
      return 0;
    }
  }
}
示例#16
0
String & String::append(unsigned long num)
{
	char buf[11];
	ultoa(num, buf, 10);
	append(buf, strlen(buf));
	return *this;
}
示例#17
0
String::String(unsigned long value, unsigned char base)
{
	init();
	char buf[1 + 8 * sizeof(unsigned long)];
	ultoa(value, buf, base);
	*this = buf;
}
/* Adds the elfcorehdr= command line parameter to command line. */
static int cmdline_add_elfcorehdr(char *cmdline, unsigned long addr)
{
    int cmdlen, len, align = 1024;
    char str[30], *ptr;

    /* Passing in elfcorehdr=xxxK format. Saves space required in cmdline.
     * Ensure 1K alignment*/
    if (addr%align)
        return -1;
    addr = addr/align;
    ptr = str;
    strcpy(str, " elfcorehdr=");
    ptr += strlen(str);
    ultoa(addr, ptr);
    strcat(str, "K");
    len = strlen(str);
    cmdlen = strlen(cmdline) + len;
    if (cmdlen > (COMMAND_LINE_SIZE - 1))
        die("Command line overflow\n");
    strcat(cmdline, str);
#if 0
    printf("Command line after adding elfcorehdr\n");
    printf("%s\n", cmdline);
#endif
    return 0;
}
示例#19
0
void DumpType(                  // DUMP TYPE ENTRY
    TYPE tp )                   // - type pointer
{
    char *id;                   // - id for symbol

    if( tp == NULL ) {
        printf( "NULL type\n" );
        return;
    }
    if( tp->id >= TYP_MAX ) {
        ultoa( tp->id, unknown_type + sizeof( unknown_type ) - 2, 16 );
        id = unknown_type;
    } else {
        id = id_names[ tp->id ];
    }
    printf( "TYPE"          F_BADDR
            " next"         F_PTR
            " id="          F_STRING
            " flag"         F_HEX_1
            " of"           F_PTR
            " u1"           F_PTR
            " u2"           F_PTR
            F_EOL
          , tp
          , tp->next
          , id
          , tp->flag
          , tp->of
          , tp->u.f.args
          , tp->u.f.pragma
          );
}
示例#20
0
文件: iostream.cpp 项目: davidwe/xpcc
void
xpcc::IOStream::writeInteger(uint32_t value)
{
#if defined(XPCC__CPU_AVR)
	char buffer[ArithmeticTraits<uint32_t>::decimalDigits + 1]; // +1 for '\0'
	
	// Uses the optimized non standard function 'ultoa()' which is
	// not always available.
	this->device->write(ultoa(value, buffer, 10));
#else
	char buffer[ArithmeticTraits<uint32_t>::decimalDigits + 1]; // +1 for '\0'
	
	// ptr points to the end of the string, it will be filled backwards
	char *ptr = buffer + ArithmeticTraits<uint32_t>::decimalDigits;

	*ptr = '\0';

	// calculate the string backwards
	do{
		uint32_t quot = value / 10;
		uint8_t rem = value - quot*10;
		*(--ptr) = static_cast<char>(rem) + '0';
		value = quot;
	}while (value != 0);

	// write string
	this->device->write(ptr);
#endif
}
示例#21
0
char* MyMessage::getString(char *buffer) const {
	uint8_t payloadType = miGetPayloadType();
	if (payloadType == P_STRING) {
		strncpy(buffer, data, miGetLength());
		buffer[miGetLength()] = 0;
		return buffer;
	} else if (buffer != NULL) {
		if (payloadType == P_BYTE) {
			itoa(bValue, buffer, 10);
		} else if (payloadType == P_INT16) {
			itoa(iValue, buffer, 10);
		} else if (payloadType == P_UINT16) {
			utoa(uiValue, buffer, 10);
		} else if (payloadType == P_LONG32) {
			ltoa(lValue, buffer, 10);
		} else if (payloadType == P_ULONG32) {
			ultoa(ulValue, buffer, 10);
		} else if (payloadType == P_FLOAT32) {
			dtostrf(fValue,2,fPrecision,buffer);
		} else if (payloadType == P_CUSTOM) {
			return getCustomString(buffer);
		}
		return buffer;
	} else {
		return NULL;
	}
}
示例#22
0
NAME NameDummy( void )
/********************/
{
    name_dummy_index_t ni;
    unsigned xhash;
    unsigned bucket;
    unsigned len;
    idname **head;
    char buff[ 1 + 1 + sizeof( ni ) * 3 + 1 ];

    ExtraRptIncrementCtr( ctr_dummy_names );
    ni = nameDummyIndex++;
    xhash = ni % NAME_TABLE_HASH;
    bucket = xhash;
    buff[0] = NAME_OPERATOR_OR_DUMMY_PREFIX1;
    buff[1] = NAME_DUMMY_PREFIX2;
    // the contents of the name don't have to be different just the address
    // but for debugging it is handy to have unique contents
#ifndef NDEBUG
    ultoa( ni, &buff[2], 10 );
    len = strlen( buff );
#else
    buff[2] = '0';
    buff[3] = '\0';
    len = 3;
#endif
    head = &(hashTable[ bucket ]);
    return( nameAdd( head, bucket, xhash, buff, len ) );
}
static int add_cmdline_param(char *cmdline, uint64_t addr, char *cmdstr,
				char *byte)
{
	int cmdlen, len, align = 1024;
	char str[COMMAND_LINE_SIZE], *ptr;

	/* Passing in =xxxK / =xxxM format. Saves space required in cmdline.*/
	switch (byte[0]) {
		case 'K':
			if (addr%align)
				return -1;
			addr = addr/align;
			break;
		case 'M':
			addr = addr/(align *align);
			break;
	}
	ptr = str;
	strcpy(str, cmdstr);
	ptr += strlen(str);
	ultoa(addr, ptr);
	strcat(str, byte);
	len = strlen(str);
	cmdlen = strlen(cmdline) + len;
	if (cmdlen > (COMMAND_LINE_SIZE - 1))
		die("Command line overflow\n");
	strcat(cmdline, str);
#if DEBUG
	fprintf(stderr, "Command line after adding elfcorehdr: %s\n", cmdline);
#endif
	return 0;
}
示例#24
0
unsigned char String::concat(unsigned long num)
{
    char buf[11];

    ultoa(num, buf, 10);
    return concat( buf, strlen(buf) );
}
uint8_t* f2str(freq_t f, uint8_t *buffer, uint8_t len)
{
    uint8_t i;
    uint8_t j;
    uint8_t *p;

    // Mhz
    ultoa(f_MHZ(f), buffer, 10);

    i = len - strlen(buffer);
    j = 0;
    p = buffer + strlen(buffer);

    // multiply fractional part to get the rest of required digits
    while (j < i) {
        if (j & 0b11) {
            f = 10 * (f - MHZ_f(f_MHZ(f)));
            *p = '0' + f_MHZ(f);
        }
        else{
            if (j == 0) *p = ',';
            else *p = '.';
        }
        ++p;
        ++j;
    }

    // discard ending dot
    if (*(p-1) == '.') --p;
    *p = '\0';

    return buffer;
}
示例#26
0
void fib(void *n){
    unsigned long val;
    char str_val[100]={0};
    if(n == NULL)
    {
	print_str("Invalid argument\n");
	print_str("Usage: fin n\n");
    }

    val = strtol(n,NULL,10);
    print_str("input n is ");
    print_str(n);
    print_str("\r\n\0");

    print_str("calculating... ");
    val = fibonacci(val);
    print_str("\r\n\0");

    print_str("fib(n) : ");
    ultoa(val, str_val, 10);
    print_str(str_val);
    print_str("\r\n\n\0");
    return;
 
}
示例#27
0
void    scr_el( void )
{
    ifcb    *   cb = input_cbs->if_cb;
    char        linestr[MAX_L_AS_STR];

    scan_err = false;
    cb->if_flags[cb->if_level].iflast = false;
    cb->if_flags[cb->if_level].ifcwte = false;

    if( !(cb->if_flags[cb->if_level].iftrue
          || cb->if_flags[cb->if_level].iffalse)

        || cb->if_flags[cb->if_level].ifthen
        || cb->if_flags[cb->if_level].ifelse
        || cb->if_flags[cb->if_level].ifdo ) {

        scan_err = true;
        g_err( err_if_else );
        if( input_cbs->fmflags & II_macro ) {
            ultoa( input_cbs->s.m->lineno, linestr, 10 );
            g_info( inf_mac_line, linestr, input_cbs->s.m->mac->name );
        } else {
            ultoa( input_cbs->s.f->lineno, linestr, 10 );
            g_info( inf_file_line, linestr, input_cbs->s.f->filename );
        }
        show_ifcb( "else", cb );
        show_include_stack();
        err_count++;
        return;
    }
    cb->if_flags[cb->if_level].ifelse = true;
    ProcFlags.keep_ifstate = true;
    if( input_cbs->fmflags & II_research && GlobalFlags.firstpass ) {
        show_ifcb( "else", cb );
    }
    garginit();                         // find end of control word

    while( *scan_start == ' ' ) {
        scan_start++;
    }

    if( *scan_start ) {                 // rest of line is not empty split
        split_input( buff2, scan_start, false );// and process next
    }
    scan_restart = scan_stop + 1;
    return;
}
示例#28
0
/*
 * generate and transmit pathname block consisting of
 *  pathname (null terminated),
 *  file length, mode time and file mode in octal
 *  as provided by the Unix fstat call.
 *  N.B.: modifies the passed name, may extend it!
 */
int wctxpn(const char *name)
{

  char *p, *q;

//DSERIAL.println("\nwctxpn");

  strcpy(txbuf,name);
  p = q = txbuf + strlen(txbuf)+1;
  //Pete (El Supremo) fix bug - was 1024, should be TXBSIZE??
  while (q < (txbuf + TXBSIZE))
    *q++ = 0;
//  if (!Ascii && (in!=stdin) && *name && fstat(fileno(in), &f)!= -1)
  if (!Ascii)
    // I will have to figure out how to convert the uSD date/time format to a UNIX epoch
//    sprintf(p, "%lu %lo %o 0 %d %ld", fout.fileSize(), 0L,0600, Filesleft, Totalleft);
// Avoid sprintf to save memory for small boards.  This sketch doesn't know what time it is anyway
    ultoa(fout.fileSize(), p, 10);
    strcat_P(p, PSTR(" 0 0 0 "));
    q = p + strlen(p);
    ultoa(Filesleft, q, 10);
    strcat_P(q, PSTR(" "));
    q = q + strlen(q);
    ultoa(Totalleft, q, 10);

  Totalleft -= fout.fileSize();
//DSERIAL.print(F("wctxpn sf = "));
//DSERIAL.print(sf);
//DSERIAL.print(F("  length = "));
//DSERIAL.println(Totalleft);
  if (--Filesleft <= 0)
    Totalleft = 0;
  if (Totalleft < 0)
    Totalleft = 0;

  /* force 1k blocks if name won't fit in 128 byte block */
  //Pete (El Supremo) This can't be right??!
  if (txbuf[125])
//    blklen=1024;
    blklen = TXBSIZE;
  else {          /* A little goodie for IMP/KMD */
    blklen = 128;
    txbuf[127] = (fout.fileSize() + 127) >>7;
    txbuf[126] = (fout.fileSize() + 127) >>15;
  }
  return zsendfile(txbuf, 1+strlen(p)+(p-txbuf));
}
示例#29
0
/*****************************************************************************************************************************
*
*   Read specified metric's value of the Winsen MH-Zxx CO2 sensor via UART, put it to output buffer on success. 
*
*   Returns: 
*     - RESULT_IS_BUFFERED on success
*     - DEVICE_ERROR_TIMEOUT if device stop talking
*
*****************************************************************************************************************************/
int8_t getMHZxxMetricUART(const uint8_t _rxPin, const uint8_t _txPin, uint8_t* _dst, int32_t* _value, const uint8_t _wantsNumber) {
  uint8_t len, rc = DEVICE_ERROR_TIMEOUT;

  SoftwareSerial swSerial(_rxPin, _txPin);

  // Send query only if sensor heated
  if (millis() > MH_ZXX_PREHEAT_TIMEOUT) {
  
     swSerial.begin(MH_ZXX_UART_SPEED);

     _dst[MH_ZXX_STARTING_BYTE] = 0xFF;                           // Starting byte
     _dst[MH_ZXX_SENSOR_NUMBER] = 0x01;                           // Sensor No.
     _dst[MH_ZXX_CMD] = MH_ZXX_CMD_GAS_CONCENTRATION;             // Command
     _dst[3] = _dst[4] = _dst[5] = _dst[6] = _dst[7] = 0x00;      // Stub bytes
     _dst[MH_ZXX_CRC] = 0x79;                                     // Check value

     // Flush all device's transmitted data to avoid get excess data in recieve buffer
     //serialRXFlush(&swSerial, !UART_SLOW_MODE);
     flushStreamRXBuffer(&swSerial, MH_ZXX_DEFAULT_READ_TIMEOUT, !UART_SLOW_MODE);


     // The serial stream can get out of sync. The response starts with 0xff, try to resync : https://github.com/jehy/arduino-esp8266-mh-z19-serial/blob/master/arduino-esp8266-mhz-19-serial.ino
     //  Send command to MH-Zxx
     serialSend(&swSerial, _dst, MH_ZXX_PACKET_SIZE, !UART_SLOW_MODE);

     
     //  Recieve from MH-Zxx
     //  It actually do not use '\r', '\n', '\0' to terminate string
     len = serialRecive(&swSerial, _dst, MH_ZXX_PACKET_SIZE, MH_ZXX_DEFAULT_READ_TIMEOUT, !UART_STOP_ON_CHAR, '\r', !UART_SLOW_MODE);
     
     // Connection timeout occurs
     if (len < MH_ZXX_PACKET_SIZE) { rc = DEVICE_ERROR_TIMEOUT; goto finish; }
     
     // Wrong answer. buffer[0] must contain 0xFF
     if (0xFF != _dst[MH_ZXX_STARTING_BYTE]) { rc = DEVICE_ERROR_WRONG_ANSWER; goto finish; }
     
     // Bad CRC
     // CRC calculate for bytes #1..#9 (byte #0 excluded)
     if (_dst[MH_ZXX_CRC] != crcMHZxx(_dst)) { rc = DEVICE_ERROR_CHECKSUM; goto finish; }
     
     *_value = 256 * _dst[MH_ZXX_GAS_CONCENTRATION_HIGH_BYTE];
     *_value += _dst[MH_ZXX_GAS_CONCENTRATION_LOW_BYTE];
  } else {  // if (millis() > MH_ZXX_PREHEAT_TIMEOUT)
     // Return 'good concentracion' while sensor heated
     *_value = MH_ZXX_PREHEAT_GAS_CONCENTRATION;
  } // if (millis() > MH_ZXX_PREHEAT_TIMEOUT)

  if (!_wantsNumber) {
     ultoa(*_value, (char*) _dst, 10);
  }

  rc = RESULT_IS_BUFFERED;

  finish:
  gatherSystemMetrics(); // Measure memory consumption
  swSerial.~SoftwareSerial(); 
  return rc;

}
示例#30
0
String::String( const unsigned long value, const int base )
{
  char buf[33];   
  ultoa(value, buf, 10);
  getBuffer( _length = strlen(buf) );
  if ( _buffer != NULL )
    strcpy( _buffer, buf );
}