Understanding ARM instruction for numerical literal
Updated

As pointed out by @ChrisStratton in comments, the answer below ignored the fact that the processor in use does not support the 4-byte ARM instruction set, and only runs "Thumb" code.  Based on this information, and the fact that the debugger shown in the question is apparently decoding 4-byte instructions (based on how the addresses increment for each instruction), it would appear that the debugger is misconfigured.  There should be a setting to force it to disassemble code as thumb instructions; this needs to be enabled when working with Cortex M3 processors.

I've left the original answer below as it answers the question as asked (how to interpret the particular instruction being reported by the debugger), but it should be noted that this instruction does not occur in your code, and is only being displayed because of the incorrect configuration of the debugger.

Original answer

You're misreading the ARM documentation.  The instruction is:

STRB reg1, [reg2], #offset


where the offset is a flexible offset.

The meaning of this instruction is that the contents of reg1 are stored in memory at the address reg2 + offset. In this case, R1 is stored at the byte at the address 1 higher than the address pointed to by R3.

To help understand this, note that ARM is (predominantly) a load/store processor architecture, which is to say that it distinguishes between operations that move data to memory ("store register", abbreviated in the mnemonic as STR), from memory ("load register", abbreviated as LDR) and other operations which (generally) use registers only and not memory (albeit with exceptions because ARM isn't a pure load/store architecture).  References to either "load" or "store" are always dealing with memory, and are always dealing with it in those directions.  An instruction that copies data from one register to another wouldn't be given such a name (in fact in ARM that would be MOV for move).

As an aside, the link you provided is to the wrong section of the ARM documentation.  That describes the instructions available in the "ARM Thumb" instruction set, but your program appears to be using the traditional full ARM instruction set ("Thumb" programs have 2 bytes per instruction, whereas your program has 4 bytes per instruction, judging by the addresses displayed in the debugger output).  The correct section is the one that starts here. (striking this section out as it is completely incorrect)