copied from older project

src/display.cpp

@@ -0,0 +1,178 @@
+#include <Arduino.h>
+#include <Streaming.h>
+
+#include "mySpi.h"
+#include "display.h"
+
+#include "hardware.h"
+
+
+
+typedef struct display_s {
+  int16_t old_value;
+} display_t;
+
+display_t displays[NUM_OF_DISP_UNITS];
+
+uint8_t old_disable = 247; // illegal value
+
+void dispInit() {
+  pinMode(DISP_CS_PIN, OUTPUT);
+
+
+  spiXfer16(DISP_CS_PIN, 0x09ff); // decode mode
+  spiXfer16(DISP_CS_PIN, 0x0a01); // intensity
+
+  spiXfer16(DISP_CS_PIN, 0x0b03); // scan limit
+
+  spiXfer16(DISP_CS_PIN, 0x0c01); // normal op
+
+  spiXfer16(DISP_CS_PIN, 0x0f00); // led test: normal
+
+  for (uint8_t i = 0; i < NUM_OF_DISP_UNITS; i++) {
+    displays[i].old_value = 11111; // illegal value
+  }
+}
+
+void dispDisable(uint8_t disable) {
+  if (disable != old_disable) {
+    old_disable = disable;
+    if (disable) {
+      spiXfer16(DISP_CS_PIN, 0x0c00);
+    } else {
+      spiXfer16(DISP_CS_PIN, 0x0c01);
+    }
+  }
+}
+
+void dispSetError() {
+  spiXfer16(DISP_CS_PIN, 0x010f);
+  spiXfer16(DISP_CS_PIN, 0x020f);
+  spiXfer16(DISP_CS_PIN, 0x030f);
+  spiXfer16(DISP_CS_PIN, 0x040b);
+}
+
+#define MAX_DIGIT 4
+
+void dispSetDigit(uint8_t digit, uint8_t value) {
+  if ((digit > MAX_DIGIT) || (digit == 0) || (value > 9)) {
+    dispSetError();
+  } else {
+    uint16_t v = (((uint16_t) digit) << 8) | value;
+    spiXfer16(DISP_CS_PIN, v);
+  }
+}
+
+
+void dispSetFloat(float value) {
+  if ((value < -99) || (value > 999)) {
+    dispSetError();
+  } else {
+    uint8_t neg = (value < 0) ? 1 : 0;
+    value = abs(value);
+    uint16_t preComma = (uint16_t)value;
+    uint16_t postComma = round((value - (float)preComma) * 10);
+    if (postComma == 10) {
+      postComma = 0;
+      preComma += 1;
+    }
+    if ((preComma == 0) && (postComma == 0)) {
+      neg = false;
+    }
+
+    uint8_t digit1 = preComma / 100;
+    uint8_t remVal = preComma - (digit1 * 100);
+    uint8_t digit2 = remVal / 10;
+    remVal = remVal - (digit2 * 10);
+    uint8_t digit3 = remVal;
+
+    if (digit1 == 0) {
+      if (neg) {
+        digit1 = 0x0a;
+      } else {
+        digit1 = 0x0f;
+      }
+    }
+
+    if (digit1 > 0x09 && digit2 == 0) {
+      if (neg) {
+        digit2 = 0x0a;
+        digit1 = 0x0f;
+      } else {
+        digit2 = 0x0f;
+      }
+    }
+
+    digit3 |= 0x80;
+
+    spiXfer16(DISP_CS_PIN, 0x0100 | digit1);
+    spiXfer16(DISP_CS_PIN, 0x0200 | digit2);
+    spiXfer16(DISP_CS_PIN, 0x0300 | digit3);
+
+    spiXfer16(DISP_CS_PIN, 0x0400 | postComma);
+
+
+  }
+}
+
+void dispSet(uint8_t unit, int16_t value) {
+  if (displays[unit].old_value != value) {
+    displays[unit].old_value = value;
+
+    if ((value < -999) || (value > 9999)) {
+      dispSetError();
+    } else {
+      uint8_t neg = (value < 0) ? 1 : 0;
+      value = abs(value);
+
+      uint8_t digit0 = value / 1000;
+      uint16_t remVal = value - (digit0 * 1000);
+      uint8_t digit1 = remVal / 100;
+      remVal = remVal - (digit1 * 100);
+      uint8_t digit2 = remVal / 10;
+      remVal = remVal - (digit2 * 10);
+      uint8_t digit3 = remVal;
+
+      if (digit0 == 0) {
+        if (neg) {
+          digit0 = 0x0a;
+        } else {
+          digit0 = 0x0f;
+        }
+      }
+
+      if (digit0 > 0x09 && digit1 == 0) {
+        if (neg) {
+          digit1 = 0x0a;
+          digit0 = 0x0f;
+        } else {
+          digit1 = 0x0f;
+        }
+      }
+
+      if (digit0 > 0x09 && digit1 > 0x09 && digit2 == 0) {
+        if (neg) {
+          digit2 = 0x0a;
+          digit1 = 0x0f;
+        } else {
+          digit2 = 0x0f;
+        }
+      }
+
+      if (unit == 0) {
+        spiXfer16(DISP_CS_PIN, 0x0100 | digit0);
+        spiXfer16(DISP_CS_PIN, 0x0200 | digit1);
+        spiXfer16(DISP_CS_PIN, 0x0300 | digit2);
+        spiXfer16(DISP_CS_PIN, 0x0400 | digit3);
+      } else {
+        spiXfer16(DISP_CS_PIN, 0x0500 | digit0);
+        spiXfer16(DISP_CS_PIN, 0x0600 | digit1);
+        spiXfer16(DISP_CS_PIN, 0x0700 | digit2);
+        spiXfer16(DISP_CS_PIN, 0x0800 | digit3);
+      }
+    }
+  }
+}
+
+
+

