AVR Freaks

Code-of-Conduct

void lcd_write_int(unsigned int data)
{
	 char st[16] = "";  //  Make space
	 itoa(data,st,10);
	 lcd_write_string(st);
}
void lcd_write_int(unsigned int data)
{
    char st[10];
    sprintf(st,"%s",data);
    lcd_write_string(st);
}
int main(void)
{
    AVR_INIT();
    spi_init();
    DISPLAY_INIT();

    while(1)
    {
        TCNT0 = 0X00;	//CLEAR TIMER0
        TCCR0B = 0X07;	//CONNECT T0 PIN TO COUNTER

        _delay_ms(1000);	//WAIT 1 SECOND

        TCCR0B = 0X00;	//DISCONNECT T0

        if(TCNT0 < 10000)
        {
            utoa(TCNT0+10000, buffer, 10);
            buffer[0]='0';
        }

        uint8_t cnt;
        dig = 0x05;
        cnt = 0x00;
        while(dig > 0)
        {
            inf = buffer[cnt++];
            Display_Digit(dig, inf);
            dig--;
        }
    }
}
void lcd_write_int(unsigned int data)
{
    char st[10];
    sprintf(st,"%s",data);
    lcd_write_string(st);
}
//===========================================================================
// String Print a number with Fixed widht and precision (decimal point).
// Signed version.
void SPrintFixed( char* Buf, int32_t n, int8_t Length, int8_t Precision) {
	char Sign;
	ldiv_t	Number;

	if( n < 0) {
		n = -n;
		Sign = '-';
	}
	else
		Sign = ' ';

	Buf[Length] = 0x00;
	Number.quot = n;
	do {
		Number = ldiv( Number.quot, 10);
		Buf[--Length] = Number.rem + '0';
		if( --Precision == 0)
			Buf[--Length] = '.';
	}while( (Length > 0) && ((Number.quot) || (Precision >= 0)) );

	if( Sign == '-') {
		if( Length > 0)
			Buf[--Length] = '-';
	}

	while(Length > 0)		// Fill remaining space with spaces.
		Buf[--Length] = ' ';
}

//===========================================================================
// Integer to ascii, Fixed length.
// Copy from snippets.c Version: 2014-05-06.
static void ItoaF( char* Dest, uint32_t Number, uint8_t Digits, uint8_t Base){
	ldiv_t N;

	if(!Digits )
		return;		// No room to store the number.

	Dest += Digits -1;	// Write the number from back to front.

	if( Number == 0) {
		// Write the first digit.
		// Rest will be filled with spaces.
		*Dest-- = '0';
		Digits--;
		// Bug: Debugged, but this line is still missing in some other projects!.
		// Forgetting to decrement digits writes a space to many to the output.
		// 2014-05-06.
	}
	else {
		for( N.quot = Number; N.quot; Digits--, Dest--) {
			N = ldiv( N.quot, Base);
			if( N.rem > 9)				// Hex digit or similar.
				*Dest = N.rem - 10 + 'a';
			else
				*Dest = N.rem + '0';
		}
	}

	while( Digits--) {
		if( Base > 10) {
			if( Digits == 0)
				*Dest = '.';
			else if (Digits == 1)	// Prefix ".x" instead of the more common "0x"
				*Dest = 'x';		// makes printing columns with numbers more compact.
			else
				*Dest = '0';		// Hex digits always filled with zero's.
		}
		else
			*Dest = ' ';

		Dest --;
	}
}
void init_adc()
{
	ADMUX = 0x00;					// Select Channel
	ADMUX = ADMUX | 0x40; 		// Selecting voltage reference
	ADMUX = ADMUX | 0x20;  		// Selecting Justification result
	ADCSRA = 0x07;					// Select Clock Frequency
	ADCSRA = ADCSRA | 0x80; 	// Enable ADC
}

