Timer Time: Using Internal ATTiny13A Chip’s Timer, Automatic Mode, With Duty Cycle, and Phase Correction

The problem with the previous code is the phase, and it didn’t arise until we applied it on some ‘real’ hardware.

Some hardware, like motor DC, need a signal with fixed phase, even the frequency’s changed.

The previous code have the ‘center of wave’ that change according to OCR0A value. It’ll move forward on the small OCR0A value and vice versa. On application using LED, it’s enough, since the device ignore the phase.



Some hardware need a fixed center of wave.

We could do that by normally increasing TCNT0 counter, set the flag down when the value reached OCR0A value, counting up till 255, counting down with the flag still down till reached OCR0A value, set the flag up, continue to counting down to 0, counting up again… so on

Notice that one cycle need two step (count up, count down), naturally it has half speed time / or half frequency.

But the center of wave’s now fixed, in the beginning of the wave, :)

.include "../tn13Adef.inc"

.def a=r16

.org 0000

init:

sbi ddrb,0                  ; pin B0 as output

ldi a,0b10000001          ; Fast PWM mode 1 (Duty Cycle with Phase Correct Mode)

out TCCR0A,a

    

ldi a,0b00000101          ; pre-scaler /1024

out TCCR0B,a

    

    ldi a,8

    out OCR0A,a

loop:

rjmp loop

.

Timer Time: Using Internal ATTiny13A Chip’s Timer, Automatic Mode, With Duty Cycle

Now , how to set the duty cycle?

Uh, what’s duty cycle?

Well, our previous program have the LED output turned on and off with certain frequency. Of course.

But, how about set it up, so it will turn on for 1 ms and then turn off 0.5 ms, on 1 ms, off 0.5 ms and so on. Thus, the duration of high and low is different, that’s duty cycle, as far as I know, :)


And, we already have a weapon, the OCR0A, as a value where the high become low. Of course we have to set the timer to PWM Mode 3, so after the timer set the flag it will continue to 255 instead of reset the counter.

ldi a, 0b1000 0011
out TCCR0A,a


The Code:

.include "../tn13Adef.inc"

.def a=r16

.org 0000

init:

sbi ddrb,0                ; pin B0 as output

ldi a,0b10000011          ; Fast PWM mode 3 

out TCCR0A,a

    ldi a,0b00000101          ; pre-scaler /1024

out TCCR0B,a

    

    ldi a,2

    out OCR0A,a

loop:

rjmp loop

.

Timer Time: Using Internal ATTiny13A Chip’s Timer, CTC with Automatic Mode

What if we want it to do the task automatically? With neither interrupt routine nor call command?.

We could use CTC mode . The TCNT0 will start counting up, restarted to zero (and generate interrupt) if its value reaches OCR0A value (the compare value we set).

Since, in the matter of talking, the timer has its flag status on pin B0, if we set it as output, we could see the status (high/low, on off) via led connected to it and ground.  

Note that we don’t use ‘interrupt routine’ but the system’s still generate an interrupt.

.include "../tn13Adef.inc"

.def a=r16

.org 0000

init:

sbi ddrb,0              ; pinb as output 

ldi a,0b01000010        ; CTC mode

out TCCR0A,a

ldi r16,0b00000101      ; pre-scaler /1024

    out TCCR0B,a

    ldi a,200                ; compare value

    out OCR0A,a             

loop:

rjmp loop

####

Timer Time: Using Internal ATTiny13A Chip’s Timer, "OVF" Interrupt Mode (slightly modified)

We could speeding the timer by pre-loading TCNT0 with a value between 0 and 255, so TCNT0’ll start count at our own value instead of zero. 

We have to pre-load the TCNT0 at the init subroutine, and pre-load again after flag is set, so we write the command at the timer subroutine. 

So, our code now will look like this 

.include "../tn13Adef.inc"

.def a=r16

.org 0000

    rjmp init

.org 0003

    rjmp timer

