Personnellement, je n’ai jamais réussi à construire un truc potable avec des Lego. Que ce soit un véhicule, une base pour mes personnages ou des créations abstraites, tout ce que mes mains parvenaient à assembler ressemblait vaguement à un tas difforme.

Alors quand je vois cette plaque Link et Zelda (époque NES) réalisée par Naneto avec les petites briques de couleur de notre enfance, forcément, je pleure. Parce que c’est beau, et parce que je me dis que j’étais vraiment bidon quand j’étais jeune. D’autant plus quand je tombe la minute suivante sur la casquette New Era réalisée par Jean-Charles de Castelbajac, que je trouve tout simplement dingue. C’est décidé, à Noël je rachète une boîte de briques.

Via

Pour voir d’autres images de Zelda sur NES et de la casquette New Era x JCDC en Lego, vous pouvez cliquer pour

Ensamblador ( Assembler ) es un lenguaje de programación de bajo nivel, se le llama así porque su estructura es muy cercana al lenguaje de máquina al contrario de los lenguajes de Alto Nivel los cuales proveen un nivel de abstracción mayor. En esta oportunidad quiero compartir el codigo fuente y el ejecutable de un sencillo juego en lenguaje ensamblador, este consiste en un juego de naves espaciales en el cual se deben destruir naves enemigas y esquivar asteroides. Esta aplicación la construí para la primera practica del curso Arquitectura de Computadores y Ensambladores 1.

Descargar: Super Guerra Galactica.

El juego esta escrito para la sintaxis de emu8086, por lo que si deseas compilar el codigo fuente te recomiendo que descargues este programa o modificarlo para correrlo con otro compilador.

Además algúnos tutoriales que me ayudaron en el aprendizaje de este lenguaje:

http://sistemas.itlp.edu.mx/tutoriales/ensamblador/index.htm
http://www.rinconsolidario.org/eps/asm8086/asm.html

También les dejo el link para DOSBOX un emulador que se sirve para ejecutar programas DOS esto para los que no utilizan windows.

http://www.dosbox.com/download.php?main=1

Autor: Williams López

Avui us deix amb la quarta entrega de l’Assembler.

Com sempre, gràcies per visitar la torre i deixau els vostres progressos als comentaris.

Via Tomeu Morey de 1r d’ESO.

PASTED HERE

xor eax,eax
mov ebx, 0×77e61bea ;address of Sleep
mov ax, 5000 ;pause for 5000ms
push eax
call ebx ;Sleep(ms);

maybe helpfull

should make some undetected ( in combination with crypt routine )

haZl0oh

lods Routine ( xor ) MANUAL PACKING

xor eax, eax
xor ebx, ebx
mov esi, *start adress of your code to crypt*
mov edi, esi

start:
lodsb
add bl, 25 ; changeable!
add bh, 33 ; changeable!!
add ah, 23 ; changeable!!
add al, ah
xor al, bl
sub al, bh
stosb
cmp esi, *end adress of your code to crypt*
jle start
jmp OEP

also pasted HERE

haZl0oh

Standard Manual XOR Packing by haZl0oh

DOWNLOAD

haZl0oh

Esta ocasion les traijo un juego adictivo y en el que tendremos que usar nuestro cerebro.

El juego consiste en acomodar con los objetos que te den, de tal manera que se mantengan sin ayuda del mouse y el cuadro verde quede tocando donde esta su marca.

Cuenta con una gran variedad de niveles.

PD: No siempre se usan todos los objetos.

║Jugar

Document Builder
Document Builder is WYSIWYG editor for DDX and ships with LiveCycle Workbench ES2. In previous releases of LiveCycle ES you had to hand code DDX; Document Builder gives you tools to design, validate and test DDX files in a graphical manner.

What is DDX?
To specify documents that you want the Assembler service to produce, you use an XML-based language called Document Description XML (DDX). DDX is a declarative markup language whose elements represent building blocks of documents. These building blocks include PDF pages and other elements such as comments, bookmarks, and styled text. The DDX document can be considered a template for the document(s) that you want the Assembler service to produce.

Document Builder Features:

• WYSIWYG editor for designing DDX
• Full integration with Workbench and Assembler’s Invoke DDX service
• Schema Validation
• Ability to test DDX and to preview results
• Templates for the most commonly used Assembler operations
• Design and Source modes

Numele acestui entry in blog ar trebui sa se numeasca “Cum sa scoti aplicatii de 2.5 KB”
Astazi am vrut sa vad si eu acest masm32 despre care se tot vorbeste . Mai facusem assembler la facultate in anul 1 . Atunci totusi facusem numai inline-uri in Visual studio si stiu ca ma pricepeam destul de bine . Pe vremea aceea insa nu stiam win32 programming . Vara aceasta am invatat Win32 Programming , am scris destule aplicatii de acest gen si azi am fost curios sa vad de ce e in stare acest masm32. I-am dat drumul la un hello masm32, mi-a luat ceva timp, in cele din urma m-am descurcat.

.386
.model flat,stdcall
option casemap:none

include c:masm32includewindows.inc
include c:masm32includeuser32.inc
include c:masm32includekernel32.inc
includelib c:masm32libkernel32.lib
includelib c:masm32libuser32.lib

.data

string1 db "Hello MASM32",0
string2 db "Hello",0

.code

start:

push 64
push offset string2
push offset string1
push 0
call MessageBox

push 0
call ExitProcess

end start

Dimensiunea executabilului ? 2.5 KB . Acealasi program, scris in Visual Studio 2005 , ocupa 6 KB . Asta in conditiile in care avem deja Visual Studio instalat. Daca vrem sa-l facem sa mearga pe orice PC, ocupa 44 KB. Tin sa reamintesc ca nu tin cu niciunul dintre limbaje, C sau ASM . Doar ca sunt fascinat in acest moment de ceea ce poate facem MASM . Oricum nu m-as baga la un ditamai proiectul in ASM , asta e sigur . Dar, pentru o chestie micuta , MASM nu este de ignorat. Mai ales ca nici nu e asa greu de inteles.
Am decis sa mai realizez un mic programel , de data aceasta cu ceva mai mult de facut . Sa creeze un fisier, “fisier.txt” in care sa scrie, pe cate o linie, numele fiecarui fisier din folderul curent . Iata ce a iesit :

.386
.model flat,stdcall
option casemap:none

include c:masm32includewindows.inc
include c:masm32includekernel32.inc
includelib c:masm32libkernel32.lib

.data
file_handle dd 0
nume_fis db "fisier.txt",0
bytes_written dd 0
handle1 dd 0
string1 db "*.*",0
terminat_cautat dd 0
clrf db 13
clrf1 db 10

.data?
special db 318 dup(?)
.code
start:
        push 0
        push 0
        push CREATE_ALWAYS
        push 0
        push 0
        push GENERIC_WRITE
        push offset nume_fis
        call CreateFile
        mov file_handle,eax

        push offset special
        push offset string1
        call FindFirstFile
        mov handle1,eax;aici e handle-ul de la fisierele cautate  

    bucla:

        push offset special
        push handle1
        call FindNextFile
        cmp eax,0
        je cont

        push 0
        push offset bytes_written
        mov eax,offset special
        add eax,44
        mov ecx,0
    strlen:
        mov bl,[eax+ecx]
        cmp bl,0
        je strlen_end
        inc ecx
        jmp strlen

    strlen_end:
        push ecx
        mov eax,offset special
        add eax,44
        push eax
        push file_handle
        call WriteFile

        push 0
        push offset bytes_written
        push 2
        push offset clrf
        push file_handle
        call WriteFile

        jmp bucla

    cont:
        mov eax,file_handle
        push eax
        call CloseHandle

        push 0
        call ExitProcess

end start

Dimensiunea ? 2.5 KB bineintles Din motive pe care nu le-am inteles, se pare ca in masm ,daca scriu string-ul “rn” ( clrf-ul standard din windows ), in fisier se scrie la propriu ” r n” in loc sa scriu caracterele 13(‘r’) si 10 (‘n’) . Chestia asta probabil mi-a luat cel mai mult timp In rest 2 bucle … nu mi-am mai batut capul la capitolul strlen, am numarat de-a dreptul numarul de caractere. La fel, nu am mai stat sa implementez structura aceea speciala, WIN32_FIND_DATA, am declarat un tablou de 318 octeti ( sizeof(WIN32_FIND_DATA ) si m-am deplasat la denumirea fisierului , adica la 44 octeti distanta.
Concluzia : gasesc masm32 un foarte interesant limbaj de asamblare . Cu siguranta nu voi trece la el in defavoarea C-ului insa merita si el destula atentie .


; ********************************************************
; * Number conversion routines, Version 0.1 January 2002 *
; * (C)2002 by info@avr-asm-tutorial.net *
; ********************************************************
;
; The following rules apply for all conversion routines:
; - Errors during conversion set the T-bit in the status
; register.
; - Z points to either SRAM (Z>=$0060) or to registers
; ($0001 .. $001D, exclude R0, R16 and R30/31).
; - ASCII- and BCD-coded numbers with multiple digits are
; placed with higher significant digits at lower adres-
; ses. Z should always point to the most significant
; digit.
; - 16-bit-binary values are generally located in the
; registers rBin1H:rBin1L. These must be defined within
; the calling program.
; - Register rmp (range: R16..R29) is used within the
; routines, its content is changed.
; - Register pair Z is used within the routines, its
; content is set depending on the result.
; - Some routines use register R0 temporarily, its content
; is restored.


;=============================================

; – Due to the use of the Z-Register pair the header file
; for the target processor (xxxxdef.inc) must be inclu-
; ded in the calling program or ZH (R31) and ZL (R30)
; must be defined manually. Otherwise an error message
; results, or you will get crazy things going on, when
; you run the program.
; – Because subroutines and push/pop-operations are used
; within these routines you must set the stack pointer
; (SPH:SPL, resp. SPL for devices with equal or less
; than 256 Byte internal SRAM).
;
; ***************** Routines Overview ********************
; Routines Input Conditions Out, Errors
; ——————————————————–
; AscToBin2 Z points on stops at first non- 16-bit-bin
; first ASCII non-decimal digit, rBin1H:L,
; char ignores leading Overflow
; blanks and zeros
; Asc5ToBin2 Z points on requires exact 5 16-bit-bin
; first ASCII valid digits, rBin1H:L,
; char ignores leading Overflow
; blanks and zeros and non-dec
; Bcd5ToBin2 5-digit-BCD requires exact 5 16-bit-bin
; Z points to valid digits rBin1H:L
; first digit Overflow
; and non-BCD
; Bin2ToBcd5 16-bit-bin Z points to first 5-digit-BCD
; in rBin1H:L BCD digit Z on first,
; no errors
; Bin2ToHex4 16-bit-bin Z points to first 4-digit-hex
; in rBin1H:L Hex ASCII digit, Z on first
; hex digits A..F no errors
; Hex4ToBin2 4-digit-hex Z points to first 16-bit-bin
; Z points to hex ASCII digit, rBin1H:L,
; first char requires 4 digits, invalid hex
; A..F or a..f ok digit
; ******************* Conversion code ********************
;
; Package I: From ASCII resp. BCD to binary
;
; AscToBin2
; =========
; converts an ASCII coded number to a 2-Byte bi-
; nary
; In: Z points to first digit, conversion stops at first
; digit detected or if overflow of the result occurs,
; end of number must be terminated by a non-decimal
; ASCII-digit!
; Out: Z points to first non-valid digit or to the digit
; where the overflow occurred, if number is valid the
; T-Flag is clear and the number is in registers
; rBin1H:rBin1L
; Used registers: rBin1H:L (result), rBin2H:L (restored
; after use), rmp
; Called subroutines: Bin1Mul10
;
AscToBin2:
clr rBin1H ; Clear the result
clr rBin1L
clt ; Clear error flag bit
AscToBin2a:
ld rmp,Z+ ; ignore leading blanks and zeros
cpi rmp,’ ‘ ; blank?
breq AscToBin2a
cpi rmp,’0′ ; zero?
breq AscToBin2a
AscToBin2b:
subi rmp,’0′ ; subtract ASCII zero
brcs AscToBin2d ; End of the number
cpi rmp,10 ; check invalid digit
brcc AscToBin2d ; No-decimal char
rcall Bin1Mul10 ; Multiply binary number by 10
brts AscToBin2c ; overflow, return with T-Flag set
add rBin1L,rmp ; add the digit to the binary
ld rmp,Z+ ; read next char
brcc AscToBin2b ; no overflow to binary MSB
inc rBin1H ; Overflow to binary MSB
brne AscToBin2b ; no overflow of binary MSB
set ; Set overflow flag
AscToBin2c:
sbiw ZL,1 ; Back one char, last char end/invalid
AscToBin2d:
ret
;
; Asc5ToBin2
; ==========
; converts a 5-digit ASCII to a 16-bit-binary
; In: Z points to first decimal ASCII-digit, leading
; blanks and zeros are ok. Requires exact 5 digits.
; Result: T-Flag reports result:
; T=0: result in rBin1H:rBin1L, valid, Z points to
; first digit of the hex-ASCII-number
; T=1: error, Z points to the first illegal character
; or to the digit, where the overflow occurred
; Used registers: rBin1H:L (result), R0 (restored after
; use), rBin2H:L (restored after use), rmp
; Called subroutines: Bin1Mul10
;
Asc5ToBin2:
push R0 ; R0 is used as counter, save it first
ldi rmp,6 ; five chars, one too much
mov R0,rmp
clr rBin1H ; Clear result
clr rBin1L
clt ; Clear T-Bit
Asc5ToBin2a:
dec R0 ; all chars read?
breq Asc5ToBin2d ; last char
ld rmp,Z+ ; read a char
cpi rmp,’ ‘ ; ignore blanks
breq Asc5ToBin2a ; next char
cpi rmp,’0′ ; ignore leading zeros
breq Asc5ToBin2a ; next char
Asc5ToBin2b:
subi rmp,’0′ ; treat digit
brcs Asc5ToBin2e ; Last char was invalid
cpi rmp,10 ; digit > 9
brcc Asc5ToBin2e ; Last char invalid
rcall Bin1Mul10 ; Multiply result by 10
brts Asc5ToBin2e ; Overflow occurred
add rBin1L,rmp ; add the digit
ld rmp,z+
brcc Asc5ToBin2c ; no overflow to MSB
inc rBin1H ; Overflow to MSB
breq Asc5ToBin2e ; Overflow of MSB
Asc5ToBin2c:
dec R0 ; downcount number of digits
brne Asc5ToBin2b ; convert more chars
Asc5ToBin2d: ; End of ASCII number reached ok
sbiw ZL,5 ; Restore start position of ASCII number
pop R0 ; Restore register R0
ret
Asc5ToBin2e: ; Last char was invalid
sbiw ZL,1 ; Point to invalid char
pop R0 ; Restore register R0
set ; Set T-Flag for error
ret ; and return with error condition set
;
; Bcd5ToBin2
; ==========
; converts a 5-bit-BCD to a 16-bit-binary
; In: Z points to the most signifant digit of the BCD
; Out: T-flag shows general result:
; T=0: Binary in rBin1H:L is valid, Z points to the
; first digit of the BCD converted
; T=1: Error during conversion. Either the BCD was too
; big (must be 0..65535, Z points to BCD where the
; overflow occurred) or an illegal BCD was detected
; (Z points to the first non-BCD digit).
; Used registers: rBin1H:L (result), R0 (restored after
; use), rBin2H:L (restored after use), rmp
; Called subroutines: Bin1Mul10
;
Bcd5ToBin2:
push R0 ; Save register
clr rBin1H ; Empty result
clr rBin1L
ldi rmp,5 ; Set counter to 5
mov R0,rmp
clt ; Clear error flag
Bcd5ToBin2a:
ld rmp,Z+ ; Read BCD digit
cpi rmp,10 ; is it valid?
brcc Bcd5ToBin2c ; invalid BCD
rcall Bin1Mul10 ; Multiply result by 10
brts Bcd5ToBin2c ; Overflow occurred
add rBin1L,rmp ; add digit
brcc Bcd5ToBin2b ; No overflow to MSB
inc rBin1H ; Overflow to MSB
breq Bcd5ToBin2c ; Overflow of MSB
Bcd5ToBin2b:
dec R0 ; another digit?
brne Bcd5ToBin2a ; Yes
pop R0 ; Restore register
sbiw ZL,5 ; Set to first BCD digit
ret ; Return
Bcd5ToBin2c:
sbiw ZL,1 ; back one digit
pop R0 ; Restore register
set ; Set T-flag, error
ret ; and return
;
; Bin1Mul10
; =========
; multiplies a 16-bit-binary by 10
; Sub used by: AscToBin2, Asc5ToBin2, Bcd5ToBin2
; In: 16-bit-binary in rBin1H:L
; Out: T-flag shows general result:
; T=0: Valid result, 16-bit-binary in rBin1H:L ok
; T=1: Overflow occurred, number too big
;
Bin1Mul10:
push rBin2H ; Save the register of 16-bit-binary 2
push rBin2L
mov rBin2H,rBin1H ; Copy the number
mov rBin2L,rBin1L
add rBin1L,rBin1L ; Multiply by 2
adc rBin1H,rBin1H
brcs Bin1Mul10b ; overflow, get out of here
Bin1Mul10a:
add rBin1L,rbin1L ; again multiply by 2 (4*number reached)
adc rBin1H,rBin1H
brcs Bin1Mul10b ; overflow, get out of here
add rBin1L,rBin2L ; add the copied number (5*number reached)
adc rBin1H,rBin2H
brcs Bin1Mul10b ;overflow, get out of here
add rBin1L,rBin1L ; again multiply by 2 (10*number reached)
adc rBin1H,rBin1H
brcc Bin1Mul10c ; no overflow occurred, don’t set T-flag
Bin1Mul10b:
set ; an overflow occurred during multplication
Bin1Mul10c:
pop rBin2L ; Restore the registers of 16-bit-binary 2
pop rBin2H
ret
;
; *************************************************
;
; Package II: From binary to ASCII resp. BCD
;
; Bin2ToAsc5
; ==========
; converts a 16-bit-binary to a 5 digit ASCII-coded decimal
; In: 16-bit-binary in rBin1H:L, Z points to the highest
; of 5 ASCII digits, where the result goes to
; Out: Z points to the beginning of the ASCII string, lea-
; ding zeros are filled with blanks
; Used registers: rBin1H:L (content is not changed),
; rBin2H:L (content is changed), rmp
; Called subroutines: Bin2ToBcd5
;
Bin2ToAsc5:
rcall Bin2ToBcd5 ; convert binary to BCD
ldi rmp,4 ; Counter is 4 leading digits
mov rBin2L,rmp
Bin2ToAsc5a:
ld rmp,z ; read a BCD digit
tst rmp ; check if leading zero
brne Bin2ToAsc5b ; No, found digit >0
ldi rmp,’ ‘ ; overwrite with blank
st z+,rmp ; store and set to next position
dec rBin2L ; decrement counter
brne Bin2ToAsc5a ; further leading blanks
ld rmp,z ; Read the last BCD
Bin2ToAsc5b:
inc rBin2L ; one more char
Bin2ToAsc5c:
subi rmp,-’0′ ; Add ASCII-0
st z+,rmp ; store and inc pointer
ld rmp,z ; read next char
dec rBin2L ; more chars?
brne Bin2ToAsc5c ; yes, go on
sbiw ZL,5 ; Pointer to beginning of the BCD
ret ; done
;
; Bin2ToAsc
; =========
; converts a 16-bit-binary to a 5-digit ASCII coded decimal,
; the pointer points to the first significant digit of the
; decimal, returns the number of digits
; In: 16-bit-binary in rBin1H:L, Z points to first digit of
; the ASCII decimal (requires 5 digits buffer space, even
; if the number is smaller!)
; Out: Z points to the first significant digit of the ASCII
; decimal, rBin2L has the number of characters (1..5)
; Used registers: rBin1H:L (unchanged), rBin2H (changed),
; rBin2L (result, length of number), rmp
; Called subroutines: Bin2ToBcd5, Bin2ToAsc5
;
Bin2ToAsc:
rcall Bin2ToAsc5 ; Convert binary to ASCII
ldi rmp,6 ; Counter is 6
mov rBin2L,rmp
Bin2ToAsca:
dec rBin2L ; decrement counter
ld rmp,z+ ; read char and inc pointer
cpi rmp,’ ‘ ; was a blank?
breq Bin2ToAsca ; Yes, was a blank
sbiw ZL,1 ; one char backwards
ret ; done
;
; Bin2ToBcd5
; ==========
; converts a 16-bit-binary to a 5-digit-BCD
; In: 16-bit-binary in rBin1H:L, Z points to first digit
; where the result goes to
; Out: 5-digit-BCD, Z points to first BCD-digit
; Used registers: rBin1H:L (unchanged), rBin2H:L (changed),
; rmp
; Called subroutines: Bin2ToDigit
;
Bin2ToBcd5:
push rBin1H ; Save number
push rBin1L
ldi rmp,HIGH(10000) ; Start with tenthousands
mov rBin2H,rmp
ldi rmp,LOW(10000)
mov rBin2L,rmp
rcall Bin2ToDigit ; Calculate digit
ldi rmp,HIGH(1000) ; Next with thousands
mov rBin2H,rmp
ldi rmp,LOW(1000)
mov rBin2L,rmp
rcall Bin2ToDigit ; Calculate digit
ldi rmp,HIGH(100) ; Next with hundreds
mov rBin2H,rmp
ldi rmp,LOW(100)
mov rBin2L,rmp
rcall Bin2ToDigit ; Calculate digit
ldi rmp,HIGH(10) ; Next with tens
mov rBin2H,rmp
ldi rmp,LOW(10)
mov rBin2L,rmp
rcall Bin2ToDigit ; Calculate digit
st z,rBin1L ; Remainder are ones
sbiw ZL,4 ; Put pointer to first BCD
pop rBin1L ; Restore original binary
pop rBin1H
ret ; and return
;
; Bin2ToDigit
; ===========
; converts one decimal digit by continued subraction of a
; binary coded decimal
; Used by: Bin2ToBcd5, Bin2ToAsc5, Bin2ToAsc
; In: 16-bit-binary in rBin1H:L, binary coded decimal in
; rBin2H:L, Z points to current BCD digit
; Out: Result in Z, Z incremented
; Used registers: rBin1H:L (holds remainder of the binary),
; rBin2H:L (unchanged), rmp
; Called subroutines: -
;
Bin2ToDigit:
clr rmp ; digit count is zero
Bin2ToDigita:
cp rBin1H,rBin2H ; Number bigger than decimal?
brcs Bin2ToDigitc ; MSB smaller than decimal
brne Bin2ToDigitb ; MSB bigger than decimal
cp rBin1L,rBin2L ; LSB bigger or equal decimal
brcs Bin2ToDigitc ; LSB smaller than decimal
Bin2ToDigitb:
sub rBin1L,rBin2L ; Subtract LSB decimal
sbc rBin1H,rBin2H ; Subtract MSB decimal
inc rmp ; Increment digit count
rjmp Bin2ToDigita ; Next loop
Bin2ToDigitc:
st z+,rmp ; Save digit and increment
ret ; done
;
; **************************************************
;
; Package III: From binary to Hex-ASCII
;
; Bin2ToHex4
; ==========
; converts a 16-bit-binary to uppercase Hex-ASCII
; In: 16-bit-binary in rBin1H:L, Z points to first
; position of the four-character Hex-ASCII
; Out: Z points to the first digit of the four-character
; Hex-ASCII, ASCII digits A..F in capital letters
; Used registers: rBin1H:L (unchanged), rmp
; Called subroutines: Bin1ToHex2, Bin1ToHex1
;
Bin2ToHex4:
mov rmp,rBin1H ; load MSB
rcall Bin1ToHex2 ; convert byte
mov rmp,rBin1L
rcall Bin1ToHex2
sbiw ZL,4 ; Set Z to start
ret
;
; Bin1ToHex2 converts an 8-bit-binary to uppercase hex
; Called by: Bin2ToHex4
;
Bin1ToHex2:
push rmp ; Save byte
swap rmp ; upper to lower nibble
rcall Bin1ToHex1
pop rmp ; Restore byte
Bin1ToHex1:
andi rmp,$0F ; mask upper nibble
subi rmp,-’0′ ; add 0 to convert to ASCII
cpi rmp,’9′+1 ; A..F?
brcs Bin1ToHex1a
subi rmp,-7 ; add 7 for A..F
Bin1ToHex1a:
st z+,rmp ; store in target
ret ; and return
;
; *******************************************
;
; Package IV: From Hex-ASCII to binary
;
; Hex4ToBin2
; converts a 4-digit-hex-ascii to a 16-bit-binary
; In: Z points to first digit of a Hex-ASCII-coded number
; Out: T-flag has general result:
; T=0: rBin1H:L has the 16-bit-binary result, Z points
; to the first digit of the Hex-ASCII number
; T=1: illegal character encountered, Z points to the
; first non-hex-ASCII character
; Used registers: rBin1H:L (result), R0 (restored after
; use), rmp
; Called subroutines: Hex2ToBin1, Hex1ToBin1
;
Hex4ToBin2:
clt ; Clear error flag
rcall Hex2ToBin1 ; convert two digits hex to Byte
brts Hex4ToBin2a ; Error, go back
mov rBin1H,rmp ; Byte to result MSB
rcall Hex2ToBin1 ; next two chars
brts Hex4ToBin2a ; Error, go back
mov rBin1L,rmp ; Byte to result LSB
sbiw ZL,4 ; result ok, go back to start
Hex4ToBin2a:
ret
;
; Hex2ToBin1 converts 2-digit-hex-ASCII to 8-bit-binary
; Called By: Hex4ToBin2
;
Hex2ToBin1:
push R0 ; Save register
rcall Hex1ToBin1 ; Read next char
brts Hex2ToBin1a ; Error
swap rmp; To upper nibble
mov R0,rmp ; interim storage
rcall Hex1ToBin1 ; Read another char
brts Hex2ToBin1a ; Error
or rmp,R0 ; pack the two nibbles together
Hex2ToBin1a:
pop R0 ; Restore R0
ret ; and return
;
; Hex1ToBin1 reads one char and converts to binary
;
Hex1ToBin1:
ld rmp,z+ ; read the char
subi rmp,’0′ ; ASCII to binary
brcs Hex1ToBin1b ; Error in char
cpi rmp,10 ; A..F
brcs Hex1ToBin1c ; not A..F
cpi rmp,$30 ; small letters?
brcs Hex1ToBin1a ; No
subi rmp,$20 ; small to capital letters
Hex1ToBin1a:
subi rmp,7 ; A..F
cpi rmp,10 ; A..F?
brcs Hex1ToBin1b ; Error, is smaller than A
cpi rmp,16 ; bigger than F?
brcs Hex1ToBin1c ; No, digit ok
Hex1ToBin1b: ; Error
sbiw ZL,1 ; one back
set ; Set flag
Hex1ToBin1c:
ret ; Return

While working on the Density overall re-design I was working extensively on the audio engine as well but just for one single reason: The one thing I was missing in the original design was to have some more “responsive” gain riding possibilities but without the usual tradeoff of introducing more distortion or compromising the transparency. And (unsurprisingly) that turned out to be not that easy.

Developers friend: the oscilloscope

Fortunately, there are a couple of gadgets in the audio developers toolbox which can tremendously help in getting the things right or to avoid (time consuming) audio listening tests in the early development stage. The oscilloscope e.g. is a good tool to investigate a certain attack and release curve behaviour or to perform tests with automatic leveling circuits just to name the two. This is mostly performed on periodic input signals like raw basic waveforms. While re-designing the audio core of Density I did a lot of experiments with that and even checked some weird and funny approaches to compression which had lead to some interesting insights here and there while working towards the final circuit.

A CPU cycle measurement tool

At the end of the day not everything which looks promising in the oscillator actually does sound necessarily good or, in other cases, the computational costs of that algorithm is simply way off. The latter one can easily checked with CPU cycle sort of tools which provides instant feedback on how many CPU cycles a certain algorithm actually consumes or which performance optimzation gains more speed. I’ve used such tools and methods quiet a lot during the technical design of the mkII version and that way I was able to introduce some new algorithms with higher precision and resolution but at lower computational costs (compared to the original design). In general this is better already been finished during the design phase opposed to upon the end of development where this can cause more impact (overall redesign or so) and therefore potentially can waste a lot of development time. Further Assembler code tuning on the other side is better be done to the end of development for the sake of programmers efficiency.

A pure second order harmonic in the analyzer

Christian Buddes audio plug-in analyzer is another excellent tool when you already have managed to get your algorithms compiled into a VST dll-file. It’s really usefull on judging frequency or harmonic spectrum issues like intermodulation distortion or the compressors transfer curve and things alike. However, it cannot see all things and sometimes even weird stuff or nothing is showing up though it normally should do so. This can be the case when e.g. measured algorithms just work on or behind transients, on mid/side encoded signals or just works differently along the entire frequency spectrum. In the plot above everything is ok and it shows an algorithms effect where just a pure second order harmonic is produced (oversampled). In DensitymkII the compression algorithm itself is capable of generating a pleasant second order harmonic during the compression duty cycle. This replaces the “phat” mode of the previous Density version and is inherently active.

10kHz sinus signal pre and post compressor

If the developed plug-in now properly loads into a host, another common technique for measuring the dynamic behaviour of such an audio plug-in is to load the compiled plug-in into it so someone can apply special test signals on it. Continous sinus based signals at different frequencies (e.g. 3kHz, 10kHz or even rather low frequencies for measuring bass response) at different levels over time are typically used. The outcoming overall curves are then compared to the original test signals or to some reference curves of other devices or so. This was a lifesaver during the beta test stage of DensitymkII where some subtle discontinuities in the release curve were spotted (caused by a malfunctioning program dependency) and so it could be finally tracked down. The way program dependency in the mkII is actually implemented now is a major part of the unobtrusive compression action and it offers both now: strict peak compression and relaxed and punchy sound.

An audio wave player

Normally, one would increase the number of audio listening tests along the progress of development over time and therefore switch over to separate testbeds to do so. In the development framework I’m currently using, one is able to just load audio files into a wave player and to hear it passing through that algorithm which is currently under developement. Thanks to instant re-compile there is no real lag when re-triggering audio and so you can hear and judge the code changes instantaneously during development – what a time saver!

Credits

Many thanks to the Synthmaker community and Christian B. for providing all those usefull tools!

References

the compressors sidechain: filtering

soft-knee compression and beyond

compressor gain control principles

in the lab – audio listening tests

Density mkII – reworking the usage concept

Grab Bag Goes Postal:

July 26th, 1775… the U.S. Postal system is established, and none other than Ben Franklin is the first postmaster. Although he only held the position for a year before going to France as an ambassador of sorts, Mr. Franklin left a vastly improved system in the hands of his successor. Established routes from Florida to Maine and stepped-up deliveries to and from England set the Postal service on the right track. “Going postal” back then meant actually sending and receiving letters. Go figure.

Grab Bag Cool Tip:

Have you ever just wanted to leave a voicemail, skipping the live conversation necessities of  ”Hi, how are you?” or the awkward “The lab results came back and…” ?  Well, my friends, have I got a nice little life hack for you. Found this slick way to go straight to voicemail on someone’s cell phone, even if their cell is on and ready to accept calls (doesn’t work to land lines, although you can place your call FROM a land line).



Meet “Sly Dial”. Just call (267) 759-3425 (267-SLYDIAL). A recording will ask you to enter the 10 digit cell phone where you wish to leave a voicemail. The next thing you will hear is the recipient’s voicemail greeting, and you leave your message as usual. That’s it. AND IT’S FREE!

The recipient soon sees that they have a voicemail, and it appears from the number you used to place the call, not the “Sly Dial” number. Sly Dial also exists as an App for Blackberry, iPhone and Windows Mobile smartphones, although this ad-free, quicker connection will cost you 10 cents a call or $30 a year, and who needs to dodge that many convos? Well, maybe some of us do…. Anyway, I suggest you enter Sly Dial as a contact in your address book and call it as you would any other contact.

So… it may not do much for your upfront, forthright image, but it might just make life a little easier on those days when you just can’t handle another conversation.

Grag Bag Green Tip:

To date, this is the best “green” website I have found. Their standards are strict, their research is thorough and their offerings are categorically broad, although not terribly deep (possibly because not that many products stand up to their requirements). What I really like about this is that you can pretty much rest assured that everything you find on this website is just about the cleanest and greenest in it’s category. I was delighted to find some of my favorite brands there, and to discover some I had never heard of before.

Browse, learn, enjoy

BuyGreen.com

Grab Bag “What IS That” Solution:

What IS that thing on your shoulder? What does it mean when your fingernails get white marks? For those times when you find yourself staring at some UFG (unidentified foreign growth) somewhere on your skin, or a disconcerting ridge appears on your fingernail, here is a dermatological visual database site you will want to keep handy, if only to just to tap into that horrified-yet-fascinated side of you

DERMNET.COM

“EEEEWWWWW”

Grab Bag Valuable Sociology Ponderance:

What follows is a synopsis of a Washington Post-sponsored sociology experiment. To see video of the experiment, and to get a deeper sense of the experience itself and the issues it raises, read the Washington Post story in it’s entirety HERE. Many thanks to Corinna G. for sending this to me:

A musician playing violin in a Washington DC Metro Station on a cold January morning…… He played six Bach pieces for about 60 minutes. During that time approximately 1,000 people went through the station, most of them on their way to work. After: 3 minutes A middle aged man noticed there was a musician playing. He slowed his pace and stopped for a few seconds and then hurried to meet his schedule. 4 minutes The violinist received his first dollar: a woman threw the money in the till and without stopping, continued to walk. 6 minutes A young man leaned against the wall to listen to him, then looked at his watch and started to walk again. 10 minutes A three year old boy stopped but his mother tugged him along hurriedly, as the kid stopped to look at the violinist. Finally the mother pushed hard and the child continued to walk, turning his head all the time. This action was repeated by several other children. Every parent, without exception, forced them to move on. 45 minutes The musician played. Only 6 people stopped and stayed for a while. About 20 gave him money but continued to walk their normal pace. He collected $32. 1 hour: He finished playing and silence took over. No one noticed. No one applauded, nor was there any recognition. This is a real story. The Washington Post, as part of a social experiment about perception, taste and people’s priorities, arranged the entire scenario. Playing incognito, no one knew the violinist was Joshua Bell, one of the best musicians in the world. He played one of the most intricate pieces ever written, with a violin worth $3.5 million dollars. Two days prior to this, Joshua Bell sold out a theater in Boston where the tickets averaged $100 per seat. The questions raised: In a common place environment at an inappropriate hour, do we perceive beauty; Do we stop to appreciate it; Do we recognize talent in such an unexpected context? One possible conclusion reached from this experiment could be: If we do not have a moment to stop and listen to one of the best musicians in the world, playing some of the finest music ever written, with one of the most beautiful instruments ……. How many other things are we missing?

Grab Bag “Wanna be Her” Moment:

more about “Video of Romancing the Road by Growin…“, posted with vodpod

Grab Bag Brain Game:

WARNING:

This one may rob you of many hours….

ASSEMBLER

Grab Bag Funny Stuff:

GREAT BILLBOARDS WE WISH WE WOULD SEE:

Thanks to sis Shelley G. for sending these along…

]]>