Revision 0:e4ea0ca99174, committed 2010-11-04

Comitter:

mrfurious

Date:

Thu Nov 04 23:00:34 2010 +0000

Commit message:

1.1.1

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FontPack.cpp	Thu Nov 04 23:00:34 2010 +0000
@@ -0,0 +1,227 @@
+#include "FontPack.h"
+#include "mbed.h"
+
+using namespace FontPack;
+using namespace std;
+
+static const char FONTPACK_CHAR_WIDTH=5;
+
+//numbers
+static const char FONTPACK_0[FONTPACK_CHAR_WIDTH] = {0x7E, 0xE1, 0x99, 0x87, 0x7E};
+static const char FONTPACK_1[FONTPACK_CHAR_WIDTH] = {0x21, 0x41, 0xFF, 0x01, 0x01};
+static const char FONTPACK_2[FONTPACK_CHAR_WIDTH] = {0x63, 0x85, 0x89, 0x91, 0x61};
+static const char FONTPACK_3[FONTPACK_CHAR_WIDTH] = {0x42, 0x81, 0x91, 0x91, 0x6E};
+static const char FONTPACK_4[FONTPACK_CHAR_WIDTH] = {0x18, 0x28, 0x48, 0xFF, 0x08};
+static const char FONTPACK_5[FONTPACK_CHAR_WIDTH] = {0xF2, 0x91, 0x91, 0x91, 0x8E};
+static const char FONTPACK_6[FONTPACK_CHAR_WIDTH] = {0x7E, 0x91, 0x91, 0x91, 0x4E};
+static const char FONTPACK_7[FONTPACK_CHAR_WIDTH] = {0x80, 0x8F, 0x90, 0xA0, 0xC0};
+static const char FONTPACK_8[FONTPACK_CHAR_WIDTH] = {0x6E, 0x91, 0x91, 0x91, 0x6E};
+static const char FONTPACK_9[FONTPACK_CHAR_WIDTH] = {0x70, 0x88, 0x88, 0x90, 0x7F};
+//letters
+static const char FONTPACK_A[FONTPACK_CHAR_WIDTH] = {0x3F, 0x48, 0x88, 0x48, 0x3F};
+static const char FONTPACK_B[FONTPACK_CHAR_WIDTH] = {0xFF, 0x91, 0x91, 0x91, 0x6E};
+static const char FONTPACK_C[FONTPACK_CHAR_WIDTH] = {0x7E, 0x81, 0x81, 0x81, 0x42};
+static const char FONTPACK_D[FONTPACK_CHAR_WIDTH] = {0xFF, 0x81, 0x81, 0x81, 0x7E};
+static const char FONTPACK_E[FONTPACK_CHAR_WIDTH] = {0xFF, 0x91, 0x91, 0x91, 0x91};
+static const char FONTPACK_F[FONTPACK_CHAR_WIDTH] = {0xFF, 0x90, 0x90, 0x90, 0x80};
+static const char FONTPACK_G[FONTPACK_CHAR_WIDTH] = {0x7E, 0x89, 0x89, 0x6E, 0x08}; //{0x7E, 0x89, 0x89, 0x89, 0x4E}; //
+static const char FONTPACK_H[FONTPACK_CHAR_WIDTH] = {0xFF, 0x10, 0x10, 0x10, 0xFF};
+static const char FONTPACK_I[FONTPACK_CHAR_WIDTH] = {0x81, 0x81, 0xFF, 0x81, 0x81};
+static const char FONTPACK_J[FONTPACK_CHAR_WIDTH] = {0x86, 0x81, 0x81, 0xFE, 0x80};
+static const char FONTPACK_K[FONTPACK_CHAR_WIDTH] = {0xFF, 0x18, 0x28, 0x44, 0x83};
+static const char FONTPACK_L[FONTPACK_CHAR_WIDTH] = {0xFF, 0x01, 0x01, 0x01, 0x01};
+static const char FONTPACK_M[FONTPACK_CHAR_WIDTH] = {0x7F, 0x80, 0x7C, 0x80, 0x7F};
+static const char FONTPACK_N[FONTPACK_CHAR_WIDTH] = {0xFF, 0x60, 0x18, 0x06, 0xFF};
+static const char FONTPACK_O[FONTPACK_CHAR_WIDTH] = {0x7E, 0x81, 0x81, 0x81, 0x7E};
+static const char FONTPACK_P[FONTPACK_CHAR_WIDTH] = {0xFF, 0x88, 0x88, 0x88, 0x70};
+static const char FONTPACK_Q[FONTPACK_CHAR_WIDTH] = {0x7E, 0x89, 0x85, 0x7E, 0x01};
+static const char FONTPACK_R[FONTPACK_CHAR_WIDTH] = {0xFF, 0x88, 0x88, 0x98, 0x6F};
+static const char FONTPACK_S[FONTPACK_CHAR_WIDTH] = {0x62, 0x91, 0x91, 0x91, 0x4E};
+static const char FONTPACK_T[FONTPACK_CHAR_WIDTH] = {0x80, 0x80, 0xFF, 0x80, 0x80};
+static const char FONTPACK_U[FONTPACK_CHAR_WIDTH] = {0xFE, 0x01, 0x01, 0x01, 0xFE};
+static const char FONTPACK_V[FONTPACK_CHAR_WIDTH] = {0xFC, 0x02, 0x01, 0x02, 0xFC};
+static const char FONTPACK_W[FONTPACK_CHAR_WIDTH] = {0xFE, 0x01, 0x0E, 0x01, 0xFE};
+static const char FONTPACK_X[FONTPACK_CHAR_WIDTH] = {0xC7, 0x28, 0x10, 0x28, 0xC7};
+static const char FONTPACK_Y[FONTPACK_CHAR_WIDTH] = {0xE0, 0x10, 0x0F, 0x10, 0xE0};
+static const char FONTPACK_Z[FONTPACK_CHAR_WIDTH] = {0x83, 0x85, 0x99, 0xA1, 0xC1};
+
+//special characters
+static const char FONTPACK_COLON[FONTPACK_CHAR_WIDTH] = {0x00, 0x00, 0x24, 0x00, 0x00};
+static const char FONTPACK_SPACE[FONTPACK_CHAR_WIDTH] = {0,0,0,0,0};
+static const char FONTPACK_PERIOD[FONTPACK_CHAR_WIDTH] = {0x00, 0x00, 0x03, 0x03, 0x00};
+static const char FONTPACK_EXCLAMATION[FONTPACK_CHAR_WIDTH] ={0x00, 0x00, 0xFB, 0xFB, 0x00};
+
+
+int FontPack::writeChar(char c, char map[], int index, int col) {
+    int out=index;
+    FontPackChar myChar = getChar(c);
+    if (col >= myChar.nCols) return index; //do nothing
+    for (int i=0; i < myChar.nCols; i++) {
+        out++;
+        map[index+i] = myChar.getCol(i);
+    }
+    return out+1; //gives a bit of space between letters
+}
+
+int FontPack::blank(int index) {
+    return index+1;
+}
+
+FontPackChar FontPack::getChar(char a) {
+    FontPackChar myChar;
+    myChar.nCols = FONTPACK_CHAR_WIDTH;
+
+    switch (a) {
+        case '0':
+            myChar.col = FONTPACK_0;
+            break;
+        case '1':
+            myChar.col = FONTPACK_1;
+            break;
+        case '2':
+            myChar.col = FONTPACK_2;
+            break;
+        case '3':
+            myChar.col = FONTPACK_3;
+            break;
+        case '4':
+            myChar.col = FONTPACK_4;
+            break;
+        case '5':
+            myChar.col = FONTPACK_5;
+            break;
+        case '6':
+            myChar.col = FONTPACK_6;
+            break;
+        case '7':
+            myChar.col = FONTPACK_7;
+            break;
+        case '8':
+            myChar.col = FONTPACK_8;
+            break;
+        case '9':
+            myChar.col = FONTPACK_9;
+            break;
+        case 'A':
+        case 'a':
+            myChar.col = FONTPACK_A;
+            break;
+        case 'B':
+        case 'b':
+            myChar.col = FONTPACK_B;
+            break;
+        case 'C':
+        case 'c':
+            myChar.col = FONTPACK_C;
+            break;
+        case 'D':
+        case 'd':
+            myChar.col = FONTPACK_D;
+            break;
+        case 'E':
+        case 'e':
+            myChar.col = FONTPACK_E;
+            break;
+        case 'F':
+        case 'f':
+            myChar.col = FONTPACK_F;
+            break;
+        case 'G':
+        case 'g':
+            myChar.col = FONTPACK_G;
+            break;
+        case 'H':
+        case 'h':
+            myChar.col = FONTPACK_H;
+            break;
+        case 'I':
+        case 'i':
+            myChar.col = FONTPACK_I;
+            break;
+        case 'J':
+        case 'j':
+            myChar.col = FONTPACK_J;
+            break;
+        case 'K':
+        case 'k':
+            myChar.col = FONTPACK_K;
+            break;
+        case 'L':
+        case 'l':
+            myChar.col = FONTPACK_L;
+            break;
+        case 'M':
+        case 'm':
+            myChar.col = FONTPACK_M;
+            break;
+        case 'N':
+        case 'n':
+            myChar.col = FONTPACK_N;
+            break;
+        case 'O':
+        case 'o':
+            myChar.col = FONTPACK_O;
+            break;
+        case 'P':
+        case 'p':
+            myChar.col = FONTPACK_P;
+            break;
+        case 'Q':
+        case 'q':
+            myChar.col = FONTPACK_Q;
+            break;
+        case 'R':
+        case 'r':
+            myChar.col = FONTPACK_R;
+            break;
+        case 'S':
+        case 's':
+            myChar.col = FONTPACK_S;
+            break;
+        case 'T':
+        case 't':
+            myChar.col = FONTPACK_T;
+            break;
+        case 'U':
+        case 'u':
+            myChar.col = FONTPACK_U;
+            break;
+        case 'V':
+        case 'v':
+            myChar.col = FONTPACK_V;
+            break;
+        case 'W':
+        case 'w':
+            myChar.col = FONTPACK_W;
+            break;
+        case 'X':
+        case 'x':
+            myChar.col = FONTPACK_X;
+            break;
+        case 'Y':
+        case 'y':
+            myChar.col = FONTPACK_Y;
+            break;
+        case 'Z':
+        case 'z':
+            myChar.col = FONTPACK_Z;
+            break;
+        case ':':
+            myChar.col = FONTPACK_COLON;
+            break;
+        case '.':
+            myChar.col = FONTPACK_PERIOD;
+            break;
+        case ' ':
+            myChar.col = FONTPACK_SPACE;
+            break;
+        case '!':
+            myChar.col = FONTPACK_EXCLAMATION;
+            break;
+        default:
+            myChar.col = FONTPACK_SPACE;
+            break;
+
+    }
+    return myChar;
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FontPack.h	Thu Nov 04 23:00:34 2010 +0000
@@ -0,0 +1,33 @@
+namespace FontPack {
+
+
+typedef struct {
+    int nCols;
+    const char* col;
+    char getCol(int i) {
+        return col[i];
+    }
+} FontPackChar;
+
+
+
+
+/*
+FN: writeChar
+Function takes the char to write to the map, the map to write to,
+and where in the map to start the writing.
+RETURN: index in map after inserting char (the caret)
+*/
+int writeChar(char a, char map[], int index, int col = 0);
+/*FN: blank
+Inserts a blank.
+RETURN: index in map after inserting blank
+*/
+int blank(int index);
+
+/*
+FN: getChar
+RETURN: a struct encapsulating the requested char.
+*/
+FontPackChar getChar(char a);
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Thu Nov 04 23:00:34 2010 +0000
@@ -0,0 +1,198 @@
+/*
+Date: 04/08/10
+Version 0.1.3
+
+Notes
+Write strings to display
+Update speed reporting based on calculated time
+
+
+Bugs
+Can update displayed strings, but cant stay at constant speed
+at value not equal to 0, 10, or 20. during accel it will increase
+from 10 to 20 1 at a time.
+
+Known Issues
+1.Pin20 seems a bit dodgy. InterruptIn does not work on that pin.
+2. Pin19 seems a bit dodgy. InterruptIn does not work on that pin.
+
+*/
+
+#include "mbed.h"
+#include "FontPack.h"
+
+using namespace FontPack;
+
+#define true 1
+#define false 0
+
+#define MSEC_USEC 1000
+/*
+we get msec/rev, what we want is miles/hour
+[1rev/(PI*Dia)in]*[12in/ft]*[5280ft/1mi]*[1sec/1000ms]*[1hr/3600sec]
+% has units of hr/mi, so invert
+ */
+#define POV_DIAMETER 26.5
+#define PI 3.14 
+
+#define POV_NUM_SAMPLES 3
+
+#define POV_NUM_COLS 360 //how many cols make up the whole wheel
+#define POV_MIN_SPEED_MPH 3
+
+#define POV_NUM_LEDS 8 //leds to paint
+#define POV_HALL_DEBOUNCE_US 2000*MSEC_USEC //debug code - long suppression
+
+//#define POV_HALL_DEBOUNCE_US 250*POV_MSEC_TO_USEC
+
+//DigitalOut led[POV_NUM_LEDS] = { p21, p22, p23, p24, p25, p26, p27, p28};
+DigitalOut led[POV_NUM_LEDS] = {p28, p27, p26, p25, p24, p23, p22, p21};
+InterruptIn hall(p17);
+Ticker paintTimer; //repeating ISR call
+//Timeout suppressHallTimer; //single ISR call
+Timer wheelSpeedTimer; //true timer, not an ISR call
+/*
+CONVERTER when multiplied by msec/rev results in hr/mi
+so the inversion of the product is mph
+pov_converter = [12in/1ft]*[5280ft/1mi]*[1sec/1000msec]*[1hr/3600s]
+pov_converter = pov_diameter/pov_converter
+mph = pov_converter/ (ms/rev)
+*/
+static double POV_CONVERTER=.0056;
+
+static bool hallFlag = false;
+static bool hallSuppressed = false;
+static bool paintFlag = false;
+static int columnCounter = 0;
+static int wheelSpeedCounter_ms = 0;
+
+
+
+/*FUNCTION DECLARATIONS*/
+static void paintInterrupt(void);
+//static void suppressInterrupt(void);
+static void hallEffectDetected(void);
+static void paint(char canvas[]);
+static void updateCanvas(char canvas[], float wheelSpeed_mph);
+static int writeString(char canvas[], const char* msg, int index) ;
+
+float updateWheelSpeed(int wheelSpeedCtr_us);
+static void turnLightsOn(bool isOn);
+
+int main() {
+    float wheelSpeed_mph = 0;
+    int colSpeed_us = 0;
+    char canvas[POV_NUM_COLS] = {0};
+    POV_CONVERTER = POV_DIAMETER / POV_CONVERTER;
+
+    turnLightsOn(false);
+    hall.fall(&hallEffectDetected);  // attach the address of the handling routine
+    hall.mode(PullUp);
+    wheelSpeedTimer.start();
+    paintTimer.attach(&paintInterrupt, 1);
+
+    while (true) {
+        if (hallFlag) {
+            hallFlag = false;
+            colSpeed_us = wheelSpeedCounter_ms*MSEC_USEC / POV_NUM_COLS;
+            wheelSpeed_mph = updateWheelSpeed(wheelSpeedCounter_ms);
+            updateCanvas(canvas, wheelSpeed_mph);
+            if (wheelSpeed_mph > POV_MIN_SPEED_MPH) {
+            //if (true) {
+                paintFlag = true;
+                paintTimer.attach_us(&paintInterrupt, colSpeed_us);
+                columnCounter = 0;
+                //paintTimer.attach(&paintInterrupt, 1); //debug - msec, slow update
+            }
+            hallSuppressed = false;
+        }
+
+        if (paintFlag) {
+            paintFlag = false;
+            paint(canvas);
+        }
+    }
+}
+
+static void paintInterrupt(void) {
+    ++columnCounter;
+    paintFlag = true;
+}
+
+
+static void hallEffectDetected(void) {
+    if (!hallSuppressed) {
+        hallSuppressed = true;
+        paintFlag = false;
+        wheelSpeedCounter_ms = wheelSpeedTimer.read_ms();
+        wheelSpeedTimer.reset();
+        hallFlag = true;
+    }
+}
+
+static void paint(char canvas[]) {
+    if (columnCounter >= POV_NUM_COLS) return;
+    int LED = canvas[columnCounter];
+    for (int i=0; i < POV_NUM_LEDS; i++) {
+        led[i] = (LED >> i) & 0x01; //just get the last bit for comparison
+    }
+}
+
+
+static void updateCanvas(char canvas[], float wheelSpeed_mph) {
+    int index = 120;
+    char msg[30];
+    memset(canvas, 0x00, POV_NUM_COLS);
+    float bike_distance = 0;
+    //sprintf(msg, "Distance: %2f Speed: %2.2f MPH", wheelSpeed_mph);
+   // sprintf(msg, "Speed: %2.1fMPH Distance: %2.1f", wheelSpeed_mph);
+   
+   
+    
+    sprintf(msg, "Speed: %2.1f MPH", wheelSpeed_mph);
+    
+    index = writeString(canvas, msg, 90);
+    
+}
+
+static int writeString(char canvas[], const char* msg, int index) {
+
+    while ((msg != NULL) && (*msg != '\0')) {
+        index = writeChar(*msg, canvas, index);
+        msg++;
+    }
+    return index;
+}
+
+
+static void turnLightsOn(bool isOn) {
+    for (int i=0; i < POV_NUM_LEDS; i++) {
+        led[i]=isOn;
+    }
+}
+
+
+//Aggregates and stores num samples in the averager
+//computes running average by always replacing value at index
+//with new measured value, then updating sample with new measured value
+
+float updateWheelSpeed(int wheelSpeedCtr_ms) {
+    static float samples[POV_NUM_SAMPLES] =  {0};
+    static char index = 0;
+    static float avgSpeed_mph = 0;
+
+    //float lin = POV_CONVERTER/((float) wheelSpeedCtr_ms);
+    //return lin;
+    
+     if (wheelSpeedCtr_ms != 0) {
+        float linearSpeed_mph = POV_CONVERTER/((float) wheelSpeedCtr_ms);
+        //calculate new running average
+        avgSpeed_mph = avgSpeed_mph - samples[index]/POV_NUM_SAMPLES + linearSpeed_mph/POV_NUM_SAMPLES;
+        //store new sample
+        samples[index] = linearSpeed_mph;
+        //update averager index
+        index = ++index % POV_NUM_SAMPLES;
+    }
+    
+    return avgSpeed_mph;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Thu Nov 04 23:00:34 2010 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/49a220cc26e0