init:

    sbi ddrb,0          ; pin b0 output

    ldi a,0b00000101    ; prescaler 1024

    out TCCR0B,a

    ldi a,0b00000010    ; enable OVF

    out TIMSK0,a

    ldi a, 64           ; preload TCNT0

    out TCNT0,a

    sei                 ; enable interrupts globally

    

main:

    rjmp main

timer:

    sbi pinb,0          ; flip pin B0 bit

    ldi a,64            ; preload again 

    out TCNT0,a

    reti

    

    

Timer Time: Using Internal ATTiny13A Chip’s Timer, "OVF" Interrupt Mode

Using interrupt, we have a subroutine that regularly called, automatically.

It called when overflow flag (OVF) is set.

As always, the timer/counter (TCNT0 register) counts up from zero toward 255, called an interrupt and rolls over back to zero and starts counts up again. 

We could set the output at the interrupt subroutine so we eventually have nothing to do at the main program.

main:
 rjmp main

If we enabled interrupts, the system looks an  interrupt vector table at the bottom of memory, .org 000; composed of jumps to routines series.

OVF interrupt located at .org 0003

The first interrupt is, of course, power on or reset or initial condition, you named it…

We have to jump to it (using rjmp init) to set initial condition of our system when it connected to power source, or reset-ed. On this program we set pre-scaler to 1024, enabling OVF mode and of course enabling interrupts globally

The interrupt routine itself is only consist of toggle pinb,0 command  

.include "../tn13Adef.inc"

.def a=r16

.org 0000

    rjmp init

.org 0003

    rjmp timer

init:

    sbi ddrb,0          ; pin b0 output

    ldi a,0b00000101    ; prescaler 1024

    out TCCR0B,a

    ldi a,0b00000010    ; enable OVF

    out TIMSK0,a

    sei                 ; enable interrupts globally

    

main:

    rjmp main

timer:

    sbi pinb,0          ; flip pin B0 bit

    reti

    

    

.

Timer Time: Using Internal ATTiny13A Chip’s Timer “CTC” Mode

Clear Timer on Compare (CTC) as its name suggests, will clear the flag if counter has same value with compare value. 

Thus, TCNT0 still count fram zero to 255, but if we set OCR0A on 64, timer will clear the flag at 64, restart counter to zero and count up again.

If we set OCR0A to 255, then it’ll behave like normal timer in 'Normal’ Mode.

If OCR0A value’s lower, then the delay time is faster/shorter.

Here's the code. OCF0A is compare flag, the bit-3 on TIFR0 register.

Notice that we have to set TCCR0A register to enable CTC mode; in Normal mode we don’t have to do that.

.include "../tn13Adef.inc"

.def a=r16

.org 0000

init:

    sbi ddrb,0          ; pin b0 output

    ldi a, 0b01000010   ; CTC mode

    out TCCR0A,a

    ldi a,0b00000101    ; prescaler 1024

    out TCCR0B,a

    ldi a,255           ; compare value (emulating normal mode, set to lower value for shorter d)

    out OCR0A,a

main:

    sbi pinb,0          ; flip the B0 bit

    rcall timer

    rjmp main

timer:

        loop:

    in a,TIFR0          ; wait 

    andi a, 0b00000100  ; (1<<OCF0A) is OCF0A 

    breq loop

    

    ldi a, 0b00000100   ; set OCF0A to 1 again after flagged

    out TIFR0,a

    

    ret

    

    

.

Timer Time: Using Internal ATTiny13A Chip’s Timer “Normal” Mode (Slightly Modified)

Our timer is static, it have to wait TCNT0 to count from 0 to 255 and then start over.

We could modify it so it count from x to 255 to make it count faster

so we need to pre-set/pre-load TCNT0 to some value

ldi a, 200
out TCNT0,a

With that, we could make the delay time faster. Set the TCNT0 to lower value for longer delay



We  need to modify it

.include "../tn13Adef.inc"
.def a=r16

