data_transfer.c File Reference

#include "data_transfer.h"

Include dependency graph for data_transfer.c:

Go to the source code of this file.

Functions
void	mov (uint8_t d, uint8_t r, struct CORE *core)
	Move data from register r to register d.
void	movw (uint8_t d, uint8_t r, struct CORE *core)
	Move word from register pair r to register pair d.
void	ldi (uint8_t d, uint8_t K, struct CORE *core)
	Load immediate value K into register d.
void	lds (uint8_t d, int16_t k, struct CORE *core, union DATA_SPACE *data_space)
	Load direct from data space using 16-bit address.
void	ld_x (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space using X register.
void	ld_x_inc (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space using X register and post-increment.
void	ld_x_dec (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space using X register and pre-decrement.
void	ld_y (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space using Y register.
void	ld_y_inc (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space using Y register and post-increment.
void	ld_y_dec (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space using Y register and pre-decrement.
void	ldd_y (uint8_t d, uint8_t q, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space to register using Y pointer with displacement.
void	ld_z (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space to register using Z pointer.
void	ld_z_inc (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space to register using Z pointer and post-increment.
void	ld_z_dec (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space to register using Z pointer and pre-decrement.
void	ldd_z (uint8_t d, uint8_t q, struct CORE *core, union DATA_SPACE *data_space)
	Load indirect from data space to register using Z pointer with displacement.
void	sts (int16_t k, uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Store direct from register to data space.
void	st_x (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Store indirect from register to data space using X pointer.
void	st_x_inc (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Store indirect from register to data space using X pointer and post-increment.
void	st_x_dec (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Store indirect from register to data space using X pointer and pre-decrement.
void	st_y (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Store indirect from register to data space using Y pointer.
void	st_y_inc (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Store register to data space using Y pointer and post-increment Y.
void	st_y_dec (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Store register to data space using Y pointer and pre-decrement Y.
void	std_y (uint8_t d, uint8_t q, struct CORE *core, union DATA_SPACE *data_space)
	Store register to data space using Y pointer with displacement.
void	st_z (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Store register to data space using Z pointer.
void	st_z_inc (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Store register to data space using Z pointer and post-increment Z.
void	st_z_dec (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Store register to data space using Z pointer and pre-decrement Z.
void	std_z (uint8_t d, uint8_t q, struct CORE *core, union DATA_SPACE *data_space)
	Store register to data space using Z pointer with displacement.
void	lpm_0 (struct CORE *core, union PROGMEM_SPACE *progmem_space)
	Load program memory into register using Z pointer.
void	lpm_z (uint8_t d, struct CORE *core, union PROGMEM_SPACE *progmem_space)
	Load program memory into register using Z pointer.
void	lpm_z_inc (uint8_t d, struct CORE *core, union PROGMEM_SPACE *progmem_space)
	Load program memory and post-increment Z register.
void	in (uint8_t d, uint8_t A, struct CORE *core, union DATA_SPACE *data_space)
	Read from I/O space into register.
void	out (uint8_t A, uint8_t r, struct CORE *core, union DATA_SPACE *data_space)
	Write from register to I/O space.
void	push (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Push register onto stack.
void	pop (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Pop register from stack.
void	xch (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Exchange register with data space.
void	las (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load and set data space.
void	lac (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load and clear data space.
void	lat (uint8_t d, struct CORE *core, union DATA_SPACE *data_space)
	Load and toggle data space.

Function Documentation

in()

void in	(	uint8_t	d,
		uint8_t	A,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Read from I/O space into register.

Parameters

d	Destination register.
A	I/O address.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 451 of file data_transfer.c.

                                                                               {
    // Read from I/O register
    // Rd <- I/O[A]
    // 1 cycle
 
    // Execute instruction
    core->gp.R[d] = data_space->io_reg[A];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), DATA_SPACE::io_reg, and GP::R.

lac()

void lac	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load and clear data space.

Parameters

d	Register to load and clear.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 546 of file data_transfer.c.

                                                                     {
    // Load and clear register
    // Only on SRAM
    // In same time:
    // (Z) <- (0xFF - Rd) & (Z)
    // Rd <- (Z)
    // 2 cycle
 
    // Execute instruction
    uint8_t temp = data_space->data[core->gp.Z];
    data_space->data[core->gp.Z] = (0xFF - core->gp.R[d]) & temp;
    core->gp.R[d] = temp;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

las()

void las	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load and set data space.

Parameters

d	Register to load and set.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 527 of file data_transfer.c.

                                                                     {
    // Load and set register
    // Only on SRAM
    // In same time:
    // (Z) <- Rd || (Z)
    // Rd <- (Z)
    // 2 cycle
 
    // Execute instruction
    uint8_t temp = data_space->data[core->gp.Z];
    data_space->data[core->gp.Z] = core->gp.R[d] || temp;
    core->gp.R[d] = temp;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

lat()

void lat	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load and toggle data space.

Parameters

d	Register to load and toggle.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 565 of file data_transfer.c.

                                                                     {
    // Load and toggle register
    // Only on SRAM
    // In same time:
    // (Z) <- Rd ^ (Z)
    // Rd <- (Z)
    // 2 cycle
 
    // Execute instruction
    uint8_t temp = data_space->data[core->gp.Z];
    data_space->data[core->gp.Z] = core->gp.R[d] ^ temp;
    core->gp.R[d] = temp;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

ld_x()

void ld_x	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space using X register.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 61 of file data_transfer.c.

                                                                      {
    // Load indirect from data space using X as address
    // Rd <- (X)
    // 1 cycle
 
    // Execute instruction
    core->gp.R[d] = data_space->data[core->gp.X];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::X.

ld_x_dec()

void ld_x_dec	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space using X register and pre-decrement.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 91 of file data_transfer.c.

                                                                          {
    // Load indirect from data space using X as address and post-decrement X
    // X <- X - 1
    // Rd <- (X)
    // 3 cycle
 
    // Execute instruction
    core->gp.X--;
    core->gp.R[d] = data_space->data[core->gp.X];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::X.

ld_x_inc()

void ld_x_inc	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space using X register and post-increment.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 75 of file data_transfer.c.

                                                                          {
    // Load indirect from data space using X as address and post-increment X
    // Rd <- (X)
    // X <- X + 1
    // 2 cycle
 
    // Execute instruction
    core->gp.R[d] = data_space->data[core->gp.X];
    core->gp.X++;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::X.

ld_y()

void ld_y	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space using Y register.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 107 of file data_transfer.c.

                                                                      {
    // Load indirect from data space using Y as address
    // Rd <- (Y)
    // 1 cycle
 
    // Execute instruction
    core->gp.R[d] = data_space->data[core->gp.Y];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Y.

ld_y_dec()

void ld_y_dec	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space using Y register and pre-decrement.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 137 of file data_transfer.c.

                                                                          {
    // Load indirect from data space using Y as address and post-decrement Y
    // Y <- Y - 1
    // Rd <- (Y)
    // 3 cycle
 
    // Execute instruction
    core->gp.Y--;
    core->gp.R[d] = data_space->data[core->gp.Y];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Y.

ld_y_inc()

void ld_y_inc	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space using Y register and post-increment.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 121 of file data_transfer.c.

                                                                          {
    // Load indirect from data space using Y as address and post-increment Y
    // Rd <- (Y)
    // Y <- Y + 1
    // 2 cycle
 
    // Execute instruction
    core->gp.R[d] = data_space->data[core->gp.Y];
    core->gp.Y++;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Y.

ld_z()

void ld_z	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space to register using Z pointer.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 167 of file data_transfer.c.

                                                                      {
    // Load indirect from data space using Z as address
    // Rd <- (Z)
    // 1 cycle
 
    // Execute instruction
    core->gp.R[d] = data_space->data[core->gp.Z];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

ld_z_dec()

void ld_z_dec	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space to register using Z pointer and pre-decrement.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 197 of file data_transfer.c.

                                                                          {
    // Load indirect from data space using Z as address and post-decrement Z
    // Z <- Z - 1
    // Rd <- (Z)
    // 3 cycle
 
    // Execute instruction
    core->gp.Z--;
    core->gp.R[d] = data_space->data[core->gp.Z];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

ld_z_inc()

void ld_z_inc	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space to register using Z pointer and post-increment.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 181 of file data_transfer.c.

                                                                          {
    // Load indirect from data space using Z as address and post-increment Z
    // Rd <- (Z)
    // Z <- Z + 1
    // 2 cycle
 
    // Execute instruction
    core->gp.R[d] = data_space->data[core->gp.Z];
    core->gp.Z++;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

ldd_y()

void ldd_y	(	uint8_t	d,
		uint8_t	q,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space to register using Y pointer with displacement.

Parameters

d	Destination register.
q	Displacement value.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 153 of file data_transfer.c.

                                                                                  {
    // Load indirect with displacement from data space using Y as address
    // Rd <- (Y + q)
    // 2 cycle
 
    // Execute instruction
    core->gp.R[d] = data_space->data[core->gp.Y + q];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Y.

ldd_z()

void ldd_z	(	uint8_t	d,
		uint8_t	q,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load indirect from data space to register using Z pointer with displacement.

Parameters

d	Destination register.
q	Displacement value.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 213 of file data_transfer.c.

                                                                                  {
    // Load indirect with displacement from data space using Z as address
    // Rd <- (Z + q)
    // 2 cycle
 
    // Execute instruction
    core->gp.R[d] = data_space->data[core->gp.Z + q];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

ldi()

void ldi	(	uint8_t	d,
		uint8_t	K,
		struct CORE *	core
	)

Load immediate value K into register d.

Parameters

d	Destination register.
K	Immediate value.
core	Pointer to the CORE structure.

Definition at line 33 of file data_transfer.c.

                                                  {
    // Load immediate 16 <= d <= 31
    // Rd <- K
    // 1 cycle
 
    // Execute instruction
    core->gp.R[d] = K;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

lds()

void lds	(	uint8_t	d,
		int16_t	k,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Load direct from data space using 16-bit address.

Parameters

d	Destination register.
k	16-bit address in data space.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 47 of file data_transfer.c.

                                                                                {
    // Load direct from data space
    // Rd <- k
    // 2 cycles
 
    // Execute instruction
    core->gp.R[d] = data_space->data[k];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), and GP::R.

lpm_0()

void lpm_0	(	struct CORE *	core,
		union PROGMEM_SPACE *	progmem_space
	)

Load program memory into register using Z pointer.

Parameters

core	Pointer to the CORE structure.
progmem_space	Pointer to the PROGMEM_SPACE union.

Definition at line 407 of file data_transfer.c.

                                                                  {
    // Load program memory to R0
    // R0 <- Z
    // 3 cycle
 
    // Execute instruction
    core->gp.R0 = progmem_space->data[core->gp.Z];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References PROGMEM_SPACE::data, CORE::gp, inc_pc(), GP::R0, and GP::Z.

lpm_z()

void lpm_z	(	uint8_t	d,
		struct CORE *	core,
		union PROGMEM_SPACE *	progmem_space
	)

Load program memory into register using Z pointer.

Parameters

d	The register to load into.
core	Pointer to the CORE structure.
progmem_space	Pointer to the PROGMEM_SPACE union.

Definition at line 421 of file data_transfer.c.

                                                                             {    
    // Load program memory to register using Z as address
    // Rd <- (Z)
    // 3 cycle
 
    // Execute instruction
    core->gp.R[d] = progmem_space->data[core->gp.Z];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References PROGMEM_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

lpm_z_inc()

void lpm_z_inc	(	uint8_t	d,
		struct CORE *	core,
		union PROGMEM_SPACE *	progmem_space
	)

Load program memory and post-increment Z register.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
progmem_space	Pointer to the PROGMEM_SPACE union.

Definition at line 435 of file data_transfer.c.

                                                                                 {
    // Load program memory to register using Z as address and post-increment Z
    // Rd <- (Z)
    // Z <- Z + 1
    // 3 cycle
 
    // Execute instruction
    core->gp.R[d] = progmem_space->data[core->gp.Z];
    core->gp.Z++;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References PROGMEM_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

mov()

void mov	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Move data from register r to register d.

Parameters

d	Destination register.
r	Source register.
core	Pointer to the CORE structure.

Definition at line 3 of file data_transfer.c.

                                                  {
    // Copy register r to register d
    // Rd <- Rr
    // 1 cycle
 
    // Execute instruction
    core->gp.R[d] = core->gp.R[r];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

movw()

void movw	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Move word from register pair r to register pair d.

Parameters

d	Destination register pair.
r	Source register pair.
core	Pointer to the CORE structure.

Definition at line 17 of file data_transfer.c.

                                                   {
    // Copy register pair r to register pair d
    // Rd <- Rr
    // Rd+1 <- Rr+1
    // 1 cycle
 
    // Execute instruction
    core->gp.R[d] = core->gp.R[r];
    core->gp.R[d + 1] = core->gp.R[r + 1];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

out()

void out	(	uint8_t	A,
		uint8_t	r,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Write from register to I/O space.

Parameters

A	I/O address.
r	Source register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 465 of file data_transfer.c.

                                                                                {
    // Write to I/O register
    // I/O[A] <- Rr
    // 1 cycle
 
    // Execute instruction
    data_space->io_reg[A] = core->gp.R[r];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), DATA_SPACE::io_reg, and GP::R.

pop()

void pop	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Pop register from stack.

Parameters

d	Destination register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 495 of file data_transfer.c.

                                                                     {
    // Pop register from stack
    // SP <- SP + 1
    // Rd <- (SP)
    // 2 cycle
 
    // Execute instruction
    core->SP++;
    core->gp.R[d] = data_space->sram[core->SP];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, CORE::SP, and DATA_SPACE::sram.

push()

void push	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Push register onto stack.

Parameters

d	Source register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 479 of file data_transfer.c.

                                                                      {
    // Push register to stack
    // (SP) <- Rr
    // SP <- SP - 1 
    // 2 cycle
 
    // Execute instruction
    data_space->sram[core->SP] = core->gp.R[d];
    core->SP--;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, CORE::SP, and DATA_SPACE::sram.

st_x()

void st_x	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store indirect from register to data space using X pointer.

Parameters

d	Source register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 241 of file data_transfer.c.

                                                                      {
    // Store indirect to data space using X as address
    // (X) <- Rd
    // 1 cycle
 
    // Execute instruction
    data_space->data[core->gp.X] = core->gp.R[d];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::X.

st_x_dec()

void st_x_dec	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store indirect from register to data space using X pointer and pre-decrement.

Parameters

d	Source register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 271 of file data_transfer.c.

                                                                          {
    // Store indirect to data space using X as address and post-decrement X
    // X <- X - 1
    // (X) <- Rd
    // 3 cycle
 
    // Execute instruction
    core->gp.X--;
    data_space->data[core->gp.X] = core->gp.R[d];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::X.

st_x_inc()

void st_x_inc	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store indirect from register to data space using X pointer and post-increment.

Parameters

d	Source register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 255 of file data_transfer.c.

                                                                          {
    // Store indirect to data space using X as address and post-increment X
    // (X) <- Rd
    // X <- X + 1
    // 2 cycle
 
    // Execute instruction
    data_space->data[core->gp.X] = core->gp.R[d];
    core->gp.X++;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::X.

st_y()

void st_y	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store indirect from register to data space using Y pointer.

Parameters

d	Source register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 287 of file data_transfer.c.

                                                                      {
    // Store indirect to data space using Y as address
    // (Y) <- Rd
    // 1 cycle
 
    // Execute instruction
    data_space->data[core->gp.Y] = core->gp.R[d];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Y.

st_y_dec()

void st_y_dec	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store register to data space using Y pointer and pre-decrement Y.

Parameters

d	The register to store.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 317 of file data_transfer.c.

                                                                          {
    // Store indirect to data space using Y as address and post-decrement Y
    // Y <- Y - 1
    // (Y) <- Rd
    // 3 cycle
 
    // Execute instruction
    core->gp.Y--;
    data_space->data[core->gp.Y] = core->gp.R[d];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Y.

st_y_inc()

void st_y_inc	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store register to data space using Y pointer and post-increment Y.

Parameters

d	The register to store.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 301 of file data_transfer.c.

                                                                          {
    // Store indirect to data space using Y as address and post-increment Y
    // (Y) <- Rd
    // Y <- Y + 1
    // 2 cycle
 
    // Execute instruction
    data_space->data[core->gp.Y] = core->gp.R[d];
    core->gp.Y++;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Y.

st_z()

void st_z	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store register to data space using Z pointer.

Parameters

d	The register to store.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 347 of file data_transfer.c.

                                                                      {
    // Store indirect to data space using Z as address
    // (Z) <- Rd
    // 1 cycle
 
    // Execute instruction
    data_space->data[core->gp.Z] = core->gp.R[d];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

st_z_dec()

void st_z_dec	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store register to data space using Z pointer and pre-decrement Z.

Parameters

d	The register to store.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 377 of file data_transfer.c.

                                                                          {
    // Store indirect to data space using Z as address and post-decrement Z
    // Z <- Z - 1
    // (Z) <- Rd
    // 3 cycle
 
    // Execute instruction
    core->gp.Z--;
    data_space->data[core->gp.Z] = core->gp.R[d];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

st_z_inc()

void st_z_inc	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store register to data space using Z pointer and post-increment Z.

Parameters

d	The register to store.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 361 of file data_transfer.c.

                                                                          {
    // Store indirect to data space using Z as address and post-increment Z
    // (Z) <- Rd
    // Z <- Z + 1
    // 2 cycle
 
    // Execute instruction
    data_space->data[core->gp.Z] = core->gp.R[d];
    core->gp.Z++;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

std_y()

void std_y	(	uint8_t	d,
		uint8_t	q,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store register to data space using Y pointer with displacement.

Parameters

d	The register to store.
q	The displacement value.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 333 of file data_transfer.c.

                                                                                  {
    // Store indirect with displacement to data space using Y as address
    // (Y + q) <- Rd
    // 2 cycle
 
    // Execute instruction
    data_space->data[core->gp.Y + q] = core->gp.R[d];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Y.

std_z()

void std_z	(	uint8_t	d,
		uint8_t	q,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store register to data space using Z pointer with displacement.

Parameters

d	The register to store.
q	The displacement value.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 393 of file data_transfer.c.

                                                                                  {
    // Store indirect with displacement to data space using Z as address
    // (Z + q) <- Rd
    // 2 cycle
 
    // Execute instruction
    data_space->data[core->gp.Z + q] = core->gp.R[d];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.

sts()

void sts	(	int16_t	k,
		uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Store direct from register to data space.

Parameters

k	Address in data space.
d	Source register.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 227 of file data_transfer.c.

                                                                                {
    // Store direct to data space
    // k <- Rd
    // 2 cycles
 
    // Execute instruction
    data_space->data[k] = core->gp.R[d];
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), and GP::R.

xch()

void xch	(	uint8_t	d,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Exchange register with data space.

Parameters

d	Register to exchange.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 511 of file data_transfer.c.

                                                                     {
    // Exchange register with stack
    // Rd <-> (SP)
    // 2 cycle
 
    // Execute instruction
    uint8_t temp = core->gp.R[d];
    core->gp.R[d] = data_space->data[core->gp.Z];
    data_space->data[core->gp.Z] = temp;
 
    // Update SREG
    // NONE
 
    inc_pc(core);
}

References DATA_SPACE::data, CORE::gp, inc_pc(), GP::R, and GP::Z.