unsigned char read_adc()		// Reading ADC and Returns a value
{
	unsigned char a;
	ADCSRA =ADCSRA | 0x40; 		// Starting Conversion
	while((ADCSRA & 0x10)==0);	// Wait for conversion to complete
	a=ADCH;							// Only read 8 bits
	ADCSRA = ADCSRA | 0x10;		// clearing the flag
	return a;
}
		ADC = read_adc();
		lcd_write_int(ADC);
void lcd_write_string(uint8_t String[])
{
	int i = 0;                             // character counter*/
	while (String[i] != 0)
	{
		lcd_write_char(String[i]);
                i++;
	}
}

void lcd_write_int(long data)
{
	char st[10];
	ltoa(data,st,10);
	lcd_write_string(st);
}
		ADC = read_adc();
		lcd_write_int(ADC);
void lcd_write_string(uint8_t String[])
{
	int i = 0;                             // character counter*/
	while (String[i] != 0)
	{
		lcd_write_char(String[i]);
                i++;
	}
}

void lcd_write_string(uint8_t *String)
{
	while (*String)
	{
		lcd_write_char(*String++);
	}
}

void init_adc();

MAIN PROGRAM
	read_adc();
	lcd_write_int(ADC);	      

void init_adc()
{
	ADMUX = 0x00;					// Select Channel
	ADMUX = ADMUX | 0x40; 		// Selecting voltage reference
	ADMUX = ADMUX | 0x20;  		// Selecting Justification result
	ADCSRA = 0x07;					// Select Clock Frequency
	ADCSRA = ADCSRA | 0x80; 	// Enable ADC
}

void read_adc()		// Reading ADC and Returns a value
{
	ADCSRA =ADCSRA | 0x40; 		// Starting Conversion
	while((ADCSRA & 0x10)==0);	// Wait for conversion to complete
	ADCSRA = ADCSRA | 0x10;		// clearing the flag
}

../LCD_Ver1.c:144: warning: return type defaults to 'int'

void init_adc(void);
int read_adc(uint8_t chan);

MAIN PROGRAM
	lcd_write_int(read_adc(0));	      

void init_adc(void)
{
	ADMUX = 0x00;					// Select Channel
	ADMUX = ADMUX | 0x40; 		// Selecting voltage reference
	ADMUX = ADMUX | 0x20;  		// Selecting Justification result
	ADCSRA = 0x07;					// Select Clock Frequency
	ADCSRA = ADCSRA | 0x80; 	// Enable ADC
}

int read_adc(uint8_t chan)		// Reading ADC and Returns a value
{
    ADMUX = chan | 0x60;
	ADCSRA = ADCSRA | 0x40; 		// Starting Conversion
	while((ADCSRA & 0x10)==0);	// Wait for conversion to complete
	ADCSRA = ADCSRA | 0x10;		// clearing the flag
        return ADC;
}
int tov_check(int);
int cntH;

/******************************* Main Program Code *************************/
int main(void)
{
   intH=0;  // Initial Value
   while(1)   
   {
	while(!(PIND & (1<<PD0)))      // wait for rising edge
	{
		cntH=50;
		tov_check(cntH);
		lcd_write_long(cntH);
		//code
	}
	while((PIND & (1<<PD0)))  	        // wait for falling edge
	{
	    //code
	}
    }
}

int tov_check(int data)
{
   data++;
   return(data);
}
cntH = tov_check(cntH);
void lcd_write_long(long);

/******************************* Main Program Code *************************/
int main(void)
	CODE
	cntH=100000;
	lcd_write_long(cntH);

}

void lcd_write_long(long data)
{
	char st[50];
	ltoa(data,st,10);
	lcd_write_string(st);
}
	lcd_write_string("100000");
void lcd_write_long(long data)
{
	data = 1000000
        char st[50];
	ltoa(data,st,10);
	lcd_write_string(st);
}
//Pass by value:
uint32_t a = 10;

    incval(a);      //this effectively does nothing
    a = incval(a);  //this increments a as we assign a value back to it

uint32_t incval( uint32_t val)
{
    val++;
}

//Pass by reference:
uint32_t a = 10;

    incval(&a);         // & is the 'address of' a
    //a now equals 11