.org 0000

init:
    sbi ddrb,0          ; pin b0 output
    ldi a,0b00000101    ; prescaler 1024
    out TCCR0B,a

    

main:
    sbi pinb,0          ; flip the B0 bit
    rcall timer

    ldi a,200           ; set lower for longer delay

    out TCNT0,a
    rjmp main

timer:
        loop:
    in a,TIFR0          ; wait 

    andi a, 0b00000010  ; (1<<TOV0) is TOV0 still 1 or flagged to 0?

    breq loop

    

    ldi a, 0b00000010   ; set TOV0 to 1 again after flagged

    out TIFR0,a

    

    ret

    

    

    

Timer Time: Using Internal ATTiny13A Chip’s Timer “Normal” Mode

Chip’s Internal Timer in ’Normal' mode will count from 0 to 255, set the overflow flag TOV0 to 0 and count again from 0 to 255, set the flag to 0 and so on. 

As usual, I used LED as output indicator on Port B0

We used 1024 for pre-scaler/divider value. Set the TCCR0B to 0000 0101

Note that we have to reset the overflow flag to 1 after timer count reached 255 (and set the flag to 0). 

Oh, by the way, the register/variable/things that count from 0 to 255 is called TCNT0. We didn’t touch it in the code this time, maybe next. 

.include "../tn13Adef.inc"

.def a=r16

.org 0000

init:

    sbi ddrb,0          ; pin b0 output

    ldi a,0b00000101    ; prescaler 1024

    out TCCR0B,a

    

main:

    sbi pinb,0          ; flip the B0 bit

    rcall timer

    rjmp main

timer:

        loop:

    in a,TIFR0          ; wait 

    andi a, 0b00000010  ; (1<<TOV0) is TOV0 still 1 or flagged to 0?

    breq loop

    

    ldi a, 0b00000010   ; set TOV0 to 1 again after flagged

    out TIFR0,a

    

    ret

    

    

Last login: Thu May 28 11:54:47 on ttys001
Nugrohos-MacBook-Air:~ nugroho$ cd attiny13a/timer/
Nugrohos-MacBook-Air:timer nugroho$ avra -o timerNormal.hex timerNormal.s 
AVRA: advanced AVR macro assembler Version 1.3.0 Build 1 (8 May 2010)
Copyright (C) 1998-2010. Check out README file for more info

   AVRA is an open source assembler for Atmel AVR microcontroller family
   It can be used as a replacement of 'AVRASM32.EXE' the original assembler
   shipped with AVR Studio. We do not guarantee full compatibility for avra.

   AVRA comes with NO WARRANTY, to the extent permitted by law.
   You may redistribute copies of avra under the terms
   of the GNU General Public License.
   For more information about these matters, see the files named COPYING.

Pass 1...
Pass 2...
done

Used memory blocks:
   Code      :  Start = 0x0000, End = 0x000B, Length = 0x000C

Assembly complete with no errors.
Segment usage:
   Code      :        12 words (24 bytes)
   Data      :         0 bytes
   EEPROM    :         0 bytes
Nugrohos-MacBook-Air:timer nugroho$ vavrdisasm timerNormal.s.hex 
   0: 9a b8       sbi $17, 0
   2: e0 05       ldi R16, 0x05
   4: bf 03       out $33, R16
   6: 9a b0       sbi $16, 0
   8: d0 01       rcall .+2 ; 0xc
   a: cf fd       rjmp .-6 ; 0x6
   c: b7 08       in R16, 0x38
   e: 70 02       andi R16, 0x02
  10: f3 e9       breq .-6 ; 0xc
  12: e0 02       ldi R16, 0x02
  14: bf 08       out $38, R16
  16: 95 08       ret 
Nugrohos-MacBook-Air:timer nugroho$ 
Nugrohos-MacBook-Air:timer nugroho$ avrdude -p t13 -P usb -c usbasp -B4 -n

