main.cpp

00001 #include "mbed.h"
00002 #include "init.h"
00003 
00004 //  --------------------------------------   ADC   ----------------------------
00005 void sample_adc() {
00006     BUSY = 1;
00007     char adc_byte[2];
00008     char man_reg_adr[3];
00009     char val_reg_adr[2];
00010     char conv_res[1];
00011     uint16 *adc_ptr = ADC_BUF;
00012 
00013     if (ADC_CMD->adc_reg_width == 1) {
00014         memcpy(&man_reg_adr, (char *)&ADC_CMD->man_trig_reg, 1);
00015         man_reg_adr[1] = ADC_CMD->man_trig_val;
00016         memcpy(&val_reg_adr, (char *)&ADC_CMD->adc_lsb_reg, 1);        
00017     } else {
00018         memcpy(&man_reg_adr, (char *)&ADC_CMD->man_trig_reg, 2);
00019         man_reg_adr[2] = ADC_CMD->man_trig_val;
00020         memcpy(&val_reg_adr, (char *)&ADC_CMD->adc_lsb_reg, 2);
00021     }
00022 
00023     for(int n = 0; n < ADC_CMD->adc_samples; n++) {
00024         if (ADC_CMD->man_conv_mask != 0xFF) {
00025             // send i2c cmd to trigger manual conversion
00026             if (ADC_CMD->adc_reg_width == 1) {
00027                 mI2C.write(ADC_CMD->slv_addr, man_reg_adr, 2);
00028             } else {
00029                 mI2C.write(ADC_CMD->slv_addr, man_reg_adr, 3);
00030             }
00031             
00032             // wait 100us to avoid conversion noise due to communication 
00033             wait_us(100);
00034                         
00035             // loop until manual conversion done
00036             conv_res[0] = 0xFF;
00037             while (conv_res[0] != ADC_CMD->man_conv_mask) {
00038                 if (ADC_CMD->adc_reg_width == 1) {
00039                     mI2C.write(ADC_CMD->slv_addr, man_reg_adr, 1, true);
00040                 } else {
00041                     mI2C.write(ADC_CMD->slv_addr, man_reg_adr, 2, true);
00042                 }            
00043                 mI2C.read((ADC_CMD->slv_addr), conv_res, 1);
00044             }
00045         }
00046         if (ADC_CMD->adc_reg_width == 1) {
00047             mI2C.write(ADC_CMD->slv_addr, val_reg_adr, 1, true);
00048         } else {
00049             mI2C.write(ADC_CMD->slv_addr, val_reg_adr, 2, true);
00050         }
00051         mI2C.read(ADC_CMD->slv_addr, adc_byte, 2);
00052         memcpy(adc_ptr, (uint16*) adc_byte, 2);
00053         //pc.printf("adc_adr= 0x%X   adc_ptr= 0x%04X\n\r", adc_ptr, *adc_ptr);
00054         adc_ptr++;
00055     }
00056     BUSY = 0;
00057 }
00058 
00059 //  --------------------------------------   DAC   ----------------------------
00060 void dac_wr(byte *cmd) {
00061     cs0 = 0;
00062     for (byte i=0;i<3;i++){
00063       spi.write(cmd[i]);
00064     }
00065     cs0 = 1;
00066 }
00067 
00068 byte* dac_rd() {
00069     static byte response[3];
00070     cs0 = 0;
00071     for (byte i=0;i<3;i++){
00072         response[i] = spi.write(0xFF);
00073     }
00074     cs0 = 1;
00075     return response;
00076 }
00077 
00078 void set_dac() {
00079     cs0 = 0;
00080     for (byte i=2;i<5;i++){
00081         //pc.printf("i=%i dac=0x%02X\n\r", i, INBUF[i]);
00082         spi.write(INBUF[i]);
00083     }
00084     cs0 = 1;
00085     wait_us(500.0);
00086 }
00087 
00088 
00089 // ---------------------------------------  MAIN  -----------------------------
00090 int main() {
00091     int i = 0;
00092     byte ADC_START = 0;
00093     byte cmd = 0;
00094     byte dac_cntrl[3];
00095     sI2C.address(mbed_SlaveAddr);     //8-bit definition
00096     mI2C.frequency(400000);
00097     sI2C.frequency(400000);
00098 
00099     cs0 = 1;
00100     // Setup the spi for 8 bit data, high steady state clock,
00101     // second edge capture, with a 500kHz clock rate
00102     spi.format(8, 2);
00103     spi.frequency(500000);
00104     dac_wr(DAC_INIT_CMD);       // init dac
00105     dac_wr(DAC_ZERO_CMD);       // to avoid negative level at startup
00106     sI2C.read(INBUF, sizeof(INBUF));    // empty the i2c buffer
00107     #ifdef debug
00108          pc.baud(115200);
00109          pc.printf("ADC-Sampling\n\r");
00110     #endif
00111         
00112     while (1) {
00113         i = sI2C.receive();
00114         switch (i) {
00115             case I2CSlave::ReadAddressed:       // i2c state 1
00116 //                 pc.printf("i2c read\n\r");
00117 //                 for(int n = 0; n < ADC_CMD->adc_samples; n++) {
00118 //                     pc.printf("n=%i adc=0x%04X  ptr=0x%04X\n\r", n, ADC_BUF[n], &ADC_BUF[n]);
00119 //                 }
00120                 switch (cmd) {
00121                     case CMD_ADC_RD:
00122                         sI2C.write((char*)ADC_BUF, ADC_CMD->adc_samples*sizeof(uint16));
00123                         led_1 = 0;
00124                         break;
00125                     case CMD_ID:
00126                         sI2C.write(IDSTR, sizeof(IDSTR));
00127                         break;
00128                     case CMD_DAC_RD:
00129                         byte * dac_response = dac_rd();
00130                         sI2C.write((char*) dac_response, 3);
00131                         break;
00132                 }         
00133                 break;
00134             
00135             case I2CSlave::WriteAddressed:      // i2c state 3
00136                 //pc.printf("i2c rec  %d\n\r" , cmd_len);
00137                 sI2C.read(INBUF, sizeof(INBUF));
00138                 cmd = INBUF[0];
00139                 switch (cmd) {
00140                    case CMD_ADC:
00141                         memcpy(ADC_CMD, &INBUF[2], sizeof(ADC_CmdSet));                     
00142                         led_1 = 1;
00143                         ADC_START = 1;
00144                         break;
00145                     case CMD_DAC:
00146                         set_dac();
00147                         break;
00148                     case CMD_VSAMPL:
00149                         set_dac();
00150                         memcpy(ADC_CMD, &INBUF[5], sizeof(ADC_CmdSet)); 
00151                         led_1 = 1;
00152                         ADC_START = 1;
00153                         break;
00154                     case CMD_IDAC:
00155                         //pc.printf("i2c CMD_IDAC  0x%02X\n\r" , INBUF[1]);
00156                         dac_wr(DAC_INIT_CMD);     // init dac
00157                         dac_wr(DAC_ZERO_CMD);     // to avoid negative level
00158                         break;
00159                     case CMD_DAC_WR:
00160                         //pc.printf("i2c CMD_DAC_WR  0x%02X\n\r" , INBUF[1]);
00161                         memcpy(dac_cntrl, &INBUF[1], sizeof(dac_cntrl));
00162                         dac_wr(dac_cntrl);
00163                         break;
00164                 }
00165                 break;
00166             case I2CSlave::WriteGeneral:        // i2c state 2
00167                 break;
00168         }
00169         if (ADC_START == 1 && BUSY == 0) {
00170             sample_adc();
00171             ADC_START = 0;
00172         }
00173     }
00174 }