void incval(uint32_t *val)
{
    *val++;
}
void lcd_write_int(unsigned int data)
#define val_lo	r22
#define str_lo	r20
#define rdx_lo	r18
#define rdx_hi	r19

ENTRY	ltoa
ENTRY	__ltoa

	cpi	rdx_lo, 37
	cpc	rdx_hi, __zero_reg__
	brsh	1f
	cpi	rdx_lo, 2
	brlo	1f
	XJMP	_U(__ltoa_ncheck)

1:	X_movw	ZL, str_lo
	st	Z, __zero_reg__
	X_movw	r24, str_lo
	ret

#define val_lo	r22
#define val_hi	r23
#define val_hlo	r24
#define val_hhi	r25
#define str_lo	r20
#define rdx_lo	r18

#define sign	r27	/* Argument for __ultoa_common()	*/

ENTRY	__ltoa_ncheck

	clr	sign
	cpi	rdx_lo, 10
	brne	1f
	tst	val_hhi
	brpl	1f

    ; radix == 10 && val < 0: sign = '-' and val = -val
	ldi	sign, '-'
	com	val_hhi
	com	val_hlo
	com	val_hi
	neg	val_lo
	sbci	val_hi, -1
	sbci	val_hlo, -1
	sbci	val_hhi, -1
1:	XJMP	_U(__ultoa_common)

#define val_lo	r22
#define val_hi	r23
#define val_hlo	r24
#define val_hhi	r25
#define str_lo	r20
#define radix	r18

#define counter	r19
#define digit	r26
#define sign	r27

ENTRY	__ultoa_ncheck
	clr	sign

ENTRY	__ultoa_common
	X_movw	ZL, str_lo

1:  ; Saves one iteration of the digit-loop:
    ; If val < radix we can use the low byte of val as digit
	mov	digit, val_lo
	cp	val_lo, radix
	cpc	val_hi, __zero_reg__
	cpc	val_hlo, __zero_reg__
	cpc	val_hhi, __zero_reg__
    ; now C is set, if val < radix
	sbc	counter, counter
	bst	counter, 0
	brts	4f
    ; counter == 0 here

    ; If val >= radix, then pop one digit from val
	clr	digit

2:  ; Vanilla 32:8 quotient and remainder to pop the digit
    ; digit <- val % radix
    ; val   <- val / radix
	lsl	val_lo
	rol	val_hi
	rol	val_hlo
	rol	val_hhi
	rol	digit
	cp	digit, radix
	brlo	3f
	sub	digit, radix
    ; val |= 1
	inc	val_lo
3:  ; Loop the 32 bits
	subi	counter, 8		; 256 / 8 == 32 loops
	brne	2b

4:  ; Convert the digit to ASCII...
	subi	digit, -'0'
	cpi	digit, '9'+1
	brlo	5f
	subi	digit, '0'-'a'+10
5:  ; ... and store it to the reversed string
	st	Z+, digit

    ; Popped all digits?
	brtc    1b

    ; Yes:  Store the sign (if any)
	cpse	sign, __zero_reg__
	st	Z+, sign

    ; Terminate the string with '\0'
7:	st	Z, __zero_reg__

    ; Reverse the string and return the original string pointer
	X_movw	r24, str_lo
	XJMP	_U(strrev)
#include "macros.inc"

#define str_hi r25
#define str_lo r24
#define ltemp  r23
#define rtemp  r22

    ASSEMBLY_CLIB_SECTION
    .global _U(strrev)
    .type   _U(strrev), @function

_U(strrev):
	X_movw	XL, str_lo	; X is start of string
	X_movw	ZL, str_lo	; Z becomes end of string
  ; find end of string
1:	mov	rtemp, ltemp	; to obtain right nonzero character
	ld	ltemp, Z+
	tst	ltemp
	brne	1b
	sbiw	ZL, 2		; to last nonzero byte
	rjmp	3f
  ; swap bytes
2:	ld	ltemp, X
	st	X+, rtemp
	st	Z, ltemp
	ld	rtemp, -Z