avrdude: set SCK frequency to 187500 Hz
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e9007

avrdude: safemode: Fuses OK (H:FF, E:FF, L:6A)

avrdude done.  Thank you.

Nugrohos-MacBook-Air:timer nugroho$ avrdude -p t13 -P usb -c usbasp -B4 -U flash:w:timerNormal.s.hex 

avrdude: set SCK frequency to 187500 Hz
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e9007
avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: set SCK frequency to 187500 Hz
avrdude: reading input file "timerNormal.s.hex"
avrdude: input file timerNormal.s.hex auto detected as Intel Hex
avrdude: writing flash (24 bytes):

Writing | ################################################## | 100% 0.02s

avrdude: 24 bytes of flash written
avrdude: verifying flash memory against timerNormal.s.hex:
avrdude: load data flash data from input file timerNormal.s.hex:
avrdude: input file timerNormal.s.hex auto detected as Intel Hex
avrdude: input file timerNormal.s.hex contains 24 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.01s

avrdude: verifying ...
avrdude: 24 bytes of flash verified

avrdude: safemode: Fuses OK (H:FF, E:FF, L:6A)

avrdude done.  Thank you.

Nugrohos-MacBook-Air:timer nugroho$ 

.

And Finally the Breathing LED is Here, :)

Jonathan Ive style, Old Macbook Pro sleep indicator LED.

Using interrupt, fast PWM on ATTiny13A.

.include "../tn13Adef.INC" 

.def a = r16

.def b = r17

.def c = r18

.def d = r19

.org $0000              ; startup vector

    rjmp onReset

.org $0006              ; compare match vector

    rjmp Tim0CompA

onReset:

    ldi a, 1

    out OCR0A,a

    ldi b, 1

    ldi c, 0

    ldi d, 255

    

    sbi DDRB,0          ; port B0 as output

    

    ldi a, 0b10000011   ; pwm mode 3

    out TCCR0A, a

    

    ldi a, 0b00000011   ; divider 01/no 10/8 11/64 100/256 101/1024

    out TCCR0B,a

    

    ldi a, 0b0000100    ; enable compare interupt

    out TIMSK0,a

    

    sei

main:

    rjmp main

    

Tim0CompA:

    in a, OCR0A

    rjmp incdec

        switch:

    out OCR0A,a

    reti

incdec:

    sbrs b,0

    rjmp deca

    inc a

        back:

    cp a,c

    breq oneB

    cp a,d

    breq zeroB

        bBack:

    rjmp switch

    

    

deca:

    dec a

    rjmp back

    

oneB:

    ldi b,1

    rjmp bBack

zeroB:

    ldi b,0

    rjmp bBack

.

Flip the Bit

Maybe it's just me, but I recently realized that we have a handy feature on ATTiny13A for flip the value of the bit.


so instead of

sbic PINB,0
cbi PINB,0
sbi PINB,0

we could just use

sbi PINB,0

Saving some clocks, :)

Blinking LED using Interrupt on ATTiny13A

Here's the template

.include "../tn13Adef.INC" 

.def a=r16

.org $0000              ; startup vector

    rjmp onReset

.org $0006              ; compare match vector

    rjmp Tim0CompA

onReset:

    sbi DDRB,0          ; port B0 as output

    

    ldi a, 0b10000011   ; pwm mode 3

    out TCCR0A, a

    

    ldi a, 0b00000101   ; divider /1024

    out TCCR0B,a

    

    ldi a, 0b0000100    ; enable compare interrupt

    out TIMSK0,a

    

    sei

main:

    rjmp main

        

Tim0CompA:

    in a, OCR0A

    inc a

    out OCR0A,a

    reti

.

if we set divider to 8

    ldi a, 0b000000010   ; divider /8

    out TCCR0B,a

and edit the timer routine to

Tim0CompA:

    in a, OCR0A

    dec a

    out OCR0A,a

    reti

we'll get smoother PWM respond 

with prescaler 64



