initial git upload, based on graphlcd-base-0.1.5

1 files changed, 355 insertions, 0 deletions

diff --git a/glcddrivers/avrctl.c b/glcddrivers/avrctl.c
new file mode 100644
index 0000000..4e1e4ea
--- /dev/null
+++ b/glcddrivers/avrctl.c
@@ -0,0 +1,355 @@
+/*
+ * GraphLCD driver library
+ *
+ * avrctl.c  -  AVR controlled LCD driver class
+ *
+ * This file is released under the GNU General Public License. Refer
+ * to the COPYING file distributed with this package.
+ *
+ * (c) 2005 Andreas Regel <andreas.regel AT powarman.de>
+ */
+
+#include <stdint.h>
+#include <syslog.h>
+
+#include "common.h"
+#include "config.h"
+#include "port.h"
+#include "avrctl.h"
+
+
+namespace GLCD
+{
+
+/* command header:
+**  8 bits  sync byte (0xAA for sent commands, 0x55 for received commands)
+**  8 bits  command id
+** 16 bits  command length (excluding header)
+*/
+const unsigned char CMD_HDR_SYNC    = 0;
+const unsigned char CMD_HDR_COMMAND = 1;
+const unsigned char CMD_HDR_LENGTH  = 2;
+const unsigned char CMD_DATA_START  = 4;
+
+const unsigned char CMD_SYNC_SEND = 0xAA;
+const unsigned char CMD_SYNC_RECV = 0x55;
+
+const unsigned char CMD_SYS_SYNC = 0x00;
+const unsigned char CMD_SYS_ACK  = 0x01;
+
+const unsigned char CMD_DISP_CLEAR_SCREEN   = 0x10;
+const unsigned char CMD_DISP_SWITCH_SCREEN  = 0x11;
+const unsigned char CMD_DISP_SET_BRIGHTNESS = 0x12;
+const unsigned char CMD_DISP_SET_COL_DATA   = 0x13;
+const unsigned char CMD_DISP_SET_ROW_DATA   = 0x14;
+const unsigned char CMD_DISP_UPDATE         = 0x15;
+
+const int kBufferWidth  = 256;
+const int kBufferHeight = 128;
+
+
+cDriverAvrCtl::cDriverAvrCtl(cDriverConfig * config)
+:   config(config)
+{
+    oldConfig = new cDriverConfig(*config);
+
+    port = new cSerialPort();
+
+    //width = config->width;
+    //height = config->height;
+    refreshCounter = 0;
+}
+
+cDriverAvrCtl::~cDriverAvrCtl()
+{
+    delete port;
+    delete oldConfig;
+}
+
+int cDriverAvrCtl::Init()
+{
+    int x;
+
+    width = config->width;
+    if (width <= 0)
+        width = 256;
+    height = config->height;
+    if (height <= 0)
+        height = 128;
+
+    for (unsigned int i = 0; i < config->options.size(); i++)
+    {
+        if (config->options[i].name == "")
+        {
+        }
+    }
+
+    // setup lcd array (wanted state)
+    newLCD = new unsigned char*[kBufferWidth];
+    if (newLCD)
+    {
+        for (x = 0; x < kBufferWidth; x++)
+        {
+            newLCD[x] = new unsigned char[(kBufferHeight + 7) / 8];
+            memset(newLCD[x], 0, (kBufferHeight + 7) / 8);
+        }
+    }
+    // setup lcd array (current state)
+    oldLCD = new unsigned char*[kBufferWidth];
+    if (oldLCD)
+    {
+        for (x = 0; x < kBufferWidth; x++)
+        {
+            oldLCD[x] = new unsigned char[(kBufferHeight + 7) / 8];
+            memset(oldLCD[x], 0, (kBufferHeight + 7) / 8);
+        }
+    }
+
+    if (config->device == "")
+    {
+        return -1;
+    }
+    if (port->Open(config->device.c_str()) != 0)
+        return -1;
+
+    *oldConfig = *config;
+
+    // clear display
+    Clear();
+
+    syslog(LOG_INFO, "%s: AvrCtl initialized.\n", config->name.c_str());
+    return 0;
+}
+
+int cDriverAvrCtl::DeInit()
+{
+    int x;
+    // free lcd array (wanted state)
+    if (newLCD)
+    {
+        for (x = 0; x < kBufferWidth; x++)
+        {
+            delete[] newLCD[x];
+        }
+        delete[] newLCD;
+    }
+    // free lcd array (current state)
+    if (oldLCD)
+    {
+        for (x = 0; x < kBufferWidth; x++)
+        {
+            delete[] oldLCD[x];
+        }
+        delete[] oldLCD;
+    }
+
+    if (port->Close() != 0)
+        return -1;
+    return 0;
+}
+
+int cDriverAvrCtl::CheckSetup()
+{
+    if (config->device != oldConfig->device ||
+        config->width != oldConfig->width ||
+        config->height != oldConfig->height)
+    {
+        DeInit();
+        Init();
+        return 0;
+    }
+
+    if (config->upsideDown != oldConfig->upsideDown ||
+        config->invert != oldConfig->invert)
+    {
+        oldConfig->upsideDown = config->upsideDown;
+        oldConfig->invert = config->invert;
+        return 1;
+    }
+    return 0;
+}
+
+void cDriverAvrCtl::Clear()
+{
+    for (int x = 0; x < kBufferWidth; x++)
+        memset(newLCD[x], 0, (kBufferHeight + 7) / 8);
+}
+
+void cDriverAvrCtl::Set8Pixels(int x, int y, unsigned char data)
+{
+    if (x >= width || y >= height)
+        return;
+
+    if (!config->upsideDown)
+    {
+        int offset = 7 - (y % 8);
+        for (int i = 0; i < 8; i++)
+        {
+            newLCD[x + i][y / 8] |= ((data >> (7 - i)) << offset) & (1 << offset);
+        }
+    }
+    else
+    {
+        x = width - 1 - x;
+        y = height - 1 - y;
+        int offset = 7 - (y % 8);
+        for (int i = 0; i < 8; i++)
+        {
+            newLCD[x - i][y / 8] |= ((data >> (7 - i)) << offset) & (1 << offset);
+        }
+    }
+}
+
+void cDriverAvrCtl::Refresh(bool refreshAll)
+{
+    int x;
+    int y;
+    int i;
+    int num = kBufferWidth / 2;
+    unsigned char data[16*num];
+
+    if (CheckSetup() == 1)
+        refreshAll = true;
+
+    if (config->refreshDisplay > 0)
+    {
+        refreshCounter = (refreshCounter + 1) % config->refreshDisplay;
+        if (!refreshAll && !refreshCounter)
+            refreshAll = true;
+    }
+
+    refreshAll = true;
+    if (refreshAll)
+    {
+        for (x = 0; x < kBufferWidth; x += num)
+        {
+            for (i = 0; i < num; i++)
+            {
+                for (y = 0; y < (kBufferHeight + 7) / 8; y++)
+                {
+                    data[i * ((kBufferHeight + 7) / 8) + y] = (newLCD[x + i][y]) ^ (config->invert ? 0xff : 0x00);
+                }
+                memcpy(oldLCD[x + i], newLCD[x + i], (kBufferHeight + 7) / 8);
+            }
+            CmdDispSetColData(x, 0, 16 * num, data);
+        }
+        CmdDispUpdate();
+        CmdDispSwitchScreen();
+        // and reset RefreshCounter
+        refreshCounter = 0;
+    }
+    else
+    {
+        // draw only the changed bytes
+    }
+}
+
+void cDriverAvrCtl::SetBrightness(unsigned int percent)
+{
+  CmdDispSetBrightness(percent);
+}
+
+int cDriverAvrCtl::WaitForAck(void)
+{
+    uint8_t cmd[4];
+    int len;
+    int timeout = 10000;
+
+    len = 0;
+    while (len < 4 && timeout > 0)
+    {
+        len += port->ReadData(&cmd[len]);
+        timeout--;
+    }
+    if (timeout == 0)
+        return 0;
+    return 1;
+}
+
+void cDriverAvrCtl::CmdSysSync(void)
+{
+    uint8_t cmd[4];
+
+    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;
+    cmd[CMD_HDR_COMMAND] = CMD_SYS_SYNC;
+    cmd[CMD_HDR_LENGTH] = 0;
+    cmd[CMD_HDR_LENGTH+1] = 0;
+
+    port->WriteData(cmd, 4);
+    WaitForAck();
+}
+
+void cDriverAvrCtl::CmdDispClearScreen(void)
+{
+    uint8_t cmd[4];
+
+    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;
+    cmd[CMD_HDR_COMMAND] = CMD_DISP_CLEAR_SCREEN;
+    cmd[CMD_HDR_LENGTH] = 0;
+    cmd[CMD_HDR_LENGTH+1] = 0;
+
+    port->WriteData(cmd, 4);
+    WaitForAck();
+}
+
+void cDriverAvrCtl::CmdDispSwitchScreen(void)
+{
+    uint8_t cmd[4];
+
+    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;
+    cmd[CMD_HDR_COMMAND] = CMD_DISP_SWITCH_SCREEN;
+    cmd[CMD_HDR_LENGTH] = 0;
+    cmd[CMD_HDR_LENGTH+1] = 0;
+
+    port->WriteData(cmd, 4);
+    WaitForAck();
+}
+
+void cDriverAvrCtl::CmdDispSetBrightness(uint8_t percent)
+{
+    uint8_t cmd[5];
+
+    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;
+    cmd[CMD_HDR_COMMAND] = CMD_DISP_SET_BRIGHTNESS;
+    cmd[CMD_HDR_LENGTH] = 0;
+    cmd[CMD_HDR_LENGTH+1] = 1;
+    cmd[CMD_DATA_START] = percent;
+
+    port->WriteData(cmd, 5);
+    WaitForAck();
+}
+
+void cDriverAvrCtl::CmdDispSetColData(uint16_t column, uint16_t offset, uint16_t length, uint8_t * data)
+{
+    uint8_t cmd[2560];
+
+    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;
+    cmd[CMD_HDR_COMMAND] = CMD_DISP_SET_COL_DATA;
+    cmd[CMD_HDR_LENGTH] = (length + 6) >> 8;
+    cmd[CMD_HDR_LENGTH+1] = (length + 6);
+    cmd[CMD_DATA_START] = column >> 8;
+    cmd[CMD_DATA_START+1] = column;
+    cmd[CMD_DATA_START+2] = offset >> 8;
+    cmd[CMD_DATA_START+3] = offset;
+    cmd[CMD_DATA_START+4] = length >> 8;
+    cmd[CMD_DATA_START+5] = length;
+    memcpy(&cmd[CMD_DATA_START+6], data, length);
+
+    port->WriteData(cmd, length+10);
+    WaitForAck();
+}
+
+void cDriverAvrCtl::CmdDispUpdate(void)
+{
+    uint8_t cmd[4];
+
+    cmd[CMD_HDR_SYNC] = CMD_SYNC_SEND;
+    cmd[CMD_HDR_COMMAND] = CMD_DISP_UPDATE;
+    cmd[CMD_HDR_LENGTH] = 0;
+    cmd[CMD_HDR_LENGTH+1] = 0;
+
+    port->WriteData(cmd, 4);
+    WaitForAck();
+}
+
+}