src/display.h

@@ -0,0 +1,22 @@
+#include <stdint.h>
+
+#ifndef DISPLAY_H_
+#define DISPLAY_H_
+
+
+#define NUM_OF_DISP_UNITS 1
+
+
+
+void dispInit();
+void dispSetError();
+void dispSetDigit(uint8_t digit, uint8_t value);
+
+void dispSet(uint8_t unit, int16_t value);
+void dispSetFloat(float value);
+
+void dispDisable(uint8_t disable);
+
+
+
+#endif /* DISPLAY_H_ */

src/mySpi.cpp

@@ -0,0 +1,40 @@
+#include "mySpi.h"
+#include <SPI.h>
+
+void spiInit() {
+  SPI.begin();
+
+  SPI.setBitOrder(MSBFIRST);
+  SPI.setClockDivider(SPI_CLOCK_DIV4);
+  SPI.setDataMode(SPI_MODE0);
+}
+
+static void _spiSetCS(uint8_t cs) {
+  digitalWrite(cs, LOW);
+}
+
+static void _spiReleaseCS(uint8_t cs) {
+  digitalWrite(cs, HIGH);
+}
+
+static uint8_t __spiXfer(uint8_t o) {
+  return SPI.transfer(o);
+}
+
+uint8_t spiXfer16(uint8_t cs, uint16_t o) {
+  _spiSetCS(cs);
+  __spiXfer((o >> 8) & 0x0ff);
+  uint8_t res = __spiXfer(o & 0x0ff);
+  _spiReleaseCS(cs);
+  return res;
+}
+
+uint16_t spiXferD16(uint8_t cs, uint16_t o) {
+  _spiSetCS(cs);
+  uint16_t res = __spiXfer((o >> 8) & 0x0ff);
+  res <<= 8;
+  res |= __spiXfer(o && 0x0ff);
+  _spiReleaseCS(cs);
+  return res;
+}
+

src/mySpi.h

@@ -0,0 +1,18 @@
+/*
+ * spi.H
+ *
+ *  Created on: 03.07.2012
+ *      Author: wn
+ */
+
+#ifndef MY_SPI_H_
+#define MY_SPI_H_
+
+#include <stdint.h>
+
+
+void spiInit();
+uint8_t spiXfer16(uint8_t cs, uint16_t o);
+uint16_t spiXferD16(uint8_t cs, uint16_t o);
+
+#endif /* MY_SPI_H_ */