Current mirror

Given, a complicated darlington circuitry:
darlington
We now replace the darlington pairs with single NPN transistors by defining: I_C=I_B \cdot a with a=(\beta+1)\cdot\beta and I_E=I_B \cdot b with b=(\beta+1)^2
darlington_replacement

Now we set:
I_{KD} = I_{B1} + I_{C3} = I_{B1} + I_{B3} \cdot a and I_{RL}=I_{C4}=I_{B4}\cdot a and I_{B2}=I_{B5} and I_{KD} + I_{C1} + I_{RL} = I_{E5} + I_{E2}
I_{KD} + I_{B1} \cdot a + I_{RL} = I_{B5} \cdot b + I_{B2} \cdot b = 2\cdot I_{B5}\cdot b = 2\cdot I_{B2}\cdot b
\Rightarrow I_{RL}=- a \cdot I_{KD} - I_{KD} + a^2 \cdot I_{B3} + 2 \cdot b \cdot I_{B2}

And resolve the current equation:
I_{B3} \cdot b = I_{E3} = I_{C5}+I_{B2}+I_{B5}
=I_{C5}+2 \cdot I_{B2}
=I_{C5}+2 \cdot I_{B5}
=a \cdot I_{B5}+2 \cdot I_{B5}=(a+2)\cdot I_{B5}=(a+2)\cdot I_{B2}

\Rightarrow I_{B2} = I_{B5} = \frac{1}{a+2} \cdot I_{E3} =\frac{b}{a+2} \cdot I_{B3}
I_{E1} = I_{B1} \cdot b = I_{B3}+I_{B4}

I_{C2} = I_{B2} \cdot a
= I_{E4}=I_{B4} \cdot b
\Rightarrow I_{B4} = \frac{a}{b}\cdot I_{B2}=\frac{a}{b}\cdot\frac{b}{a+2} \cdot I_{B3}

ARM assembly, take 3

After having considered some comments from Mr./Ms. G I optimized my assembly code a little bit.
Here a better approach:

Output
deadbeef

11011110101011011011111011101111

00000000111111111111111111111111

Code:

.equ STRING_LENGTH, 32
.equ ZERO_CHARACTER, 0x30
.equ ONE_CHARACTER, 0x31
 
.data
Mask:
	.ascii  "%x\n\n"
.align 4 
 
varToPrint:
	.long 0xdeadbeef
.balign 8 
 
varToUnspace:
	.long 0xdeadbeef
.balign 8 
 
unspacedVarToPrint:
	.long 0xdeadbeef
.balign 8 
 
stringToPrint:
	.ascii "                                                                                  \n\n"
len = STRING_LENGTH
.balign STRING_LENGTH
 
unspacedStringToPrint:
	.ascii "                                                                                  \n\n"
len = STRING_LENGTH
.balign STRING_LENGTH
 
.text
.globl main
main:
	stmfd	sp!, {r0, r1, r2, r3, r4, r5, r6, r7, lr}	@ save the registers we use to the stack
 
	ldr	r3, AddrVarToPrint
	ldr	r6, [r3]
	ldr	r3, AddrVarToPrint
	str	r6, [r3]
 
	/*
	Generating string of binary representation:
		Address of variable in r0
		Address of target string in r1
	*/
	ldr	r0, AddrVarToPrint
	ldr	r1, AddrStringToPrint
	bl make_binary_number
	/*------------------------------------------*/
 
	/*
	Removing zeroes between the ones in binary value:
		Address of variable in r0
		Address of target variable in r1
	*/
	ldr	r0, AddrVarToPrint
	ldr	r1, AddrUnspacedVarToPrint
	bl remove_spaces
 
	/*
	Generating string of binary representation:
		Address of variable in r0
		Address of target string in r1
	*/
	ldr	r0, AddrUnspacedVarToPrint
	ldr	r1, AddrUnspacedStringToPrint
	bl make_binary_number
	/*------------------------------------------*/
 
	bl print_out_result
 
	b exit
 
/*-Fetching the values and printing them-----------------------*/
print_out_result:
	push	{r0, r1, r2, r3, r4, lr}
 
	ldr     r3, AddrMask
	movs	r0, r3
	ldr	r3, AddrVarToPrint
	ldr	r1, [r3]
	bl	printf
 
	ldr     r3, AddrStringToPrint 
	movs	r0, r3
	bl	printf
 
	ldr     r3, AddrUnspacedStringToPrint
	movs	r0, r3
	bl	printf
 
	pop	{r0, r1, r2, r3, r4, pc}
 
/*-Generate a binary representation string from integer--------*/
/* Address of variable in r0 */
/* Address of target string in r1 */
make_binary_number:
	push	{r2, r3, r4, r5, r6, r7, lr}
	ldr	r3, [r0] /* integer value of variable */
 
	movs	r4, $0 /* loop counter */
bin_loop:
	movs    r2, $0x1
	lsls	r2, r4 /* r2 = (0x01 >> counter) */
 
	movs	r6, $STRING_LENGTH-1
	subs	r6, r6, r4 /* idx = reg_length-counter */
 
	tst	r3, r2
	beq	no_one
 
	movs	r5, $ONE_CHARACTER
	strb	r5, [r1,r6]
	b end_bin_loop
 
no_one:
	movs	r5, $ZERO_CHARACTER
	strb	r5, [r1,r6]
	b end_bin_loop
 
end_bin_loop:
	adds	r4, r4,$1
	cmp	r4, $STRING_LENGTH
	bne	bin_loop
 
	pop	{r2, r3, r4, r5, r6, r7, pc}
 
/*-Removes spaces between ones---------------------------------*/
/* Taken we have: 0xdeadbeef
	Binary representation: 11011110101011011011111011101111
	Then the ones will be shifted together so that we get
	the following result: 00000000111111111111111111111111
*/
/* Address of variable in r0 */
/* Address of target variable in r1 */
remove_spaces:
	push	{r2, r3, r4, r5, r6, r7, lr}
	ldr	r6, [r0]
 
	movs	r4, $0
	movs	r5, $0
	movs	r7, $0
 
unspace_loop:
	movs    r2, $0x1
 
	lsls	r2, r4
 
	tst	r6, r2
	beq	end_unspace_loop
 
	lsls	r5, r5, $1
	adds	r5, r5, $1
 
end_unspace_loop:
	adds	r4, r4,$1
	cmp	r4, $STRING_LENGTH
	bne	unspace_loop
 
	str	r5, [r1]
 
	pop	{r2, r3, r4, r5, r6, r7, pc}
/*-------------------------------------------------------------*/
 
/*--------EXIT main(void) function -> return 0-----------------*/
exit:
	ldmfd	sp!, {r0, r1, r2, r3, r4, r5, r6, r7, pc}	@ restore registers before exit
	movs	r7, $1                  @ set r7 to 1 - the syscall for exit
	swi	0                       @ then invoke the syscall from linux
 
 
/*-----Variable pointers---------------------------------------*/
AddrMask:
	.word	Mask
 
AddrVarToPrint:
	.long	varToPrint
 
AddrVarToUnspace:
	.long	varToUnspace
 
AddrStringToPrint:
	.word stringToPrint
 
AddrUnspacedStringToPrint:
	.word unspacedStringToPrint
 
AddrUnspacedVarToPrint:
	.long unspacedVarToPrint

ARM assembly

Eliminating zeroes between ones from binary number:
Output
deadbeef

11011110101011011011111011101111

111111111111111111111111

Code

.data
Mask:
	.ascii  "%x\n\n"
.align 4 
 
varToPrint:
	.long 0xdeadbeef
.balign 8 
 
stringToPrint:
	.ascii "                                                                                  \n\n"
len = 32
.balign 32
 
unspacedStringToPrint:
	.ascii "                                                                                  \n\n"
len = 32
.balign 32
 
.text
.globl main
main:
	stmfd	sp!, {r0, r1, r2, r3, r4, r5, r6, r7, lr}	@ save the registers we use to the stack
 
	ldr	r3, AddrVarToPrint
	ldr	r6, [r3]
	ldr	r3, AddrVarToPrint
	str	r6, [r3]
 
	bl make_binary_number
 
	bl remove_spaces
 
	bl print_out_result
 
	b exit
 
print_out_result:
	push	{r0, r1, r2, r3, r4, lr}
 
	ldr     r3, AddrMask
	movs	r0, r3
	ldr	r3, AddrVarToPrint
	ldr	r1, [r3]
	bl	printf
 
	ldr     r3, AddrStringToPrint 
	movs	r0, r3
	bl	printf
 
	ldr     r3, AddrUnspacedStringToPrint
	movs	r0, r3
	bl	printf
 
	pop	{r0, r1, r2, r3, r4, pc}
 
make_binary_number:
	push	{r0, r1, r2, r3, r4, r5, r6, r7, lr}
	ldr	r3, AddrVarToPrint
	ldr	r1, [r3]
 
	movs	r4, $0
bin_loop:
	movs    r2, $0x1
 
	lsls	r2, r4
	movs	r6, $31
	subs	r6, r6, r4
 
	tst	r1, r2
	beq	no_one
 
	ldr	r3, AddrStringToPrint
	movs	r5, $0x31
	strb	r5, [r3,r6]
	b end_bin_loop
 
no_one:
	ldr	r3, AddrStringToPrint
	movs	r5, $0x30
	strb	r5, [r3,r6]
	b end_bin_loop
 
end_bin_loop:
	adds	r4, r4,$1
	cmp	r4, $32
	bne	bin_loop
 
	pop	{r0, r1, r2, r3, r4, r5, r6, r7, pc}
 
remove_spaces:
	push	{r0, r1, r2, r3, r4, r5, r6, r7, lr}
	ldr	r3, AddrVarToPrint
	ldr	r1, [r3]
 
	ldr	r3, AddrUnspacedStringToPrint
	movs	r5, $0x31
 
	movs	r4, $0
	movs	r7, $0
 
unspace_loop:
	movs    r2, $0x1
 
	lsls	r2, r4
 
	tst	r1, r2
	beq	end_unspace_loop
 
	strb	r5, [r3,r7]
 
	adds	r7,r7,$1
 
end_unspace_loop:
	adds	r4, r4,$1
	cmp	r4, $32
	bne	unspace_loop
 
	pop	{r0, r1, r2, r3, r4, r5, r6, r7, pc}
 
exit:
	ldmfd	sp!, {r0, r1, r2, r3, r4, r5, r6, r7, pc}	@ restore registers before exit
	movs	r7, $1                  @ set r7 to 1 - the syscall for exit
	swi	0                       @ then invoke the syscall from linux
 
AddrMask:
	.word	Mask
 
AddrVarToPrint:
	.long	varToPrint
 
AddrStringToPrint:
	.word stringToPrint
 
AddrUnspacedStringToPrint:
	.word unspacedStringToPrint

printfs syscall in ARM assembly

You can assemble and link it with

arm-linux-gnueabi-gcc --static hello.S -o hello
.data
LC0:
	.ascii  "%d\n"
.text
.align  2
 
.globl main
main:
	stmfd	sp!, {r0, r1, r2, r3, r4, r5, r6, lr}	@ save the registers we use to the stack
	movs	r4, $0
loop:
	ldr     r3, L3
	movs	r0, r3
	movs	r1, r4
	bl	printf
 
	adds	r4, r4,$1
	cmp	r4, $100
	bne	loop
 
exit:
	ldmfd	sp!, {r0, r1, r2, r3, r4, r5, r6, pc}	@ restore registers before exit
	movs	r7, $1                  @ set r7 to 1 - the syscall for exit
	swi	0                       @ then invoke the syscall from linux
 
L3:
	.word	LC0
	.size	main, .-main

Mein potentielles schlechte Laune Ablassventil