3:	cp	XL, ZL
	cpc	XH, ZH
	brlo	2b

	ret
extern __inline__ __ATTR_GNU_INLINE__
char *ltoa (long __val, char *__s, int __radix)
{
    if (!__builtin_constant_p (__radix)) {
	extern char *__ltoa (long, char *, int);
	return __ltoa (__val, __s, __radix);
    } else if (__radix < 2 || __radix > 36) {
	*__s = 0;
	return __s;
    } else {
	extern char *__ltoa_ncheck (long, char *, unsigned char);
	return __ltoa_ncheck (__val, __s, __radix);
    }
}

_utoa(char *src, char *dst, char fill);
(unsigned int data)
 lsr r24        ;1/2
 mov r25,r24
 lsr r24        ;1/4
 adc r24,r25    ;3/4
 lsr r24        ;3/8
 lsr r24        ;3/16
 lsr r24        ;3/32
 adc r24,r25    ;19/32
 lsr r24        ;19/64
 adc r24,r25    ;51/64
 lsr r24        ;51/128
 lsr r24        ;51/256
 lsr r24        ;51/512

ldi	r17, 164
fmul	r16, r17
adc	r18, r18
add	r1, r1
adc	r18, r18
andi	r18, 3
ldi	r16, 10
mul	r16, r1
mov	r17, r1
mul	r16, r0
mov	r16, r1
#if	!defined (__AVR_TINY__)

#include "asmdef.h"

/* char *__utoa_ncheck (unsigned val, char *s, unsigned char radix)
   This function is the utoa() without checking the radix for 2..36 margins.
 */

#define val_lo	r24
#define val_hi	r25
#define str_lo	r22
#define radix	r20

#define counter	r21
#define digit	r26
#define sign	r27
                                                                // clock cycles
ENTRY	__utoa_ncheck
	clr	sign                                            // 1

ENTRY	__utoa_common
	X_movw	ZL, str_lo                                      // 1
	clr	counter                                         // 1

1:  ; Vanilla 16:8 quotient and remainder to pop the digit
    ; digit <- val % radix
    ; val   <- val / radix
	clr	digit                                           // 1

2:	lsl	val_lo                                          // 1
	rol	val_hi                                          // 1
	rol	digit                                           // 1
	cp	digit, radix                                    // 1
	brlo	3f                                              // 1/2
	sub	digit, radix                                    // 1
	inc	val_lo                                          // 1
3:	subi	counter, 16		; 256 / 16 == 16 loops  // 1
	brne	2b                                              // 1/2

    ; Convert the digit to ASCII...
	subi	digit, -'0'                                     // 1
	cpi	digit, '9'+1                                    // 1
	brlo	4f                                              // 1/2
	subi	digit, '0'-'a'+10                               // 1
4:  ; ... and store it to the reversed string
	st	Z+, digit                                       // 1(tiny/xmega)/2

    ; Iterate until all digits are sucked out of VAL.
	sbiw	val_lo, 0                                       // 2
	brne	1b                                              // 1/2

    ; Store the sign (if any)
	cpse	sign, __zero_reg__                              // 1/2
	st	Z+, sign                                        // 1(tiny/xmega)/2

    ; Terminate the string with '\0'
	st	Z+, __zero_reg__                                // 1(tiny/xmega)/2

    ; Reverse the string and return the original string pointer
	X_movw	r24, str_lo                                     // 1
	XJMP	_U(strrev)                                      // …

ENDFUNC