prescaler 256



with prescaler 64 and increasing OCR0A

Oscillating LED Blink Delay on ATTiny13A

Based on my ADC with PWM output program.

The expected result is the old school MacbookPro unibody sleep indicator LED;  Sir Jonathan Ive style, :)

The code below resulted on slow to fast to slow to fast... blinking LED

;based on ADC 
.include "../tn13Adef.INC" 
.def zero=r19
.def max=r20
.org $0000 
init: 
 ldi r17,0                        
  ldi r18,1 ;increment/decrement check
 ldi zero,0
 ldi max,255
 sbi   DDRB,0   
 ;ldi   R16,0b10000011
 ;out   TCCR0A,R16    ;fast pwm       
main:
 cpse r18,zero
 rjmp increment 
 rjmp decrement
back:
 cp r17,zero
 breq switchUp

 cp r17,max
 breq switchDown

switch:
     rcall delay          
     sbi   PINB,0         
     rjmp  main

increment:
 inc r17
 rjmp back

decrement:
 dec r17
 rjmp back

switchUp:
 ldi r18,1
 rjmp switch

switchDown:
 ldi r18,0
 rjmp switch

delay:  
 mov r16,r17
loopDelay:
 rcall pause
     dec r16
     brne loopDelay
     ret

pause:
 ldi r21,127
lpause: 
 dec r21
 brne lpause
 ret

Save it as timer2.s, build it using avra

Nugrohos-MacBook-Air:timer nugroho$ avra -o timer2.hex timer2.s 
AVRA: advanced AVR macro assembler Version 1.3.0 Build 1 (8 May 2010)
Copyright (C) 1998-2010. Check out README file for more info

   AVRA is an open source assembler for Atmel AVR microcontroller family
   It can be used as a replacement of 'AVRASM32.EXE' the original assembler
   shipped with AVR Studio. We do not guarantee full compatibility for avra.

   AVRA comes with NO WARRANTY, to the extent permitted by law.
   You may redistribute copies of avra under the terms
   of the GNU General Public License.
   For more information about these matters, see the files named COPYING.

Pass 1...
Pass 2...
done

Used memory blocks:
   Code      :  Start = 0x0000, End = 0x0019, Length = 0x001A

Assembly complete with no errors.
Segment usage:
   Code      :        26 words (52 bytes)
   Data      :         0 bytes
   EEPROM    :         0 bytes
Nugrohos-MacBook-Air:timer nugroho$ avra -o timer2.hex timer2.s 
AVRA: advanced AVR macro assembler Version 1.3.0 Build 1 (8 May 2010)
Copyright (C) 1998-2010. Check out README file for more info

   AVRA is an open source assembler for Atmel AVR microcontroller family
   It can be used as a replacement of 'AVRASM32.EXE' the original assembler
   shipped with AVR Studio. We do not guarantee full compatibility for avra.

   AVRA comes with NO WARRANTY, to the extent permitted by law.
   You may redistribute copies of avra under the terms
   of the GNU General Public License.
   For more information about these matters, see the files named COPYING.

Pass 1...
Pass 2...
done

Used memory blocks:
   Code      :  Start = 0x0000, End = 0x0019, Length = 0x001A

Assembly complete with no errors.
Segment usage:
   Code      :        26 words (52 bytes)
   Data      :         0 bytes
   EEPROM    :         0 bytes
