There are only operands and operators. Operands are also called mnemonics (pronouned new-MON-ix).
Binary is not a thing. It is a numbering system, like hex or decimal. It is not a what, but a HOW you look at RAM.
If I look at a location in RAM in decimal I might see 0. If I look at it in hex, it might see 0x00, and if I look at it in binary I might see 00000000.
All the same thing no matter how you look at it.
Thus, to create assembly, you simply, using specific rules about your processor, create a 32-bit number whose bits reflect those that tell the processor what mnemonic it is, and then what its operands are. You might have to create a couple of other 8, 16, or 32-bit numbers to go with it, depending on the processor syntax for the given mnemonic.
If you want to see what bit pattern an assembly instruction (again, a mnemonic, or operand) requires, you should get a processor book from the maker of that chip (eg. Motorola or Intel), or get a book at the bookstore about that chip.. eg. 8088, or 80386, etc.)
So to recount: Let's _suppose_ you had an LDA mnemonic for "Loading a value into an Address location". It might be assembler like this:
Code:
...
NOP
LDA #5,bx ;put a 5 into register bx
LDA #10,ax ;put a 10 into register ax
MUL bx,ax ;multiply the 2, putting result into bx
...
In binary, you have to know how the processor knows what a register is (and hence what index applies to what register). You have to know how many bits are used to tell the CPU which mnemonic it's looking at.
For example, Let's say all mnemonics require 6 bits to tell the CPU what the mnemonic is. You need 3 bits each for each registor (your imaginary processor only supports 7 registers), you need a sign bit, and a value for the operators.
LDA #5,bx might look like this:
11101000000000000000000101010011
Which, in decimal is: 3892314451, or
in hex is: 0x00E8000153.