#endif	/* !__AVR_TINY__ */
/**
 \ingroup avr_stdlib

   \brief Convert an unsigned integer to a string.

   The function utoa() converts the unsigned integer value from \c val into an
   ASCII representation that will be stored under \c s.  The caller
   is responsible for providing sufficient storage in \c s.

   \note The minimal size of the buffer \c s depends on the choice of
   radix. For example, if the radix is 2 (binary), you need to supply a buffer
   with a minimal length of 8 * sizeof (unsigned int) + 1 characters, i.e. one
   character for each bit plus one for the string terminator. Using a larger
   radix will require a smaller minimal buffer size.

   \warning If the buffer is too small, you risk a buffer overflow.

   Conversion is done using the \c radix as base, which may be a
   number between 2 (binary conversion) and up to 36.  If \c radix
   is greater than 10, the next digit after \c '9' will be the letter
   \c 'a'.

   The utoa() function returns the pointer passed as \c s.
*/
#ifdef  __DOXYGEN__
extern char *utoa(unsigned int val, char *s, int radix);
#else
extern __inline__ __ATTR_GNU_INLINE__
char *utoa (unsigned int __val, char *__s, int __radix)
{
    if (!__builtin_constant_p (__radix)) {
	extern char *__utoa (unsigned int, char *, int);
	return __utoa (__val, __s, __radix);
    } else if (__radix < 2 || __radix > 36) {
	*__s = 0;
	return __s;
    } else {
	extern char *__utoa_ncheck (unsigned int, char *, unsigned char);
	return __utoa_ncheck (__val, __s, __radix);
    }
}
#endif

ENTRY	__utoa_ncheck
	clr	sign                                            // 1

    ; Store the sign (if any)
	cpse	sign, __zero_reg__                              // 1/2
	st	Z+, sign                                        // 1(tiny/xmega)/2

;multiply
ldi	r17, 164
fmul	r19, r17
adc	r18, r18

;shift
add	r0, r0
adc	r1, r1
adc	r18, r18

;rounding correction
ldi	r16, 0xFF
sub	r1, r16
sbc	r18, r16

;in case r18 was not cleared on entry
andi	r18, 3

;final multiplies for tens and units
ldi	r16, 10
mul	r16, r1
mov	r17, r1
mul	r16, r0
avr-libc-1.8.1$ grep -rIn fmul .
./include/avr/builtins.h:90:extern unsigned int __builtin_avr_fmul(unsigned char __a, unsigned char __b);
./include/avr/builtins.h:96:extern int __builtin_avr_fmuls(char __a, char __b);
./include/avr/builtins.h:102:extern int __builtin_avr_fmulsu(char __a, unsigned char __b);
./include/avr/builtins.h.in:90:extern unsigned int __builtin_avr_fmul(unsigned char __a, unsigned char __b);
./include/avr/builtins.h.in:96:extern int __builtin_avr_fmuls(char __a, char __b);
./include/avr/builtins.h.in:102:extern int __builtin_avr_fmulsu(char __a, unsigned char __b);

/* Macro 'X_movw' extends enhanced movw instruction for classic chips.
 */
.macro	X_movw	dst,src
#if  __AVR_HAVE_MOVW__
	movw	\dst,\src
#else
  REGNO	.L__movw_dst, \dst
  .if	.L__movw_dst < 0
    .exitm
  .endif
  .if	.L__movw_dst % 1
    .err	; Invalid dst arg in X_movw macro.
    .exitm
  .endif

  REGNO	.L__movw_src, \src
  .if	.L__movw_src < 0
    .exitm
  .endif
  .if	.L__movw_src % 1
    .err	; Invalid src arg in X_movw macro.
    .exitm
  .endif
	mov	.L__movw_dst, .L__movw_src
	mov	.L__movw_dst + 1, .L__movw_src + 1
#endif
.endm
#if !defined(__AVR_TINY__)
91516	40Hz
91516
91514
163443
146897
155983
117972
215110
215112
215114
215112
116696
170956
170959
170957
170957  20Hz
290749 <------- out of sequence
192329
192331
193355
128721 <--------
180942
180940
180940
180941
333496
426928 <------- out of sequence
426664
426669
189002
264769
579356
609680
692722
775762
858804
1007380  2 hz from now on the count just keeps increasing even though the input is still 2 hz.
1090422
1173464
1256505
1405082
1488122
1571164
1654204
1737245
1820286
1903328
2051905
2134947
2217988
2301029
2449606
2532647
2615689
2698729
2847306
2930347
3013389
3096430
3179471
3262513
3345553
3494131
3577173
3660213
3743255
3891832
3974873
4057914
4140955
4289532
4372573
4455615
4538655
/*
Read input pulse length using PD0
*/

