epaper/epd/epd.c

/* epd.c - E-Paper Display library API */

/* Includes */
#include "epd.h"
#include "string.h"
#include "util.h"

/* Function Definitions */
/**
 * \brief   initialize a new epd object
 *
 * \details Initialize a new epd object given the configuration options.
 *
 * \param[in,out] epd  pointer to an epd_t
 * \param[in]     cfg  pointer to a populated epd_platform_config_t
 */
void epd_init(epd_t *epd, epd_platform_config_t *cfg)
{
	memcpy(&(epd->platform), cfg, sizeof(epd_platform_config_t));
	epd->dbuf = NULL;
	epd->font = NULL;
	epd->draw_color = 0x00;
	epd->display.w = 0;
	epd->display.h = 0;
}

/* Function Definitions */
/**
 * \brief   initialize a new display
 *
 * \details Initialize and configure a new display.
 *
 * \param[in,out] epd  pointer to an epd_t
 * \param[in]     cfg  pointer to a populated epd_display_config_t
 */
void epd_display_init(epd_t *epd, epd_display_config_t *cfg)
{
	memcpy(&(epd->display), cfg, sizeof(epd_display_config_t));
}

/**
 * \brief   attach a display buffer to the epd_t object
 *
 * \details Attach a display buffer to the epd_t object to do things which
 *          require buffering.
 *
 * \param[in,out] epd  pointer to an epd_t
 * \param[in,out] dbuf pointer to a dbuf_t array large enough to hold the data
 *                     for this display
 *
 * \return        0 on success; otherwise failure
 */
int8_t epd_dbuf_set(epd_t *epd, epd_dbuf_t *dbuf)
{
	return_val_if_fail(epd, -1);
	return_val_if_fail(dbuf, -1);

	epd->dbuf = dbuf;
	memset(epd->dbuf, 0xff, (epd->display.w * epd->display.h * sizeof(epd_dbuf_t) / 8));

	return 0;
}

/**
 * \brief   clear a display buffer
 *
 * \details Clear the display buffer attached to an epd_t object.
 *
 * \param[in,out] epd  pointer to an epd_t
 *
 * \return        0 on success; otherwise failure
 */
int8_t epd_dbuf_clear(epd_t *epd)
{
	return_val_if_fail(epd, -1);
	return_val_if_fail(epd->dbuf, -1);

	memset(epd->dbuf, 0xff, (epd->display.w * epd->display.h * sizeof(epd_dbuf_t) / 8));

	return 0;
}

/**
 * \brief   draw a line
 *
 * \details Draw a horizontal or vertical line on the display buffer.
 *
 * \param[in,out] epd  pointer to an epd_t
 * \param[in]     x    starting x coordinate
 * \param[in]     y    starting y coordinate
 * \param[in]     len  length of the line
 * \param[in]     dir  direction of the line
 */
void epd_draw_line(epd_t *epd, uint16_t x, uint16_t y, uint16_t len, epd_dir_t dir)
{
	uint32_t i;
	epd_dbuf_t tmp;
	uint16_t boundary;

	return_if_fail(epd);
	return_if_fail(epd->dbuf);
	return_if_fail(len);
	return_if_fail(x < (epd->display.w * 8));
	return_if_fail(y < epd->display.h);

	switch (dir)
	{
	case EPD_DIR_L2R:
		/* calculate first byte boundary */
		boundary = MIN((x % 8) + len, 8);
		/* calculate byte at left of line */
		tmp = 0xff;
		for (i = x % 8; i < boundary; i++)
		{
			tmp &= ~(0x80 >> i);
		}
		epd->dbuf[x / 8 + (y * epd->display.w) / 8] &= tmp;
		/* calculate full bytes */
		for (i = (x + 7) / 8; i < (x + len) / 8; i++)
		{
			epd->dbuf[i + (y * epd->display.w) / 8] &= 0x00;
		}
		/* calculate byte at right of line */
		if((x % 8) + len < 8)
		{
			break;
		}
		tmp = 0xff;
		for (i = 8 - ((x + len) % 8); i < boundary; i++)
		{
			tmp &= ~(0x01 << i);
		}
		epd->dbuf[(x + len) / 8 + (y * epd->display.w) / 8] &= tmp;
#		if defined(AIDS)
		for (i = (x + 7) / 8; i < (x + len) / 8; i++)
		{
			epd->dbuf[i + (y * epd->display.w) / 8] &= 0x00;
		}
		/* calculate byte at left of line */
		tmp = 0x00;
		for (i = x % 8; i < MIN(len, 8); i++)
		{
			tmp <<= 1;
			tmp |= 0x01;
		}
		epd->dbuf[x / 8 + (y * epd->display.w) / 8] &= ~tmp;
		/* calculate byte at right of line */
		tmp = 0x00;
		for (i = 7 - ((x + len) % 8); i < MIN(len, 8); i++)
		{
			tmp >>= 1;
			tmp |= 0x80;
		}
		epd->dbuf[(x + len) / 8 + (y * epd->display.w) / 8] &= ~tmp;
#		endif
		break;
	case EPD_DIR_T2B:
		for (i = y; i < (y + len); i++)
		{
			epd->dbuf[(x + i * epd->display.w) / 8] &= ~(0x80 >> (x % 8));
		}
		break;
	case EPD_DIR_R2L:
		break;
	case EPD_DIR_B2T:
		return_if_fail(y - len >= 0);
		for (i = y; i > (y - len); i--)
		{
			epd->dbuf[(x + i * epd->display.w) / 8] &= ~(0x80 >> (x % 8));
		}
		break;
	default:
		return;
	}
}

/**
 * \brief   send the dbuf to the display
 *
 * \details Display the contents of the dbuf on the screen.
 *
 * \param[in,out] epd  pointer to an epd_t
 *
 * \returns 0 on success
 */
int32_t epd_update(epd_t *epd)
{
	return_val_if_fail(epd, -1);
	return_val_if_fail(epd->dbuf, -1);

	return epd->display.write(epd);
}

/**
 * \brief   send the dbuf to the display
 *
 * \details Display the contents of the dbuf on the screen within a specified
 * window. Falls back on a full update if the display does not implement
 * partial updates.
 *
 * \param[in,out] epd  pointer to an epd_t
 * \param[in] x0 x-coordinate of first pixel in window
 * \param[in] x1 x-coordinate of last pixel in window
 * \param[in] y0 y-coordinate of first pixel in window
 * \param[in] y1 y-coordinate of last pixel in window
 *
 * \returns 0 on success
 */
int32_t epd_update_partial(epd_t *epd, uint16_t x0, uint16_t x1, uint16_t y0, uint16_t y1)
{
	return_val_if_fail(epd, -1);
	return_val_if_fail(epd->dbuf, -1);

	if(epd->display.write_partial)
	{
		return epd->display.write_partial(epd, x0, x1, y0, y1);
	}
	else
	{
		return epd->display.write(epd);
	}
}