The following is a compendium of inline assembly functions dealing with ports and pins. Use these at your own risk. These functions have been trimmed of most bounds checking, so they can easily be abused. The Arduino Inline Assembly Tutorial explains most of the details starting here.
analogWrite
This inline code writes an analog value (in the form of a PWM wave) to a particular pin. After executing, the pin will generate a steady square wave of the specified duty cycle until the next call (or call to digitalRead() or digitalWrite() on the same pin). The frequency of the PWM signal on most pins is approximately 490 Hz. On the Uno and similar boards, pins 5 and 6 have a frequency of approximately 980 Hz. On Arduino boards with the ATmega168/328, this function works on pins 3, 5, 6, 9, 10, and 11. The analogWrite function has nothing to do with the analog pins or the analogRead function.
A pinMode() call is included inside this function, so there is no need to set the pin as an output before executing this code.
This version of AnalogWrite, with no frills saves ~542 bytes over the built-in function:
//analogWrite requires a PWM pin
//PWM pin/timer table:
//3: (TIMER2B) PD3/TCCR2A/COM2B1/OCR2B
//5: (TIMER0B) PD5/TCCR0A/COM0B1/OCR0B
//6: (TIMER0A) PD6/TCCR0A/COM0A1/OCR0A
//9: (TIMER1A) PB1/TCCR1A/COM1A1/OCR1A
//10: (TIMER1B) PB2/TCCR1A/COM1B1/OCR1B
//11: (TIMER2A) PB3/TCCR2A/COM2A1/OCR2A
//set below 6 defines per above table
#define ANALOG_PORT PORTB
#define ANALOG_PIN PORTB3
#define ANALOG_DDR DDRB
#define TIMER_REG TCCR2A
#define COMPARE_OUTPUT_MODE COM2A1
#define COMPARE_OUTPUT_REG OCR2A
volatile uint8_t val = 128; //0-255
asm (
"sbi %0, %1 \n" //DDR set to output (pinMode)
"cpi %6, 0 \n" //if full low (0)
"breq _SetLow \n"
"cpi %6, 0xff \n" //if full high (0xff)
"brne _SetPWM \n"
"sbi %2, %1 \n" //set high
"rjmp _SkipPWM \n"
"_SetLow: \n"
"cbi %2, %1 \n" //set low
"rjmp _SkipPWM \n"
"_SetPWM: \n"
"ld r24, X \n"
"ori r24, %3 \n"
"st X, r24 \n" //connect pwm pin timer# & channel
"st Z, %6 \n" //set pwm duty cycle (val)
"_SkipPWM: \n"
: : "I" (_SFR_IO_ADDR(ANALOG_DDR)), "I" (ANALOG_PIN),
"I" (_SFR_IO_ADDR(ANALOG_PORT)), "M" (_BV(COMPARE_OUTPUT_MODE)),
"x" (_SFR_MEM_ADDR(TIMER_REG)), "z" (_SFR_MEM_ADDR(COMPARE_OUTPUT_REG)), "r" (val)
: "r24"
);
analogRead
The Arduino board contains a 6 channel, 10-bit analog to digital converter which is the brains beneath the analogRead function. It maps input voltages between 0 and 5 into integer values between 0 and 1023, thus yielding a resolution between readings of: 5/1024 units or, 0.0049 volts (4.9 mV) per unit. The input range and resolution can be changed through the ANALOG_V_REF define. This code reads the value from the specified analog channel (0-7), which correspond to the analog pins (note, do NOT use A0-A7 for the channel number in this code). Further information about the underlying ADC can be found here.
While this version of analogRead (aRead) saves a few bytes (~50), it also gives the option of changing the speed via the ADC prescaler. However, don’t arbitrarily change the prescale without understanding the consequences. ATMEL advises the slowest prescale should be used (PS128). A higher speed (smaller prescale) reduces the accuracy of the AD conversion. The arduino sets the prescale to 128 during initiation, just as the code below does.
//Define various ADC prescales
#define PS2 (1<<ADPS0) //8000kHz ADC clock freq
#define PS4 (1<<ADPS1) //4000kHz
#define PS8 ((1<<ADPS0) | (1<<ADPS1)) //2000kHz
#define PS16 (1<<ADPS2) //1000kHz
#define PS32 ((1<<ADPS2) | (1<<ADPS0)) //500kHz
#define PS64 ((1<<ADPS2) | (1<<ADPS1)) //250kHz
#define PS128 ((1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0)) //125kHz
#define ANALOG_V_REF DEFAULT //INTERNAL, EXTERNAL, or DEFAULT
#define ADC_PRESCALE PS128 //PS16, PS32, PS64 or P128(default)
uint16_t aRead(uint8_t channel) {
uint16_t result;
asm (
"andi %1, 0x07 \n" //force pin==0 thru 7
"ori %1, (%6<<6) \n" //(pin | ADC Vref)
"sts %2, %1 \n" //set ADMUX
"lds r18, %3 \n" //get ADCSRA
"andi r18, 0xf8 \n" //clear prescale bits
"ori r18, ((1<<%5) | %7) \n" //(new prescale | ADSC)
"sts %3, r18 \n" //set ADCSRA
"_loop: \n" //loop until ADSC cleared
"lds r18, %3 \n"
"sbrc r18, %5 \n"
"rjmp _loop \n"
"lds %A0, %4 \n" //result = ADCL
"lds %B0, %4+1 \n" //ADCH
: "=r" (result) : "r" (channel), "M" (_SFR_MEM_ADDR(ADMUX)),
"M" (_SFR_MEM_ADDR(ADCSRA)), "M" (_SFR_MEM_ADDR(ADCL)),
"I" (ADSC), "I" (ANALOG_V_REF), "M" (ADC_PRESCALE)
: "r18"
);
return result;
}
pinMode(OUTPUT)
The arduino pinMode function configures pin behavior. The code presented from here on, has been previously explained inside the Arduino Inline Tutorial Series.
asm (
"sbi %0, %1 \n" //1=OUTPUT
: : "I" (_SFR_IO_ADDR(DDRB)), "I" (DDB5)
);
pinMode (INPUT PULLUP)
asm (
"cbi %0, %2 \n"
"sbi %1, %2 \n"
: : "I" (_SFR_IO_ADDR(DDRB)), "I" (_SFR_IO_ADDR(PORTB)), "I" (DDB5)
);
pinMode (INPUT)
asm (
"cbi %0, %2 \n"
"cbi %1, %2 \n"
: : "I" (_SFR_IO_ADDR(DDRB)), "I" (_SFR_IO_ADDR(PORTB)), "I" (DDB5)
);
pinMode with Multiple Pins
#define PIN_DIRECTION 0b00101000 //PIN 3 & 5 OUTPUT //#define PIN_DIRECTION (1<<DDB3) | (1<<DDB5) asm ( "out %0, %1 \n" : : "I" (_SFR_IO_ADDR(DDRB)), "r" (PIN_DIRECTION) );
digitalWrite HIGH
If a pin has been configured as an OUTPUT, its voltage will be set to the corresponding value: 5V (or 3.3V on 3.3V boards) for HIGH, 0V (ground) for LOW. However, if the pin is configured as an INPUT, digitalWrite enables (HIGH) or disables (LOW) the internal pullup on the input pin.
asm ( "sbi %0, %1 \n" : : "I" (_SFR_IO_ADDR(PORTB)),"I" (PORTB5) );
digitalWrite LOW
asm ( "cbi %0, %1 \n" : : "I" (_SFR_IO_ADDR(PORTB)), "I" (PORTB5) );
digitalWrite(output)
volatile uint8_t output = HIGH; //LOW or HIGH asm ( "cpi %2, 0 \n" "breq 1f \n" "sbi %0, %1 \n" "rjmp 2f \n" "1: cbi %0, %1 \n" "2: \n" : : "I" (_SFR_IO_ADDR(PORTB)), "I" (PORTB5), "r" (output) );
digitalToggle
Try to find this one in the Arduino wiring code:
//toggle pin asm ( "in r24, %0 \n" "eor r24, %1 \n" "out %0, r24 \n" : : "I" (_SFR_IO_ADDR(PORTB)), "r" ((uint8_t)_BV(PORTB5)) : "r24" );
digitalRead
digitalRead simply reads the value from a specified digital pin, either HIGH or LOW.
volatile uint8_t status; asm ( "in __tmp_reg__, __SREG__ \n" "cli \n" "ldi %0, 1 \n" //high "sbis %1, %2 \n" //skip next if pin high "clr %0 \n" //low "out __SREG__, __tmp_reg__ \n" : "=r" (status) : "I" (_SFR_IO_ADDR(PINB)), "I" (PINB5) );
digitalRead Alternative
This is a generic alternative, which can be called programmatically. Note it must be called using a pointer to the PIN (&PINB), otherwise the compiler emits incorrect code:
//call like so:
//uint8_t status = dRead(&PINB, PINB5);
__attribute__ ((noinline)) uint8_t dRead(volatile uint8_t *port, uint8_t pin) {
uint8_t result, mask=1;
asm (
"movw r30, %1 \n" //port reg addr in Z
"1: \n"
"cpi %2, 0 \n" //loop until pin==0
"breq 2f \n" //leave loop
"lsl %3 \n" //shift (mask) left 1 position
"dec %2 \n" //decrement loop counter
"rjmp 1b \n" //repeat
"2: \n"
"in __tmp_reg__, __SREG__ \n" //preserve sreg
"cli \n" //disable interrupts
"ld r18, Z \n" //fetch port data
"and r18, %3 \n" //compare pin with mask
"ldi %0, 1 \n" //set return high
"brne 3f \n"
"clr %0 \n" //set return low
"3: \n"
"out __SREG__, __tmp_reg__ \n"
: "=&r" (result) : "r" (port), "a" (pin), "r" (mask) : "r18", "r30", "r31"
);
return result;
}
Example of turning off PWM for arduino digital pin #11
//digital PWM pin registers: //3: (TIMER2B) PD3/TCCR2A/COM2B1/OCR2B //5: (TIMER0B) PD5/TCCR0A/COM0B1/OCR0B //6: (TIMER0A) PD6/TCCR0A/COM0A1/OCR0A //9: (TIMER1A) PB1/TCCR1A/COM1A1/OCR1A //10: (TIMER1B) PB2/TCCR1A/COM1B1/OCR1B //11: (TIMER2A) PB3/TCCR2A/COM2A1/OCR2A asm ( "ld r16, Z \n" "ldi r17, 0xff \n" "eor r17, %1 \n" "and r16, r17 \n" "st Z, r16 \n" : : "z" (_SFR_MEM_ADDR(TCCR2A)), "d" (COM2A1) : "r16", "r17" );
Also available as a book, with greatly expanded coverage!
[click on the image]
µC eXperiment 
thank you so much for sharing the code. i was looking for it.