#define F_CPU 16E6
#define USART_BAUDRATE 57600
#define F_BAUD_PRESCALE (((F_CPU/(USART_BAUDRATE*16UL)))-1)  // from manual

#include <avr/io.h>
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>

#define lcd_SetCursor   0x80    // set cursor position
#define lcd_Clear       0x01

// Functions
void lcd_write_nibble(uint8_t);
void lcd_write_inst(uint8_t);
void lcd_write_char(uint8_t);
void lcd_write_string(uint8_t *);
void lcd_write_long(long);
void lcd_init_4d(void);

void serial_init(unsigned int BAUD_PRESCALE);
void serial_send(char* data);

void init_timer1();
int tov_check(int);

unsigned char sndtime[20];
long cntL;
long cntH;
int edge;			// first occurrence
int i;				// pointer

/******************************* Main Program Code *************************/
int main(void)
{
	lcd_init_4d();        							// initialize the LCD display for a 4-bit interface
	timer1_init();
	serial_init(F_BAUD_PRESCALE);
	while(1)
   {
		edge=1;
		while (!(PIND & (1<<PD0)))      // stay in loop while positive signal
		{
			if (edge == 1)
			{
				TCNT1=0;    // Reset Timer
				cntH=0;
				edge=0;
			}
		 	cntH=tov_check(cntH);     // Count overflows
		}
		while ((PIND & (1<<PD0)))  	 // stay in loop while negative signal
		{
		 	cntH=tov_check(cntH);
		}
		if (!(PIND & (1<<PD0)))      // wait for rising edge
		{
			cntL=TCNT1;           // store timer
			lcd_write_inst(0x01);  // clear display
			lcd_write_inst(0x80);
			_delay_ms(2);
			lcd_write_inst(lcd_SetCursor | 0x00); 	// Line 1
			lcd_write_long(cntH);
			lcd_write_inst(lcd_SetCursor | 0x40); 	// Line 2
			lcd_write_long(cntL);
			cntL=cntL+(cntH<<16);                // Turn into Long
 			ltoa(cntL,sndtime,10);
			serial_send("SS");
			serial_send(sndtime);
			serial_send("EE");
		}
		_delay_ms(1000);
	}
}

void timer1_init()
{
    TCCR1A = 0x00; 								// Normal count Mode and waveform
    TCCR1B = (1 << CS11);						// CS12 and CS10 = 1 Prescaler 4
    TCNT1 = 0;										// Initalize
}

int tov_check(int data)
{
	if (TIFR1 & (1 << TOV1))
	{
		data++;
		TIFR1 = (1 << TOV1);
	}
	return(data);
}

// LCD Setup
void lcd_init_4d(void)
{
	DDRD = 0xF0;			// 4 data lines - output
	DDRB = 0x03;			// Control Lines

	_delay_ms(100);               // initial 40 mSec delay
	lcd_write_nibble(0x30);       // reset sequence
   _delay_ms(10);
	lcd_write_nibble(0x30);
	_delay_us(200);
	lcd_write_nibble(0x30);
	_delay_us(200);  

	lcd_write_inst(0x28);  // Set interface length = 4, Display Lines, Font 5x7
	_delay_us(80);
	lcd_write_inst(0x08);  // turn display OFF
	_delay_us(80);
	lcd_write_inst(0x01);  // clear display RAM
	_delay_ms(4);
	lcd_write_inst(0x06);  // shift cursor from left to right on read/write
	_delay_us(80);
	lcd_write_inst(0x0C);  // turn the display ON
	_delay_us(80);
}                                 

void lcd_write_inst(uint8_t inst)
{
	PORTB &= ~(1<<PORTB0);    		// select the inst Register (RS low)
	lcd_write_nibble(inst);       // write the upper 4-bits of the data
	lcd_write_nibble(inst << 4);  // write the lower 4-bits of the data
	_delay_us(80);
}

