Revision 0:e313e46f2b3d, committed 2015-10-10

Comitter:

aallport

Date:

Sat Oct 10 23:09:34 2015 +0000

Commit message:

Works on led's; need to test on floppydrives

Changed in this revision

diff -r 000000000000 -r e313e46f2b3d MODSERIAL.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MODSERIAL.lib	Sat Oct 10 23:09:34 2015 +0000
@@ -0,0 +1,1 @@
+http://developer.mbed.org/users/AjK/code/MODSERIAL/#ae0408ebdd68

diff -r 000000000000 -r e313e46f2b3d main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Sat Oct 10 23:09:34 2015 +0000
@@ -0,0 +1,273 @@
+#include "mbed.h"
+#include <Ticker.h>
+#include "MODSERIAL.h"
+
+bool firstRun = true;
+const int FIRST_PIN = 2;
+const int PIN_MAX=17;
+//in the array
+MODSERIAL pc(USBTX, USBRX);
+#define RESOLUTION 0.0040
+DigitalOut MyLED(LED1);
+Ticker tick_flip;
+
+
+/*NOTE: Many of the arrays below contain unused indexes.  This is 
+ to prevent the Arduino from having to convert a pin input to an alternate
+ array index and save as many cycles as possible.  In other words information 
+ for pin 2 will be stored in index 2, and information for pin 4 will be 
+ stored in index 4.*/
+
+
+/*An array of maximum track positions for each step-control pin.  Even pins
+ are used for control, so only even numbers need a value here.  3.5" Floppies have
+ 80 tracks, 5.25" have 50.  These should be doubled, because each tick is now
+ half a position (use 158 and 98).
+ */
+char MAX_POSITION[] = {
+  0,0,158,0,158,0,158,0,158,0,158,0,158,0,158,0,158,0};
+
+//Array to track the current position of each floppy head.  (Only even indexes (i.e. 2,4,6...) are used)
+char currentPosition[] = {
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+
+/*Array to keep track of state of each pin.  Even indexes track the control-pins for toggle purposes.  Odd indexes
+ track direction-pins.  LOW = forward, HIGH=reverse
+ */
+//go to line 52
+
+//Current period assigned to each pin.  0 = off.  Each period is of the length specified by the RESOLUTION
+//variable above.  i.e. A period of 10 is (RESOLUTION x 10) microseconds long.
+unsigned int currentPeriod[] = {
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+};
+
+//Current tick
+unsigned int currentTick[] = {
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 
+};
+
+
+
+DigitalOut currentState[]= {
+    LED3,
+    LED4,
+    p5,//S1
+    p6,//D1
+    p7,//S2
+    p8,//D2
+    p9,//S3
+    p10,//D3
+    p11,//S4
+    p12,//D4
+    p13,//S5
+    p14,//D5
+    p15,//S6
+    p16,//D6
+    p17,//S7
+    p18,//D7
+    p19,//S8
+    p20,//S8
+};
+
+void togglePin(unsigned char pin, unsigned char direction_pin)
+{
+
+    //Switch directions if end has been reached
+    if (currentPosition[pin] >= MAX_POSITION[pin]) {
+        currentState[direction_pin] = 1;
+        wait_us(2);
+    } else if (currentPosition[pin] <= 0) {
+        currentState[direction_pin] = 0;
+        wait_us(2);
+    }
+
+    //Update currentPosition
+    if (currentState[direction_pin] == 1) {
+        currentPosition[pin]--;
+    } else {
+        currentPosition[pin]++;
+    }
+
+    //Pulse the control pin
+    currentState[pin] = !currentState[pin];
+    wait_us(2);
+}
+
+void tick()
+{
+    /*
+     If there is a period set for control pin 2, count the number of
+     ticks that pass, and toggle the pin if the current period is reached.
+     */
+    if (currentPeriod[2]>0) {
+        currentTick[2]++;
+        if (currentTick[2] >= currentPeriod[2]) {
+            togglePin(2,3);
+            currentTick[2]=0;
+        }
+    }
+    if (currentPeriod[4]>0) {
+        currentTick[4]++;
+        if (currentTick[4] >= currentPeriod[4]) {
+            togglePin(4,5);
+            currentTick[4]=0;
+        }
+    }
+    if (currentPeriod[6]>0) {
+        currentTick[6]++;
+        if (currentTick[6] >= currentPeriod[6]) {
+            togglePin(6,7);
+            currentTick[6]=0;
+        }
+    }
+    if (currentPeriod[8]>0) {
+        currentTick[8]++;
+        if (currentTick[8] >= currentPeriod[8]) {
+            togglePin(8,9);
+            currentTick[8]=0;
+        }
+    }
+    if (currentPeriod[10]>0) {
+        currentTick[10]++;
+        if (currentTick[10] >= currentPeriod[10]) {
+            togglePin(10,11);
+            currentTick[10]=0;
+        }
+    }
+    if (currentPeriod[12]>0) {
+        currentTick[12]++;
+        if (currentTick[12] >= currentPeriod[12]) {
+            togglePin(12,13);
+            currentTick[12]=0;
+        }
+    }
+    if (currentPeriod[14]>0) {
+        currentTick[14]++;
+        if (currentTick[14] >= currentPeriod[14]) {
+            togglePin(14,15);
+            currentTick[14]=0;
+        }
+    }
+    if (currentPeriod[16]>0) {
+        currentTick[16]++;
+        if (currentTick[16] >= currentPeriod[16]) {
+            togglePin(16,17);
+            currentTick[16]=0;
+        }
+    }
+
+}
+
+
+//
+//// UTILITY FUNCTIONS
+//
+
+//Not used now, but good for debugging...
+void blinkLED()
+{
+    MyLED = 1; // set the LED on
+    wait(0.25); // wait for a second
+    MyLED = 0;
+}
+
+//For a given controller pin, runs the read-head all the way back to 0
+void reset(unsigned char pin)
+{
+    currentState[pin+1] = 1; // Go in reverse
+    wait_us(2);
+    for (unsigned char s = 0; s < MAX_POSITION[pin]; s+= 2) { //Half max because we're stepping directly (no toggle)
+        currentState[pin]=1;
+        wait_us(2);
+        currentState[pin]=0;
+        wait_us(2);
+    }
+    currentPosition[pin] = 0; // We're reset.
+    currentState[pin+1]=0;
+    wait_us(2);
+    currentPosition[pin+1] = 0; // Ready to go forward.
+}
+
+//Resets all the Pins
+void resetAll()
+{
+
+    // Old one-at-a-time reset
+    //for (byte p         =         FIRST_PIN;p<           =           PIN_MAX;p+           =           2){
+    //  reset(p);
+    //}
+
+    //Stop all notes (don't want to be playing during/after reset)
+    for (int p=FIRST_PIN; p<=PIN_MAX; p+=2) {
+        currentPeriod[p]=0; // Stop playing notes
+    }
+
+    // New all-at-once reset
+    for (int s=0; s<80 ; s++) { // For max drive's position
+        for (int p=FIRST_PIN; p<=PIN_MAX; p+=2) {
+            currentState[p+1]=1; // Go in reverse
+            wait_us(2);
+            currentState[p]=1;
+            wait_us(2);
+            currentState[p]=0;
+            wait_us(2);
+        }
+    }
+
+    for (unsigned char p = FIRST_PIN; p <= PIN_MAX; p+= 2) {
+        currentPosition[p] = 0; // We're reset.
+        currentState[p+1] = 0; // Ready to go forward.
+        wait_us(2);
+    }
+}
+
+int main()
+{
+    tick_flip.attach(&tick,RESOLUTION);
+//Setup Pins (Even-odd pairs for step control and direction
+    /*
+        pinMode(LED1, OUTPUT);// Pin 13 has an LED connected on most Arduino boards
+        pinMode(5, OUTPUT); // Step control 1
+        pinMode(6, OUTPUT); // Direction 1
+        pinMode(7, OUTPUT); // Step control 2
+        pinMode(8, OUTPUT); // Direction 2
+        pinMode(9, OUTPUT); // Step control 3
+        pinMode(10, OUTPUT); // Direction 3
+        pinMode(11, OUTPUT); // Step control 4
+        pinMode(12, OUTPUT); // Direction 4
+        pinMode(13, OUTPUT); // Step control 5
+        pinMode(14, OUTPUT); // Direction 5
+        pinMode(15, OUTPUT); // Step control 6
+        pinMode(16, OUTPUT); // Direction 6
+        pinMode(17, OUTPUT); // Step control 7
+        pinMode(18, OUTPUT); // Direction 7
+        pinMode(19, OUTPUT); // Step control 8
+        pinMode(20, OUTPUT); // Direction 8
+    */
+    resetAll();
+    while(1) {
+
+        //The first loop, reset all the drives, and wait 2 seconds...
+        if (firstRun) {
+            firstRun = false;
+            resetAll();
+            wait(2);
+        }
+
+        //Only read if we have
+        if (pc.rxBufferGetCount() > 2) {
+            char part0 = pc.getc();
+            char part1 = pc.getc();
+            char part2 = pc.getc();
+            //Watch for special 100-message to reset the drives
+            if (part0 == 100) {
+                resetAll();
+                //Flush any remaining messages.
+                pc.rxBufferFlush();
+            } else {
+                currentPeriod[part0] = (part1 << 8) | part2;
+            }
+        }
+    }
+}

diff -r 000000000000 -r e313e46f2b3d mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Sat Oct 10 23:09:34 2015 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/34e6b704fe68
\ No newline at end of file