code to drive the main board of the london-hackspace vending machine

Dependencies:   mbed

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 
00003 DigitalOut g(p22);
00004 DigitalOut r(p21);
00005 
00006 void red(void) {
00007     r = 1; g = 0;
00008 }
00009 
00010 void green(void) {
00011     r = 0; g = 1;
00012 }
00013 
00014 void orange(void) {
00015     r = 1; g = 1;
00016 }
00017 
00018 void off(void) {
00019     r = 0; g = 0;
00020 }
00021 
00022 Serial pc(USBTX, USBRX);
00023 
00024 DigitalOut ser(p25);
00025 DigitalOut mclock(p24);
00026 DigitalOut oe(p26);
00027 DigitalOut m10(p28);
00028 DigitalOut m9(p27);
00029 
00030 InterruptIn vint(p30);
00031 
00032 int intrcount = 0;
00033 bool vendfound = 0;
00034 
00035 /*
00036 motor connectors pinouts:
00037 
00038         a       b
00039 1       a1      b1
00040 2       a2      b2
00041 3       a3      b3
00042 4       a4      b4
00043 5       a5      b5
00044 6       a6      b6
00045 7       a7      n/a
00046 8       a8      n/a
00047 9       a9      n/a
00048 10      a0      n/a
00049 */
00050 
00051 /* bits are:
00052  *
00053  * serial data mcu -> 5890 -> 5842A
00054  *
00055  * first bits out are for the first 8 motor sinks
00056  * next 8 are the sources, we only need 2
00057  *
00058  * low order bits are the sinks
00059  *
00060  */ 
00061 uint16_t motor_bits(int motor)
00062 {
00063         uint16_t out = 0; // 16 bits!
00064 
00065         switch (motor) {
00066         case 1:
00067                 out = 0x2080; // 0010000010000000
00068                 break;
00069         case 2:
00070                 out = 0x2040; // 0010000001000000
00071                 break;
00072         case 3:
00073                 out = 0x2020; // 0010000000100000
00074                 break;
00075         case 4:
00076                 out = 0x2010; // 0010000000010000
00077                 break;
00078         case 5:
00079                 out = 0x2008; // 0010000000001000
00080                 break;
00081         case 6:
00082                 out = 0x2004; // 0010000000000100
00083                 break;
00084         case 7:
00085                 out = 0x2002; // 0010000000000010
00086                 break;
00087         case 8:
00088                 out = 0x2001; // 0010000000000001
00089                 break;
00090         case 9:
00091                 out = 0x2000; // 0010000000000000 uses the darlingtons
00092                 break;
00093         case 10:
00094                 out = 0x2000; // 0010000000000000 uses the darlingtons
00095                 break;
00096         case 11:
00097                 out = 0x4080; // 0100000010000000
00098                 break;
00099         case 12:
00100                 out = 0x4040; // 0100000001000000
00101                 break;
00102         case 13:
00103                 out = 0x4020; // 0100000000100000
00104                 break;
00105         case 14:
00106                 out = 0x4010; // 0100000000010000
00107                 break;
00108         case 15:
00109                 out = 0x4008; // 0100000000001000
00110                 break;
00111         case 16:
00112                 out = 0x4004; // 0100000000000100
00113                 break;
00114         }
00115         return out;
00116 }
00117 
00118 /*
00119  * motor is 1 to 16
00120  */
00121 int motors(int motor) {
00122     int i, bit;
00123     uint16_t bits;
00124 
00125     bits = 0;
00126 
00127     if (motor < 1)
00128         return -1;
00129         
00130     if (motor > 16)
00131         return -1;
00132 
00133     bits = motor_bits(motor);
00134 
00135     for (i = 0 ; i < 16 ; i++)
00136     {
00137         bit = (bits & (1 << i)) >> i;
00138         ser = bit;
00139         mclock = 0;
00140         wait_ms(1);
00141         mclock = 1;
00142         wait_ms(1);
00143     }
00144 
00145     // need to use the darlington pins instead
00146     if (motor == 9)
00147         m9 = 1;
00148 
00149     if (motor == 10)
00150         m10 = 1;
00151 
00152     return 0;
00153 }
00154 
00155 void clear(void) {
00156     int i;
00157     
00158     ser = 0;
00159     m9 = 0;
00160     m10 = 0;
00161     oe = 1; // oe is active low
00162     
00163     for (i = 0; i < 16 ; i++)
00164     {
00165         mclock = 0;
00166         wait_ms(1);
00167         mclock = 1;
00168     }
00169     wait_ms(1);
00170     m9 = 0;
00171     m10 = 0;
00172     oe = 0; // should switch everything off.
00173     intrcount = 0;
00174 }
00175 
00176 void vendintr() {
00177     intrcount++;
00178 }
00179 
00180 int main() {
00181     int i;
00182     char got;
00183     char state1, gcount;
00184     int ga, gb;
00185     
00186     state1 = 'n';
00187     gcount = 0;
00188     ga = gb = 0;
00189 
00190     oe = 1; // active low
00191     ser = 0;
00192     mclock = 0;
00193 
00194     printf("\n\rGo!\n\r");
00195     green();
00196 
00197     vint.mode(PullUp);
00198     vint.fall(&vendintr);
00199 
00200     for (i = 0; 1 ; i++) {
00201         if (i % 2) {
00202             orange();
00203         } else {
00204             green();
00205         }
00206 
00207         wait_ms(100);
00208         if (pc.readable())
00209         {
00210             got = pc.getc();
00211             pc.putc(got); // remote echo            
00212             if (state1 == 'n') // no command in progress
00213             {
00214                 if (got == 'c') // no args
00215                 {
00216                     clear();
00217                     printf("cleared\n\r");
00218                 }
00219                 if (got == 'r') { // no args, report intr count
00220                     printf("vendintrs: %d\n\r", intrcount);
00221                 }
00222                 if (got == 'm') // look for numbers
00223                     state1 = 'm';
00224             } else if (state1 == 'm') {
00225                 if ((got - '0') > -1 && (got - '0') < 10 )
00226                 {
00227                     if (gcount == 0)
00228                         ga = got - '0';
00229                     if (gcount == 1)
00230                         gb = got - '0';
00231                 
00232                     gcount += 1;
00233                 } else if (got == '\n' || got == '\r') {
00234                     // newline, so end command
00235                     int runmotor = 0;
00236                     if (gcount < 3 && gcount != 0) {
00237                         if (gcount == 1)
00238                             runmotor = ga;
00239                         if (gcount == 2)
00240                             runmotor = (ga * 10) + gb;
00241                         if (runmotor > 16) {
00242                             printf("motor too big: %d\n\r", runmotor);
00243                         } else {
00244                             printf("running motor %d\n\r", runmotor);
00245                             oe = 1;
00246                             motors(runmotor);
00247                             oe = 0; // active low
00248                         }
00249                     } else {
00250                         printf("too many digits\n\r");
00251                     }
00252                     state1 = 'n';
00253                     gcount = ga = gb = 0;
00254                 } else {
00255                     printf("m fail\n\r");
00256                     state1 = 'n';
00257                     gcount = ga = gb = 0;
00258                 }
00259             }            
00260         }
00261    }
00262    clear();
00263         
00264    printf("Done!\r\n");
00265 }