void lcd_write_char(uint8_t Data)
{
	PORTB |= (1<<PORTB0);      	// select the Data Register (RS high)
	lcd_write_nibble(Data);       // write the upper 4-bits of the data
	lcd_write_nibble(Data << 4);  // write the lower 4-bits of the data
	_delay_us(80);
}

void lcd_write_nibble(uint8_t theByte)
{
	if (theByte & 1<<7)
		PORTD |= (1<<PORTD7);   //Write 1 which is the actual data
	 else
	 	PORTD &= ~(1<<PORTD7);  //Write 0
	if (theByte & 1<<6)
		PORTD |= (1<<PORTD6);
	 else
	 	PORTD &= ~(1<<PORTD6);
	if (theByte & 1<<5)
		PORTD |= (1<<PORTD5);
	 else
	 	PORTD &= ~(1<<PORTD5);
	if (theByte & 1<<4)
		PORTD |= (1<<PORTD4);
	 else
	 	PORTD &= ~(1<<PORTD4);  

   PORTB &= ~(1<<PORTB1);      // make sure E is initially low
   _delay_us(1);
	PORTB |= (1<<PORTB1);       // Enable pin high
   _delay_us(1);
  	PORTB &= ~(1<<PORTB1);      // Enable pin low
    _delay_us(1);
}

void lcd_write_string(uint8_t String[])
{
	int i = 0;                             // character counter
	while (String[i] != 0)
	{
		lcd_write_char(String[i]);
      i++;
	}
}

void lcd_write_long(long data)
{
	char st[50];
	ltoa(data,st,10);
	lcd_write_string(st);
}

// Serial setup

void serial_init(unsigned int BAUD_PRESCALE)
{
	UBRR0H = (unsigned char)(BAUD_PRESCALE >> 8); 	//Upper 8-bits baud rate, Shift Right 8 times
	UBRR0L = (unsigned char)(BAUD_PRESCALE); 	 		//lower 8-bits.
	UCSR0B = (1 << RXEN0) | (1 << TXEN0); 				// Turn on the transmission and reception circuitry
	UCSR0C = (0 << USBS0) | (3 << UCSZ00); 			// Stop Bits =1  8-bit
}

void serial_send(char *data)   // send a string
{
   while(*data != 0)
   {
		while( !(UCSR0A & (1<<UDRE0))); 						// wait for empty transmit buffer.
		UDR0 = data[i] ;
      data++;
   }
}

int tov_check(int data)
		while ((PIND & (1<<PD0)))  	 // stay in loop while negative signal
		{
		 	cntH=tov_check(cntH);
		}

	Units	Avr2	Avr25	Avr4
atoi ("12345")	Flash bytes Stack bytes MCU clocks	82 (82) 2 155	78 (78) 2 149	74 (74) 2 149
atol ("12345")	Flash bytes Stack bytes MCU clocks	122 (122) 2 221	118 (118) 2 219	118 (118) 2 219


itoa (12345, s, 10)	Flash bytes Stack bytes MCU clocks	110 (110) 2 879	102 (102) 2 875	102 (102) 2 875
ltoa (12345L, s, 10)	Flash bytes Stack bytes MCU clocks	134 (134) 2 1597	126 (126) 2 1593	126 (126) 2 1593



sprintf_min (s, "%d", 12345)	Flash bytes Stack bytes MCU clocks	1224 (1112) 53 1841	1092 (982) 53 1694	1088 (978) 53 1689
sprintf (s, "%d", 12345)	Flash bytes Stack bytes MCU clocks	1614 (1502) 58 1647	1476 (1366) 58 1552	1454 (1344) 58 1547
sprintf_flt (s, "%e", 1.2345)	Flash bytes Stack bytes MCU clocks	3228 (3116) 67 2573	2990 (2880) 67 2311	2968 (2858) 67 2311

AVR Freaks

integer to string

Tags:

Search form

integer to string

Tags: