Minimalist A-go-go

As same as all of my previous creation, I myself feel I've almost fully utilise the function of tiny ATtiny10 SOT23-6 package and I completed "Super Tweezers" frequency and voltage measurement tweezers!

As I presented before, all of function is done by ultra tiny wonderful ATtiny10! I am not sure when is the next time but on the next time I will step forward from SOT23-6 to SOP8 or 14, a bit more larger scale one.

Actual operation can be found in the following movie... have fun!

I think it is quite close to "ultimate" application of tiny ATtiny10. Eventually two applications, frequency counter and digital volt meter is combined in just one code and its function can be switched by pushing switch ON or OFF as initial condition.

And my assembly code eventually ( already released at github) approaches to the limit of ATtiny10, 1024 bytes (1 kB)....

Segment   Begin    End      Code   Data   Used    Size   Use%
---------------------------------------------------------------
[.cseg] 0x000000 0x0003ae    942      0    942    1024  92.0%
[.dseg] 0x000040 0x000060      0      0      0      32   0.0%
[.eseg] 0x000000 0x000000      0      0      0       0      -

Who said ATtiny10 is "brain dead" ? In its data sheet we cannot find word I2C but we can add function as same as LED blinking. In addition, ATtiny10 has one 16 bit timer which can be driven by external clock. Naturally it will work as "frequency counter!" Here we have!

Actually I had some accumulation of AVR assembly for these two months and this code is easily written after I2C bitbang completion.This is quick coding and not optimised but as same as before dirty code is released on github.

My code occupies on flash as,

"ATtiny10" memory use summary [bytes]:
Segment   Begin    End      Code   Data   Used    Size   Use%
--------------------------------------------------------
[.cseg] 0x000000 0x000304    772      0    772    1024  
[.dseg] 0x000040 0x000060      0      0      0      32  
[.eseg] 0x000000 0x000000      0      0      0       0  

Actual operation can be found in the following movie... Have fun and let us believe "Tiny" power!

As I presented in the previous log, I2C supporting in ATtiny10 seems to be successful. This time I activate A/D converter of ATtiny10. Indeed, ATtiny10 supporting I2C LCD and A/D leads to super simple Voltage meter!!

Segment   Begin    End      Code   Data   Used    Size   Use%
--------------------------------------------------------
[.cseg] 0x000000 0x00038c    908      0    908    1024  
[.dseg] 0x000040 0x000060      0      0      0      32  
[.eseg] 0x000000 0x000000      0      0      0       0  

I2C interface is quite useful for extension of small MCU, because it just consume two pins (CLK and DAT). The case of Attiny10, it does not support by its hardware but indeed more than five years ago, some people and guys succeeded to implemented in C. For me, assembly seems to be more straightforward and I made the code from scratch.

Actually bitbang is a kind of "very fast LED blinking". If you can make LED blink program in some MCU, you will be able to implement I2C on it. For implementing it, for example, bit "1" and "0" coding is like this:

bit_high:
	ldi temp1, 0b00
	out PORTB, temp1
	rcall delay
	ldi temp1, 0b01
	out PORTB, temp1
	rcall delay
	ldi temp1, 0b11
	out PORTB, temp1
	rcall delay
	ldi temp1, 0b01
	out PORTB, temp1
	rcall delay
	ldi temp1, 0b00
	out PORTB, temp1
	rcall delay
	ret
	;cl=1 da=0
bit_low:
	ldi temp1, 0b00
	out PORTB, temp1
	rcall delay
	ldi temp1, 0b00
	out PORTB, temp1
	rcall delay
	ldi temp1, 0b10
	out PORTB, temp1
	rcall delay
	ldi temp1, 0b00
	out PORTB, temp1
	rcall delay
	ldi temp1, 0b00
	out PORTB, temp1
	rcall delay
	ret

Here PB0 is SDA and PB1 is SCL of I2C. It is LED blinking, isn't it? If you have logic analyser (not expensive one but just a handy USB based analyser, in my case...) , actual timing and logic level can be confirmed and quite useful for completing bitbang.

Segment   Begin    End      Code   Data   Used    Size   Use%
--------------------------------------------------------
[.cseg] 0x000000 0x0001e6    486      0    486    1024  
[.dseg] 0x000040 0x000060      0      0      0      32  
[.eseg] 0x000000 0x000000      0      0      0       0  

Actual operation can be found in the following movie.. have fun!

So my lovely ATtiny10 is capable of processing lots job and at this moment, I have no complaint about its processing speed. But I noticed the default clock speed is 1MHz, internal RC oscillator (8MHz) divided by 8. This is no novelty but I would summarise how to set it to 8MHz and even beyond by OSCCAL register.

.def R_TEMP1, R16	
; setting clock divider change enable
        LDI R_TEMP1, 0xD8
	OUT CCP, R_TEMP1
; selecting internal 8MHz oscillator
	LDI R_TEMP1, 0x00
	OUT CLKMSR, R_TEMP1
	LDI R_TEMP1, 0xD8
	OUT CCP, R_TEMP1
; setting clock divider change enable
LDI R_TEMP1, (0<<CLKPS3)+(0<<CLKPS2)+(0<<CLKPS1)+(0<<CLKPS0);
OUT CLKPSR, R_TEMP1; set to 8MHz clock (disable div8)

Just in order to change clock divider from 8 (default) to 1, these processes are required. Putting 0xD8 to CCP register is required each step of CLKMSR and CLKPSR. Just inserting these code, the clock will be set to 8MHz.

More another way to speed bump or up is usage of OSCCAL register. In data sheet, we can see

the clock speed varies from 4 MHz up to around 15 MHz. I was a bit afraid of this modification since it may forget original calibrated number for OSCCAL by touching it but the OSCCAL is restored if our code does not touch OSCCAL.

OSCCAL can be touched as follows.

LDI R_TEMP1, 0xFF
; overclock (from 4MHz(0x00) to 15 MHz(0xFF))
OUT OSCCAL, R_TEMP1

Actual operation can be found in the following movie (as an example by LED blinking..) Have fun!

I would put very short update, regarding my PWM trial

Corresponding ASM code is as follows. Indeed I greatly refer the C code at avrfreak and tried to convert to assembler by myself (so such a redundant code, ;-)

.def temp1 = R16
.def temp2 = R17
.def count_L = R18
.def count_H = R19
.def final_L = R20
.def final_H = R21
.def temp3 = R22
.def temp4 = R23
.def temp5 = R24
.def temp6 = R25
.equ topnum = 1000
.equ count_start = 0xff
.equ count_end = 0x01
.equ subnum = 0x01
; Replace with your application code
setup:
	ldi temp1, (1<<PB0)+(1<<PB1);
	out DDRB, temp1
	ldi temp1, (1<<COM0A1)+(1<<COM0B1)+(1<<WGM01);
	out TCCR0A, temp1
	ldi temp1, low(topnum);1111101000
	out ICR0L, temp1
	ldi temp1, byte2(topnum)
	out ICR0H, temp1
	ldi temp1,(1<<CS01)+(1<<WGM03)+(1<<WGM02)
	out TCCR0B, temp1

start:
    ;inc r16
	ldi count_L, 0
	ldi count_H, 0
	ldi final_L, low(topnum)
	ldi final_H, byte2(topnum)
	ldi temp1, 0x01
	ldi temp2, 0x00
loop1:
	add count_L, temp1
	adc	count_H, temp2
	out OCR0AL, count_L
    out OCR0AH, count_H

	mov temp3, count_L
	mov temp4, count_H
	ldi temp5, low(topnum)
	ldi temp6, byte2(topnum)
	sub temp5,temp3
	sbc temp6,temp4
	out OCR0BL,	temp5
	out OCR0BH, temp6
	rcall delay
	cp final_H, count_H
	cpc final_L, count_L
	brne loop1
    rjmp start


delay:	; subroutine DELAY
	ldi	temp3, count_end
	ldi	temp4, count_start
	ldi	temp5, subnum
counter:
	sub	temp4, temp5
	cpse	temp4, temp3
	rjmp counter	
	ret

Fortunately I got very recent ATmel MCU ATtiny102 and quickly tried to program RGB LED blinking through ATmel Studio. I found several differences from conventional 8-pin AVRs in every aspect.

So far, 8-pin AVR was programmed by SPI (MOSI/MISO/CLK/RESET..) but this new 102 accept only TPI, which is same as ATtiny10.

(2) Pin assign is completely different!!!

As shown in the above picture ATtiny102 (up) has 1-pin VCC and 8-pin GND. This is totally different from conventional pin assign (which was totally pin compatible in 8-pin AVR series, ATtiny 13 to 85). We need a bit care for initial prototyping test.

(3) New 102 has two output ports PORTA and PORTB

I guess, ATmel uses same chip for 102 and 104 (simply most of ports are not wired in 102) and as a result 102 has two ports. This means, little source modification is required from conventional 8-pin AVR to 102.

(4) Additional voltage reference (1.1 V, 2.2 V, 4.3 V) for A/D converter

Voltage reference can be selected by REFS1 and REFS0 in ADMUX. Some ATtiny has 1.1 and 2.56 V reference but they has some limitation, requiring external capacitor. But the case of 102/104, it is completely free of charge.

(5) USART and USARTSPI (functions exclusive) supported

Not bit-banged but serial and SPI (one of them) are supported..

As for programming, ATmel Studio has already supported ATtiny102/104 and we don't need to wait for something.

Actual operation can be found in the following movie...

And I am trying even more smaller MCU, ATtiny 10, actually its size is identical to general switching transistor. But even in such a small package, it has 4ch 8bit A/D converter with 1024 words flash memory. 6pin is not enough to support full SPI writing but there is a special way, TPI (details can be found in websites) but we don't need to worry about TPI. ATmel Studio with Atmel ICE fully supports its programming.

Here is actual prototype board putting ATtiny10 for 6-pin dip break out. On the surface....

This is a actual wiring information between ATtiny10 and ATmel ICE. MOSI has no connection but binary transfer is supported by Atmel Studio.

The following simple assembly code enables tiny voltage indicator...

.def r_temp1 = R16
.def r_temp2 = R17
.def r_temp3 = R18

.equ lv_1 = 0x40 ; values for voltage comparison
.equ lv_2 = 0x80
.equ lv_3 = 0xC0

setup:                
ldi	r_temp1, ((1<<ADEN)+(1<<ADSC)+(1<<ADATE)+(1<<ADIE)+(0<<ADIF)+(1<<ADPS2)+(1<<ADPS1)+(1<<ADPS2))
out   ADCSRA,r_temp1       
;starting A/D conversion (free running mode)
ldi	r_temp1, ((1<<MUX1)+(0<<MUX0)) ; input A/D = PB2
out   ADMUX,r_temp1
; setting PB2 for A/D input
ldi	r_temp1, ((0<<DDB2)+(1<<DDB1)+(1<<DDB0))
; PB0 and 1 are LED out
out	DDRB, r_temp1 
; PB0, 1 for LED output (PB2 for input)

main: ; main loop start!
in    r_temp1,ADCL        
;reading lower bit of A/D result

cpi r_temp1, lv_1 ; comparing measured result with lv_1=0x2b
brlo s_vchk_1 ; if the measured value is lower than 0x40, jump to s_vchk_10

cpi r_temp1, lv_2 ; comparing measured result with lv_2=0x80
brlo s_vchk_2

cpi r_temp1, lv_3 ; comparing measured result with lv_3=0xC0
brlo s_vchk_3

rjmp main ; closing main loop

s_vchk_1:
	ldi r_temp3, 0x00 ;all LED are off (positive logic)
	out PORTB, r_temp3
	ret ; return to main loop

s_vchk_2:
	ldi r_temp3, 0b00001 ;PB0 is on
	out PORTB, r_temp3
	ret ; return to main loop


s_vchk_3:
	ldi r_temp3, 0b00011 ; PB0, 1 are on
	out PORTB, r_temp3
	ret ; return to main loop

