data_transfer.h File Reference

Data transfer instructions. More...

#include <stdint.h>
#include <stdbool.h>
#include "core.h"
#include "data_space.h"

Include dependency graph for data_transfer.h:

This graph shows which files directly or indirectly include this file:

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.

Detailed Description

Data transfer instructions.

Contains all atomic data transfer instructions

Author

Antonin Pivard

Date

2024

Warning

Not tested

Copyright

GNU General Public License v3.0

Definition in file data_transfer.h.

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.