Nugrohos-MacBook-Air:timer nugroho$ vavrdisasm timer2.s.hex 
   0: e0 10       ldi R17, 0x00
   2: e0 21       ldi R18, 0x01
   4: e0 30       ldi R19, 0x00
   6: ef 4f       ser R20
   8: 13 23       cpse R18, R19
   a: c0 08       rjmp .+16 ; 0x1c
   c: c0 09       rjmp .+18 ; 0x20
   e: 17 13       cp R17, R19
  10: f0 49       breq .+18 ; 0x24
  12: 17 14       cp R17, R20
  14: f0 49       breq .+18 ; 0x28
  16: d0 0a       rcall .+20 ; 0x2c
  18: 9a b0       sbi $16, 0
  1a: cf f6       rjmp .-20 ; 0x8
  1c: 95 13       inc R17
  1e: cf f7       rjmp .-18 ; 0xe
  20: 95 1a       dec R17
  22: cf f5       rjmp .-22 ; 0xe
  24: e0 21       ldi R18, 0x01
  26: cf f7       rjmp .-18 ; 0x16
  28: e0 20       ldi R18, 0x00
  2a: cf f5       rjmp .-22 ; 0x16
  2c: 2f 01       mov R16, R17
  2e: 95 0a       dec R16
  30: f7 f1       brne .-4 ; 0x2e
  32: 95 08       ret 
Nugrohos-MacBook-Air:timer nugroho$ 

upload using avrdude

Nugrohos-MacBook-Air:timer nugroho$ avrdude -p t13 -P usb -c usbasp -B4 -n

avrdude: set SCK frequency to 187500 Hz
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e9007

avrdude: safemode: Fuses OK (H:FF, E:FF, L:6A)

avrdude done.  Thank you.

Nugrohos-MacBook-Air:timer nugroho$ avrdude -p t13 -P usb -c usbasp -B4 -U flash:w:timer2.s.hex 

avrdude: set SCK frequency to 187500 Hz
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e9007
avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: set SCK frequency to 187500 Hz
avrdude: reading input file "timer2.s.hex"
avrdude: input file timer2.s.hex auto detected as Intel Hex
avrdude: writing flash (52 bytes):

Writing | ################################################## | 100% 0.04s

avrdude: 52 bytes of flash written
avrdude: verifying flash memory against timer2.s.hex:
avrdude: load data flash data from input file timer2.s.hex:
avrdude: input file timer2.s.hex auto detected as Intel Hex
avrdude: input file timer2.s.hex contains 52 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.02s

avrdude: verifying ...
avrdude: 52 bytes of flash verified

avrdude: safemode: Fuses OK (H:FF, E:FF, L:6A)

avrdude done.  Thank you.

Nugrohos-MacBook-Air:timer nugroho$ 

.

 .

Timer on ATTiny13A using Interrupt

 It started with this

.include "../tn13Adef.inc" 

.org 0000 

rjmp reset 

.org 0003 

rjmp timer

reset:

sbi ddrb,0           

ldi r16,0b00000101    

out tccr0b,r16

ldi r16,0b00000010    

out timsk0,r16

sei

loop:

ldi r16,(1<<SE)

out mcucr,r16

sleep

rjmp loop

timer:

sbi   pinb,0       

reti

Nugrohos-MacBook-Air:timer nugroho$ avra -o timer.hex timer.s 
AVRA: advanced AVR macro assembler Version 1.3.0 Build 1 (8 May 2010)
Copyright (C) 1998-2010. Check out README file for more info

   AVRA is an open source assembler for Atmel AVR microcontroller family
   It can be used as a replacement of 'AVRASM32.EXE' the original assembler
   shipped with AVR Studio. We do not guarantee full compatibility for avra.

   AVRA comes with NO WARRANTY, to the extent permitted by law.
   You may redistribute copies of avra under the terms
   of the GNU General Public License.
   For more information about these matters, see the files named COPYING.

Pass 1...
Pass 2...
done

Used memory blocks:
   Code      :  Start = 0x0000, End = 0x0000, Length = 0x0001
   Code      :  Start = 0x0003, End = 0x000F, Length = 0x000D

Assembly complete with no errors.
Segment usage:
   Code      :        14 words (28 bytes)
   Data      :         0 bytes
   EEPROM    :         0 bytes