"ATtiny10" memory use summary [bytes]:
Segment   Begin    End      Code   Data   Used    Size   Use%
---------------------------------------------------------------
[.cseg] 0x000000 0x00002e     46      0     46    1024   4.5%
[.dseg] 0x000040 0x000060      0      0      0      32   0.0%
[.eseg] 0x000000 0x000000      0      0      0       0      -
Assembly complete, 0 errors. 0 warnings

Actual operation can be found in the following movie... have fun!

I am still in wonderful Attiny world, where I have learned lots of fundamentals of computer itself. This time I made a very simple and primitive voltage indicator by LEDs utilising A/D converter of ATtiny13.

As it is, ATtiny is 8-pin MCU and VCC, GND and RST ( I am still beginner, and cannot hand it away) total 3-pins are already occupied. So I used the rest 5 pins as, PB3 (pin 2) for A/D input and LEDs are driven by 4-pins by PB0, 1, 2, and 4. I am enjoying assembly language, since I can see and understand very fundamentals and the code is written by AVR assembly as follows.

;
; webADCattiny13.asm
;
; Created: 4/1/2016 12:52:26 PM
; Author : kodera2t
;
.def r_temp1 = R16
.def r_temp2 = R17
.def r_temp3 = R18

.equ lv_1 = 0x2b ; values for voltage comparison
.equ lv_2 = 0x56
.equ lv_3 = 0x81
.equ lv_4 = 0xac
.equ lv_5 = 0xd7
    
setup:                
ldi r_temp1, ((1<<ADEN)+(1<<ADSC)+(1<<ADATE)+(1<<ADIE)+(0<<ADIF)+(1<<ADPS2)+(1<<ADPS1)+(1<<ADPS2))
out ADCSRA,r_temp1 ;starting A/D conversion 
                     ;(free running mode)
;ldi r_temp1, ((0<<REFS0)+(0<<ADLAR)+(1<<MUX1)+(1<<MUX0))
;Vcc as analogue reference (currently commented out)
ldi r_temp1, ((1<<REFS0)+(0<<ADLAR)+(1<<MUX1)+(1<<MUX0))
;internal 1.1V as analogue reference
out ADMUX,r_temp1 ; setting PB3 for A/D input
ldi r_temp1, (1<<DDB4)+(0<<DDB3)+(1<<DDB2)+(1<<DDB1)+(1<<DDB0)
out DDRB, r_temp1 
; PB0, 1, 2, 4 for LED output (PB3 for input)

main: ; main loop start!
in r_temp1,ADCL ;reading lower bit of A/D result
in r_temp2,ADCH ;this program uses lower 8 bits only, therefore the comparing results will be periodical for input voltage variation

cpi r_temp1, lv_1 ;comparing measured result with lv_1=0x2b
brlo s_vchk_1 ; if the measured value is lower than 0x2b, jump to s_vchk_10

cpi r_temp1, lv_2 ;comparing measured result with lv_1=0x56
brlo s_vchk_2

cpi r_temp1, lv_3 ;comparing measured result with lv_1=0x81
brlo s_vchk_3

cpi r_temp1, lv_4 ;comparing measured result with lv_1=0xac
brlo s_vchk_4

cpi r_temp1, lv_5 ;comparing measured result with lv_1=0xd7
brlo s_vchk_5

rjmp main ; closing main loop

s_vchk_1:
ldi r_temp3, 0b10111 ;all LED are off (negative logic)
out PORTB, r_temp3
ret ; return to main loop

s_vchk_2:
ldi r_temp3, 0b10110 ;PB0 is on
out PORTB, r_temp3
ret ; return to main loop


s_vchk_3:
ldi r_temp3, 0b10100 ; PB0, 1 are on
out PORTB, r_temp3
ret ; return to main loop

s_vchk_4:
ldi r_temp3, 0b10000 ; PB0, 1, 2 are on
out PORTB, r_temp3
ret ; return to main loop
	
s_vchk_5:
ldi r_temp3, 0b00000; all LED are on
out PORTB, r_temp3
ret ; return to main loop