void WF_AssertionFailed(UINT8 moduleNumber, UINT16 lineNumber) 
{
    #if defined(STACK_USE_UART)
    char buf[8];
    
    putrsUART("WF ASSERTION: Module Number = ");
    
    sprintf(buf, "%d  ", moduleNumber);
    putsUART(buf);
    
    putrsUART("Line Number = ");
    
    sprintf(buf, "%d", lineNumber);
    putsUART(buf);
    #endif
    
    #if defined(USE_LCD)
    {
        char buf[] = {WIFI_ASSERT_STRING};
        memset(LCDText, ' ', sizeof(LCDText));
        memcpy((void *)LCDText, (void *)buf, strlen(buf));
        uitoa(moduleNumber, (BYTE*)buf);
        memcpy((void *)&LCDText[18], (void *)buf, strlen(buf));
        LCDText[23] = 'L';
        LCDText[24] = ':';
        uitoa(lineNumber, &LCDText[25]);
        LCDUpdate();
    }    
    #endif

    
    while(1);
}    
void DisplayIPValue(IP_ADDR IPVal)
#endif
{
    BYTE IPDigit[4]; //enough for a number <256: 3 digits + \0
    BYTE i;
    BYTE j;
    BYTE LCDPos=16;  //write on second line of LCD
#if defined(__SDCC__)
    unsigned int IP_field, radix=10; //type expected by sdcc's uitoa()
#endif

    for(i = 0; i < sizeof(IP_ADDR); i++) //sizeof(IP_ADDR) is 4
    {
#if defined(__SDCC__)
       IP_field =(WORD)(IPdw>>(i*8))&0xff;      //ML
       uitoa(IP_field, IPDigit, radix);      //ML
#else
       uitoa((WORD)IPVal.v[i], IPDigit);
#endif

       for(j = 0; j < strlen((char*)IPDigit); j++)
       {
	   LCDText[LCDPos++] = IPDigit[j];
       }
       if(i == sizeof(IP_ADDR)-1)
	    break;
       LCDText[LCDPos++] = '.';

    }
    if(LCDPos < 32u)
       LCDText[LCDPos] = 0;
    LCDUpdate();
}
Example #3
0
// Processes A/D data from the potentiometer
static void ProcessIO(void)
{
#if defined(__C30__) || defined(__C32__)
    // Convert potentiometer result into ASCII string
    uitoa((WORD)ADC1BUF0, AN0String);
#else
    // AN0 should already be set up as an analog input
    ADCON0bits.GO = 1;

    // Wait until A/D conversion is done
    while(ADCON0bits.GO);

	// AD converter errata work around (ex: PIC18F87J10 A2)
	#if !defined(__18F87J50) && !defined(_18F87J50) && !defined(__18F87J11) && !defined(_18F87J11) 
	{
		BYTE temp = ADCON2;
		ADCON2 |= 0x7;	// Select Frc mode by setting ADCS0/ADCS1/ADCS2
		ADCON2 = temp;
	}
	#endif

    // Convert 10-bit value into ASCII string
    uitoa(*((WORD*)(&ADRESL)), AN0String);
#endif
}
Example #4
0
/* signed integer to string */
static char *sitoa(char *str, int num)
{
    if (num < 0) {
        *str++ = '-';
        return uitoa(str, (unsigned)-num);
    }

    return uitoa(str, (unsigned)num);
}
Example #5
0
uint8_t REDFLY::socketConnect(uint8_t proto, uint8_t *ip, uint16_t port, uint16_t lport)
{
  uint8_t ret=INVALID_SOCKET, len;

  //ip
  iptoa(ip, (char*)buffer); 
  //port
  strcat_P((char*)buffer, PSTR(","));
  len = strlen((char*)buffer);
  uitoa(port, (char*)&buffer[len]);
  //local port
  strcat_P((char*)buffer, PSTR(","));
  len = strlen((char*)buffer);
  uitoa(lport, (char*)&buffer[len]);

  if(proto == PROTO_MCAST) //Multicast
  {
    proto = SOCKET_MCAST;
    if(cmd(buffer, 8, PSTR(CMD_MCAST), (char*)buffer) == 0) //xxx.xxx.xxx.xxx,aaaaa,bbbbb
    {
      ret = buffer[2]; //OKx
    }
  }
  else if(proto == PROTO_TCP) //TCP
  {
    proto = SOCKET_TCP;
    if(cmd(buffer, 8, PSTR(CMD_TCP), (char*)buffer) == 0) //xxx.xxx.xxx.xxx,aaaaa,bbbbb
    {
      ret = buffer[2]; //OKx
    }
  }
  else //UDP
  {
    proto = SOCKET_UDP;
    if(cmd(buffer, 8, PSTR(CMD_UDP), (char*)buffer) == 0) //xxx.xxx.xxx.xxx,aaaaa,bbbbb
    {
      ret = buffer[2]; //OKx
    }
  }

  if(ret != INVALID_SOCKET) //handle okay -> save socket handle and type
  {
    for(uint8_t i=0; i<MAX_SOCKETS; i++)
    {
      if(socket_state[i].handle == INVALID_SOCKET)
      {
        socket_state[i].handle = ret;
        socket_state[i].state  = proto;
        break;
      }
    }
  }

  return ret;
}
Example #6
0
// ==============================================
// = Provides the XML list of WiFi Scan Results =
// ==============================================
void HTTPPrint_aplist(void)
{
    int x;
    BYTE security;
    BYTE secString[4];
    BYTE bssTypeString[4];
    BYTE strVal;
    BYTE strString[4];

    for(x=0; x < SCANCXT.numScanResults; x++)
    {
        WFRetrieveScanResult(x, &bssDesc);

        TCPPutROMString(sktHTTP, (ROM BYTE*)"<bss>\n");
        TCPPutROMString(sktHTTP, (ROM BYTE*)"<name>");
        TCPPutString(sktHTTP, bssDesc.ssid);
        TCPPutROMString(sktHTTP, (ROM BYTE*)"</name>\n");
        TCPPutROMString(sktHTTP, (ROM BYTE*)"<privacy>");
        security = (bssDesc.apConfig & 0xd0) >> 4;
        uitoa(security, secString);
        TCPPutString(sktHTTP, secString);
        TCPPutROMString(sktHTTP, (ROM BYTE*)"</privacy>\n");
        TCPPutROMString(sktHTTP, (ROM BYTE*)"<wlan>");
        uitoa(bssDesc.bssType, bssTypeString);
        TCPPutString(sktHTTP, bssTypeString);
        TCPPutROMString(sktHTTP, (ROM BYTE*)"</wlan>\n");
        TCPPutROMString(sktHTTP, (ROM BYTE*)"<strength>");
        if (bssDesc.rssi < 121)
        {
            strVal = 1;
        }
        else if (bssDesc.rssi < 141)
        {
            strVal = 2;
        }
        else if (bssDesc.rssi < 161)
        {
            strVal = 3;
        }
        else
        {
            strVal = 4;
        }

        uitoa(strVal, strString);
        TCPPutString(sktHTTP, strString);
        TCPPutROMString(sktHTTP, (ROM BYTE*)"</strength>\n");
        TCPPutROMString(sktHTTP, (ROM BYTE*)"</bss>\n");
    }
}
Example #7
0
static void debugformatted(char *fmt, va_list va) {
    char buffer[VARG_BUF_LEN] = {0};
    strcpy(buffer, SAVE_CURSOR "\033[0;");
    uitoa(BOTTOM_HALF - 1, 10, &buffer[strlen(buffer)]);
    strcat(buffer, "r" "\033[");
    uitoa(BOTTOM_HALF - 1, 10, &buffer[strlen(buffer)]);
    strcat(buffer, ";0H\r\n");
    strcat(buffer, fmt);
    strcat(buffer, "\033[");
    uitoa(TERM_BOTTOM, 10, &buffer[strlen(buffer)]);
    strcat(buffer, ";");
    uitoa(TERMINAL_HEIGHT, 10, &buffer[strlen(buffer)]);
    strcat(buffer, "r" RESTORE_CURSOR);

    printformatted(IO, buffer, va);
}
Example #8
0
File: string.c Project: ORCOS/ORCOS
void lltoa( long long value, char* str, int base ) {
    static char num[] = "0123456789abcdefghijklmnopqrstuvwxyz";
    char* wstr = str;
    int sign = 0;
    // for all other bases we interpret value as unsigned!
    if (base != 10) return (uitoa((unsigned int) value,str,base));

    // Validate base
    if ( base < 2 || base > 35 ) {
        *wstr = '\0';
        return;
    }


    if ( ( sign = value ) < 0 )
        value = -value;

    // Conversion. Number is reversed.
    do
        *wstr++ = num[ value % base ];
    while ( value /= base );

    if ( sign < 0 )
        *wstr++ = '-';

    *wstr = '\0';

    // Reverse string
    strreverse( str, wstr - 1 );
}
Example #9
0
// =====================================================
// = Sends the number of BSS entries found from a scan =
// =====================================================
void HTTPPrint_bssCount(void)
{
    BYTE bssCountString[4];

    uitoa(SCANCXT.numScanResults, bssCountString);
    TCPPutString(sktHTTP, bssCountString);
}
Example #10
0
// ================================
// = Kick-off a WiFi Scan Process =
// ================================
void HTTPPrint_scan(void)
{
    BYTE scanInProgressString[4];

    uitoa(IS_SCAN_IN_PROGRESS(SCANCXT.scanState), scanInProgressString);
    TCPPutString(sktHTTP, scanInProgressString);
}
Example #11
0
static void OutTime(TCP_SOCKET socket, WORD wv, BYTE bt) {
	BYTE bafs[12];
	uitoa(wv,bafs); 
	if(bt != 'd') if(strlen(bafs) < 2)	TCPPut(socket, '0');
	TCPPutString(socket, bafs);
	TCPPut(socket, bt); if(bt != 's')  { TCPPut(socket, ','); } // TCPPut(socket, ' '); }
}
Example #12
0
static void test_helper_uitoa_single(unsigned int ui, char* expected) {
	char* got = uitoa(ui);
	
	CU_ASSERT_STRING_EQUAL(got, expected);
	
	free(got);
}
Example #13
0
static const char* ProcessIO(void)
{
    static uint8_t AN0String[8];
    // Convert potentiometer result into ASCII string
    uitoa((uint16_t) ADC1BUF0, AN0String);
    return (const char*)AN0String;
}
void LCDDisplayIPValue(IP_ADDR IPVal)
{
#ifdef USE_LCD

    uint8_t IPDigit[4];
    uint8_t i;
    uint8_t j;
    uint8_t LCDPos=16;

    for (i = 0; i < sizeof(IP_ADDR); i++)
    {
        uitoa((uint16_t)IPVal.v[i], IPDigit);

        for (j = 0; j < strlen((char*)IPDigit); j++)
        {
            LCDText[LCDPos++] = IPDigit[j];
        }
        
        if (i == sizeof(IP_ADDR) - 1)
            break;
            
        LCDText[LCDPos++] = '.';
    }

    if (LCDPos < 32u)
        LCDText[LCDPos] = 0;
    
    LCDUpdate();

#endif
}
Example #15
0
static void OutDot(TCP_SOCKET socket, WORD wv) { //, BYTE t) {
	BYTE i,r, bafs[6], sus[8];
	uitoa(wv, bafs); r = strlen(bafs);
	for(i=0;i<5-r;i++)	sus[i] = '0'; sus[i]=0;
	strcat(sus,bafs);
	for(i=0;i<5;i++)	{ TCPPut(socket, sus[i]); if(i==2) TCPPut(socket, '.'); }
}
Example #16
0
void LCDDisplayIPValue(IP_ADDR IPVal)
{
    BYTE IPDigit[4];
    BYTE i;
    BYTE j;
    BYTE LCDPos=16;

    for(i = 0; i < sizeof(IP_ADDR); i++)
    {
        uitoa((WORD)IPVal.v[i], IPDigit);

        for(j = 0; j < strlen((char*)IPDigit); j++)
        {
            LCDText[LCDPos++] = IPDigit[j];
        }
        if(i == sizeof(IP_ADDR)-1)
            break;
        LCDText[LCDPos++] = '.';
    }


    if(LCDPos < 32u)
        LCDText[LCDPos] = 0;
    LCDUpdate();
}
Example #17
0
void DisplayIPValue(IP_ADDR IPVal)
{
    char message[16 + 1];

//	printf("%u.%u.%u.%u", IPVal.v[0], IPVal.v[1], IPVal.v[2], IPVal.v[3]);
#if defined (__dsPIC33E__) || defined (__PIC24E__)
	static uint8_t IPDigit[4];    					/* Needs to be declared as static to avoid the array getting optimized by C30 v3.30 compiler for dsPIC33E/PIC24E. 
												   Otherwise the LCD displays corrupted IP address on Explorer 16. To be fixed in the future compiler release*/
#else
    uint8_t IPDigit[4];
#endif
	uint8_t i;

    strcpy(message, "");
    for (i = 0; i < sizeof (IP_ADDR); i++)
    {
        uitoa((uint16_t) IPVal.v[i], IPDigit);
        strcat(message, (char *) IPDigit);
        if (i < sizeof (IP_ADDR) - 1)
        {
            strcat(message, ".");
        }
    }
    SYS_OUT_MESSAGE_LINE(message, 1);
    SYS_CONSOLE_MESSAGE((char *) message);
}
Example #18
0
static void exoit(TCP_SOCKET sock) {
	BYTE bafs[12];
	TCPPutROMString(sock,resNDD);
	uitoa(strlen(httpData),bafs);
	TCPPutString(sock,bafs);
	TCPPutROMString(sock,resNDC);
	TCPFlush(sock); TCPDisconnect(sock);

}
Example #19
0
void itoa(int num, char *buf) {
    /*
     * converts an integer into the string representation
     * stores result into buf
     */
    if (num < 0) {
        num = -num;
        *buf++ = '-';
    }
    uitoa((unsigned int)num, 10, buf);
}
Example #20
0
void IP2String(IP_ADDR IPVal, char *buf) {
    BYTE i, IPDigit[11], ptt[2];
	ptt[0] = '.'; ptt[1] = 0;
	buf[0]=0;
	for(i = 0; i < sizeof(IP_ADDR); i++) 	{
	    uitoa((WORD)IPVal.v[i], IPDigit);
	    strcat(buf,IPDigit);
	    if(i == sizeof(IP_ADDR)-1)				break;
		strcat(buf,ptt);
	}
}
Example #21
0
/* supported formats: %%, %d, %u, %x, %p, %s, %c
 * TODO:
 *  - return number of bytes copied into 'str' */
int kvsprintf(char *str, const char *fmt, va_list ap)
{
    char *ptr, *stmp;
    unsigned utmp;
    int itmp;
    char ctmp;

    for (; *fmt; fmt = ptr + 2) {
        ptr = kstrchr(fmt, '%');
        if (ptr == NULL) {
            kstrcpy(str, fmt);
            return 1;
        }

        str += kstrncpy(str, fmt, (int)ptr - (int)fmt);

        switch (*(ptr + 1)) {
            case 'd': /* signed int */
                itmp = va_arg(ap, int);
                str = sitoa(str, itmp);
                break;
            case 'u': /* unsigned int */
                utmp = va_arg(ap, unsigned);
                str = uitoa(str, utmp);
                break;
            case 'p': /* pointer */
                *str++ = '0';
                *str++ = 'x';
            case 'x': /* hex */
                utmp = va_arg(ap, unsigned);
                str = htoa(str, utmp);
                break;
            case 's': /* string */
                stmp = va_arg(ap, char *);
                str += kstrcpy(str, stmp);
                break;
            case '%':
                *str++ = '%';
                break;
            case 'c':
                ctmp = va_arg(ap, int);
                *str++ = ctmp;
                break;
            default:
                /* unsupported format */
                break;
        }
    }

    return 1;
}
Example #22
0
uint8_t REDFLY::socketSendPGM(uint8_t socket, PGM_P stream, uint8_t *ip, uint16_t port)
{
  uint8_t len;
  uint16_t size = strlen_P(stream);

  //socket
  uitoa(socket, (char*)buffer);
  //size
  strcat_P((char*)buffer, PSTR(","));
  len = strlen((char*)buffer);
  uitoa(size, (char*)&buffer[len]);
  //ip
  if(ip && (socketState(socket) == SOCKET_UDP))
  {
    strcat_P((char*)buffer, PSTR(","));
    len = strlen((char*)buffer);
    iptoa(ip, (char*)&buffer[len]);
  }
  else
  {
    strcat_P((char*)buffer, PSTR(",0"));
  }
  //port
  if(port && (socketState(socket) == SOCKET_UDP))
  {
    strcat_P((char*)buffer, PSTR(","));
    len = strlen((char*)buffer);
    uitoa(port, (char*)&buffer[len]);
  }
  else
  {
    strcat_P((char*)buffer, PSTR(",0"));
  }
  //data
  strcat_P((char*)buffer, PSTR(","));

  return cmd(PSTR(CMD_SEND), (char*)buffer, stream); //x,xxxx,xxx.xxx.xxx.xxx,xxxxx,
}
Example #23
0
int vsprintf(char *buf, const char *fmt, va_list args)
{
    char *p;
    char tmp[STR_DEFAULT_LEN];
    va_list p_next_arg = args;

    for (p = buf; *fmt; fmt++) {
        if (*fmt != '%') {
            *p++ = *fmt;
            continue;
        }

        fmt++;

        switch (*fmt) {
            case 'x':
                strcpy(p, uitoa(tmp, *((int *)p_next_arg), 16));
                p += strlen(tmp);
                p_next_arg += 4;
                break;
            case 'd':
                strcpy(p, uitoa(tmp, *((int *)p_next_arg), 10));
                p += strlen(tmp);
                p_next_arg += 4;
                break;
            case 's':
                strcpy(p, *(char **)p_next_arg);
                p += strlen(*(char **)p_next_arg);
                p_next_arg += 4;
            default:
                break;
        }
    }

    *p = 0;

    return (p - buf);
}
void milli_to_string(uint16_t v, char* buffer, uint8_t display) {
  char tempBuffer[20];
  int decimals;

  if (display == DISPLAY_MILLI) {
    uitoa(v, tempBuffer, 10);
    addCommas(tempBuffer, buffer);
  } else {
    if (display == DISPLAY_3DECIMALS) {
      decimals = 3;
    } else if (display == DISPLAY_2DECIMALS) {
      decimals = 2;
    } else if (display == DISPLAY_1DECIMALS) {
      decimals = 1;
    }
    uitoa(v % 1000, buffer, 10);
    padLeft(buffer, tempBuffer, decimals, '0');
    tempBuffer[decimals] = '\0';
    uitoa(v / 1000, buffer, 10);
    strcat(buffer, ".");
    strcat(buffer, tempBuffer);
  }
}
Example #25
0
// Callback function for the dynamic variable ~pot(num)~. Anytime the browser
// asks for ~pot(num)~, this function is executed.
void HTTPPrint_pot(WORD num)
{
	BYTE AN0String[8];
	WORD ADval;

	// Analog values reading according to the webpage request.
	switch(num)
	{
		case 0:
			ADval = ADCVal(1);
			uitoa(ADval, (BYTE*)AN0String);
			break;
		case 1:
			ADval = ADCVal(2);
			uitoa(ADval, (BYTE*)AN0String);
			break;	
	}

	// After the analog value is read, it is sent to the webpage
	// using the function TCPPutString. sktHTTP is the standard
	// socket for the HTTP communication.
   	TCPPutString(sktHTTP, AN0String);
}
Example #26
0
void benchmark(void) {
    uint32_t i, pixels, ms, pps;
    char pps_str[25];
	coord_t height, width, rx, ry, rcx, rcy;
    color_t random_color;
	font_t font;

    gdispSetOrientation(GDISP_ROTATE_90);

	width = gdispGetWidth();
	height = gdispGetHeight();
    font = gdispOpenFont("UI2 Double");

	gdispDrawStringBox(0, 0, width, 30, "ChibiOS/GFX - Benchmark", font, White, justifyCenter);

	font = gdispOpenFont("UI2");
	gdispDrawStringBox(0, height/2, width, 30, "5000 random rectangles", font, White, justifyCenter);
	
	gfxSleepMilliseconds(3000);
	
	/* seed for the rand() */
	srand(DWT_CYCCNT);
	pixels = 0;

	CPU_RESET_CYCLECOUNTER;

	for (i = 0; i < 5000; i++) {
		random_color = (rand() % 65535);
		rx = (rand() % (width-10));
		ry = (rand() % (height-10));
		rcx = (rand() % ((width-rx)-10))+10;
		rcy = (rand() % ((height-ry)-10))+10;

		gdispFillArea(rx, ry, rcx, rcy, random_color);
		pixels += (rcx+1)*(rcy+1);
	}

	ms = DWT_CYCCNT / 168000;
	pps = (float)pixels/((float)ms/1000.0f);

	memset (pps_str, 0, sizeof(pps_str));
	uitoa(pps, pps_str, sizeof(pps_str));
	strcat(pps_str, " Pixels/s");

	font = gdispOpenFont("UI2 Double");
	gdispClear(Black);
	gdispDrawStringBox(0, 0, width, 30, "ChibiOS/GFX - Benchmark", font, White, justifyCenter);
	gdispDrawStringBox(0, height/2, width, 30, pps_str, font, White, justifyCenter);
	//gdispDrawString(20, height/2, pps_str, font, White);
}
Example #27
0
// Writes an IP address to the LCD display and the UART as available
void DisplayIPValue(IP_ADDR IPVal)
{
//	printf("%u.%u.%u.%u", IPVal.v[0], IPVal.v[1], IPVal.v[2], IPVal.v[3]);
#if defined (__dsPIC33E__) || defined (__PIC24E__)
	static BYTE IPDigit[4];    					/* Needs to be declared as static to avoid the array getting optimized by C30 v3.30 compiler for dsPIC33E/PIC24E. 
												   Otherwise the LCD displays corrupted IP address on Explorer 16. To be fixed in the future compiler release*/
#else
    BYTE IPDigit[4];
#endif
	BYTE i;
#ifdef USE_LCD
	BYTE j;
	BYTE LCDPos=16;
#endif

	for(i = 0; i < sizeof(IP_ADDR); i++)
	{
	    uitoa((WORD)IPVal.v[i], IPDigit);

		#if defined(STACK_USE_UART)
			putsUART((char *) IPDigit);
		#endif

		#ifdef USE_LCD
			for(j = 0; j < strlen((char*)IPDigit); j++)
			{
				LCDText[LCDPos++] = IPDigit[j];
			}
			if(i == sizeof(IP_ADDR)-1)
				break;
			LCDText[LCDPos++] = '.';
		#else
			if(i == sizeof(IP_ADDR)-1)
				break;
		#endif

		#if defined(STACK_USE_UART)
			while(BusyUART());
			WriteUART('.');
		#endif
	}

	#ifdef USE_LCD
		if(LCDPos < 32u)
			LCDText[LCDPos] = 0;
		LCDUpdate();
	#endif
}
Example #28
0
// Processes A/D data from the potentiometer
static void ProcessIO(void)
{
    BYTE temp;
    // AN0 should already be set up as an analog input
    ADCON0bits.GO = 1;

    // Wait until A/D conversion is done
    while(ADCON0bits.GO);

    temp = ADCON2;
    ADCON2 |= 0x7;    // Select Frc mode by setting ADCS0/ADCS1/ADCS2
    ADCON2 = temp;

    // Convert 10-bit value into ASCII string
    uitoa(*((WORD*)(&ADRESL)), AN0String);
}
Example #29
0
void debugc(char *fmt, unsigned int color, ...) {
    #if DEBUG
        char buffer[VARG_BUF_LEN] = {0};
        va_list va;
        va_start(va, color);

        strcpy(buffer, "\033[");
        uitoa(color, 10, &buffer[strlen(buffer)]);
        strcat(buffer, "m");
        strcat(buffer, fmt);
        strcat(buffer, "\033[0m");

        debugformatted(buffer, va);
        va_end(va);
    #endif
}
Example #30
0
bool fix_field_unparse(struct fix_field *self, struct buffer *buffer)
{
    buffer->end += uitoa(self->tag, buffer_end(buffer));

    buffer_put(buffer, '=');

    switch (self->type) {
    case FIX_TYPE_STRING: {
        const char *p = self->string_value;

        while (*p) {
            buffer_put(buffer, *p++);
        }
        break;
    }
    case FIX_TYPE_STRING_8: {
        for (int i = 0; i < sizeof(self->string_8_value) && self->string_8_value[i]; ++i) {
            buffer_put(buffer, self->string_8_value[i]);
        }
        break;
    }
    case FIX_TYPE_CHAR: {
        buffer_put(buffer, self->char_value);
        break;
    }
    case FIX_TYPE_FLOAT: {
        // dtoa2 do not print leading zeros or .0, 7 digits needed sometimes
        buffer->end += modp_dtoa2(self->float_value, buffer_end(buffer), 7);
        break;
    }
    case FIX_TYPE_INT: {
        buffer->end += i64toa(self->int_value, buffer_end(buffer));
        break;
    }
    case FIX_TYPE_CHECKSUM: {
        buffer->end += checksumtoa(self->int_value, buffer_end(buffer));
        break;
    }
    default:
        break;
    };

    buffer_put(buffer, 0x01);

    return true;
}