Nugrohos-MacBook-Air:timer nugroho$ vavrdisasm timer.s.hex 
   0: c0 03       rjmp .+6 ; 0x8
   6: c0 0a       rjmp .+20 ; 0x1c
   8: 9a b8       sbi $17, 0
   a: e0 05       ldi R16, 0x05
   c: bf 03       out $33, R16
   e: e0 02       ldi R16, 0x02
  10: bf 09       out $39, R16
  12: 94 78       sei 
  14: e2 00       ldi R16, 0x20
  16: bf 05       out $35, R16
  18: 95 88       sleep 
  1a: cf fc       rjmp .-8 ; 0x14
  1c: 9a b0       sbi $16, 0
  1e: 95 18       reti 
Nugrohos-MacBook-Air:timer nugroho$ 

.

Serial Communication at ATTiny13A (#3)

Since we need to set the baud rate. We have to use either manual delay or timer interrupt.

For now, I am trying using manual delay.



Check whether the Pin B0 is blinking using this code

.include "../tn13Adef.inc"

.cseg

.org 0x00

ldi r16, 0b00000001

out ddrb,r16

loop:

ldi r17,0xff

ldi r18,0xff

sbi PORTB,0

rcall delay

cbi PORTB,0

rcall delay

rjmp loop

delay:

dec r17

brne delay

dec r18

brne delay

ret

yup, it is

Serial Communication at ATTiny13A (#2)

To send  bit data, we need 10 bit.

0(start)-8bit-1(stop) so r17 now has value 10

.include "../tn13Adef.inc" 

.cseg

.org 0x00

rjmp start 

start:

    ldi r16, 0x6D 

    ldi r17, 10 

shiftData:

    cpi r17, 10 

    breq low 

    cpi r17, 1

    breq high

    lsr r16

    brcs high

low:

    cbi PORTB, PB0 

    rjmp sent

high:

    sbi PORTB, PB0 

sent:

    dec r17 

    breq start 

    rjmp shiftData 

Nugrohos-MacBook-Air:serial nugroho$ avra -o serialTX.hex serialTX.s
AVRA: advanced AVR macro assembler Version 1.3.0 Build 1 (8 May 2010)
Copyright (C) 1998-2010. Check out README file for more info

   AVRA is an open source assembler for Atmel AVR microcontroller family
   It can be used as a replacement of 'AVRASM32.EXE' the original assembler
   shipped with AVR Studio. We do not guarantee full compatibility for avra.

   AVRA comes with NO WARRANTY, to the extent permitted by law.
   You may redistribute copies of avra under the terms
   of the GNU General Public License.
   For more information about these matters, see the files named COPYING.

Pass 1...
Pass 2...
done

Used memory blocks:
   Code      :  Start = 0x0000, End = 0x000E, Length = 0x000F

Assembly complete with no errors.
Segment usage:
   Code      :        15 words (30 bytes)
   Data      :         0 bytes
   EEPROM    :         0 bytes
Nugrohos-MacBook-Air:serial nugroho$ vavrdisasm serialTX.s.hex 
   0: c0 00       rjmp .+0 ; 0x2
   2: e6 0d       ldi R16, 0x6d
   4: e0 1a       ldi R17, 0x0a
   6: 30 1a       cpi R17, 0x0a
   8: f0 21       breq .+8 ; 0x12
   a: 30 10       cpi R17, 0x00
   c: f0 11       breq .+4 ; 0x12
   e: 95 06       lsr R16
  10: f0 10       brcs .+4 ; 0x16
  12: 98 c0       cbi $18, 0
  14: c0 01       rjmp .+2 ; 0x18
  16: 9a c0       sbi $18, 0
  18: 95 1a       dec R17
  1a: f3 99       breq .-26 ; 0x2
  1c: cf f4       rjmp .-24 ; 0x6
Nugrohos-MacBook-Air:serial nugroho$ 

.

Serial Communication ATTiny13A (#1)

ATTiny didn't come with TX/RX Pins, so I have to make it by myself. 

Got it from http://www.bot-thoughts.com/2012/12/attiny-software-serial-tx-in-assembly.html

Slightly modify it because avra didn’t compile it original source

.include "../tn13Adef.inc" ; definitions for ATtiny13A

.cseg

.org 0x00

rjmp start ; executed after reset

start:

    ldi r16, 0x6D ; 'm' 

    ldi r17, 8 ; put 8 in counter register

txloop:

    lsr r16 ; shift off the next bit, LSB first

    brcs Send1 ; if it is 1 (C=1) then send 1

Send0:

    cbi PORTB, PB0 ; send a 0=low

    rjmp BitDone

Send1:

    sbi PORTB, PB0 ; send a 1=high

BitDone:

    dec r17 ; bitcnt--

    breq start ; if bitcnt == 0, start over

    rjmp txloop ; else do the next bit

Build, compile and upload it

Nugrohos-MacBook-Air:serial nugroho$ avra -o serialTX.hex serialTX.s 

AVRA: advanced AVR macro assembler Version 1.3.0 Build 1 (8 May 2010)
Copyright (C) 1998-2010. Check out README file for more info

   AVRA is an open source assembler for Atmel AVR microcontroller family
   It can be used as a replacement of 'AVRASM32.EXE' the original assembler
   shipped with AVR Studio. We do not guarantee full compatibility for avra.

   AVRA comes with NO WARRANTY, to the extent permitted by law.
   You may redistribute copies of avra under the terms
   of the GNU General Public License.
   For more information about these matters, see the files named COPYING.

Pass 1...
Pass 2...
done

Used memory blocks:
   Code      :  Start = 0x0000, End = 0x000A, Length = 0x000B

Assembly complete with no errors.
Segment usage:
   Code      :        11 words (22 bytes)
   Data      :         0 bytes
   EEPROM    :         0 bytes
Nugrohos-MacBook-Air:serial nugroho$ 

Nugrohos-MacBook-Air:serial nugroho$ ls
serialTX.s  serialTX.s.eep.hex serialTX.s.obj
serialTX.s.cof  serialTX.s.hex  serialTX1.s
Nugrohos-MacBook-Air:serial nugroho$ avrdude -p t13 -c usbasp -P usb -B4 -n

avrdude: set SCK frequency to 187500 Hz
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e9007

avrdude: safemode: Fuses OK (H:FF, E:FF, L:6A)

avrdude done.  Thank you.

Nugrohos-MacBook-Air:serial nugroho$ avrdude -p t13 -c usbasp -P usb -B4 -U flash:w:serialTX.s.hex 

avrdude: set SCK frequency to 187500 Hz
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e9007
avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: set SCK frequency to 187500 Hz
avrdude: reading input file "serialTX.s.hex"
avrdude: input file serialTX.s.hex auto detected as Intel Hex
avrdude: writing flash (22 bytes):

Writing | ################################################## | 100% 0.02s

avrdude: 22 bytes of flash written
avrdude: verifying flash memory against serialTX.s.hex:
avrdude: load data flash data from input file serialTX.s.hex:
avrdude: input file serialTX.s.hex auto detected as Intel Hex
avrdude: input file serialTX.s.hex contains 22 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.01s

avrdude: verifying ...
avrdude: 22 bytes of flash verified

avrdude: safemode: Fuses OK (H:FF, E:FF, L:6A)

avrdude done.  Thank you.

Nugrohos-MacBook-Air:serial nugroho$ 

I use USB-to-TTL, and after several fail attempt to compile and upload using usbasp, I’m getting annoyed, so I use hc-05 (a bluetooth module) to communicate with ATTiny. Just connect the RX pin to PB0.

Nugrohos-MacBook-Air:serial nugroho$ screen /dev/cu.HC-05-DevB 

avr

modify it 

note that 

L1:     dec  r20

        brne L1

will generate error

Pass 1...

Abort trap: 6

edit it to 

L1:     

        dec  r20

        brne L1

not sure why avra refuse the first formatting

(of course the code above still won't work, it lacks the baud rate :) )