void CC1200::reset()
{
	SendStrobe(SRES);
	delay(5);
	SendStrobe(SRES); //is twice necessary? Probably not. Does it cause problems? You tell me...
}
示例#2
0
pulsesequence() 
{ 
 double gstab = getval("gstab"),
	gt1 = getval("gt1"),
	gzlvl1 = getval("gzlvl1"),
	gt2 = getval("gt2"),
	gzlvl2 = getval("gzlvl2"),
        satpwr = getval("satpwr"),
        satdly = getval("satdly"),
	del = getval("del"),
	del2 = getval("del2"),
	dosyfrq = getval("sfrq"),
        gzlvlhs = getval("gzlvlhs"),
        hsgt = getval("hsgt"),
	Ddelta,dosytimecubed; 
 char convcomp[MAXSTR],satmode[MAXSTR],alt_grd[MAXSTR],lkgate_flg[MAXSTR],
      sspul[MAXSTR]; 
 
 getstr("convcomp",convcomp); 
 getstr("satmode",satmode);
 getstr("alt_grd",alt_grd);
 getstr("lkgate_flg",lkgate_flg);
 getstr("sspul",sspul);

       //synchronize gradients to srate for probetype='nano'
       //   Preserve gradient "area"
          gt1 = syncGradTime("gt1","gzlvl1",1.0);
          gzlvl1 = syncGradLvl("gt1","gzlvl1",1.0);
          gt2 = syncGradTime("gt2","gzlvl2",1.0);
          gzlvl2 = syncGradLvl("gt2","gzlvl2",1.0);

/* CHECK CONDITIONS */ 
  if (p1 == 0.0) p1 = 2*pw;
 
/* STEADY-STATE PHASECYCLING 
 This section determines if the phase calculations trigger off of (SS - SSCTR) 
   or off of CT */ 
 
   ifzero(ssctr); 
      dbl(ct, v1); 
      hlv(ct, v3); 
   elsenz(ssctr); 
      sub(ssval, ssctr, v7);	/* v7 = 0,...,ss-1 */ 
      dbl(v7, v1); 
      hlv(v7, v3); 
   endif(ssctr); 
 
/* PHASECYCLE CALCULATION */ 
   hlv(v3, v2); 
   mod2(v3, v3); 
   add(v3, v1, v1); 
   assign(v1, oph); 
   dbl(v2, v4); 
   add(v4, oph, oph); 
   add(v2, v3, v2); 
 
 	Ddelta=gt1;             /*the diffusion-encoding pulse width is gt1*/ 
	if (convcomp[A]=='y') 
		dosytimecubed=Ddelta*Ddelta*(del - (4.0*Ddelta/3.0)); 
        else 
		dosytimecubed=Ddelta*Ddelta*(del - (Ddelta/3.0)); 
 
   putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq); 
   mod2(ct,v10);        /* gradients change sign at odd transients */
 
/* BEGIN ACTUAL SEQUENCE */ 
 status(A); 
     if (sspul[0]=='y')
       {
         zgradpulse(gzlvlhs,hsgt);
         rgpulse(pw,zero,rof1,rof1);
         zgradpulse(gzlvlhs,hsgt);
       }
     if (satmode[0] == 'y')
      {
        if (d1 - satdly > 0) delay(d1 - satdly);
        obspower(satpwr);
        rgpulse(satdly,zero,rof1,rof1);
        obspower(tpwr);
      }
     else delay(d1);

 if (getflag("wet")) wet4(zero,one);

 status(B); 
   if (del>0.0) { 
      if (convcomp[A]=='y')
	{ 
                if (lkgate_flg[0] == 'y')  lk_hold(); /* turn lock sampling off */
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(-gzlvl2,2.0*gt2);
                   elsenz(v10);
                     zgradpulse(gzlvl2,2.0*gt2);
                   endif(v10);
                 }
                else zgradpulse(-gzlvl2,2.0*gt2);
		delay(gstab); 
             rgpulse(pw, v1, rof1, rof1); 
		delay(d2/2.0); 
		delay(gstab); 
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(gzlvl1,gt1);
                   elsenz(v10);
                     zgradpulse(-1.0*gzlvl1,gt1);
                   endif(v10);
                 }
                else zgradpulse(gzlvl1,gt1);
                if (satmode[1] == 'y')
                   { obspower(satpwr);
                     rgpulse(((del+del2)/4)-gt1-2.0*rof1,zero,rof1,rof1);
                     obspower(tpwr);
                   }
                else delay(((del+del2)/4)-gt1);
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(-1.0*gzlvl1,gt1);
                   elsenz(v10);
                     zgradpulse(gzlvl1,gt1);
                   endif(v10);
                 }
                else zgradpulse(-1.0*gzlvl1,gt1);
		delay(gstab); 
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(-1.0*gzlvl1,gt1);
                   elsenz(v10);
                     zgradpulse(gzlvl1,gt1);
                   endif(v10);
                 }
                else zgradpulse(-1.0*gzlvl1,gt1);
                if (satmode[1] == 'y')
                   { obspower(satpwr);
                     rgpulse(((del-del2)/4)-gt1-2.0*rof1,zero,rof1,rof1);
                     obspower(tpwr);
                   }
		else delay(((del-del2)/4)-gt1); 
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(gzlvl1,gt1);
                   elsenz(v10);
                     zgradpulse(-1.0*gzlvl1,gt1);
                   endif(v10);
                 }
                else zgradpulse(gzlvl1,gt1);
		delay(gstab); 
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(gzlvl2,gt2);
                   elsenz(v10);
                     zgradpulse(-1.0*gzlvl2,gt2);
                   endif(v10);
                 }
                else zgradpulse(gzlvl2,gt2);
		delay(gstab); 
             rgpulse(p1, v2, rof1, rof1); 
		delay(gstab); 
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(gzlvl2,gt2);
                   elsenz(v10);
                     zgradpulse(-1.0*gzlvl2,gt2);
                   endif(v10);
                 }
                else zgradpulse(gzlvl2,gt2);
		delay(gstab); 
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(gzlvl1,gt1);
                   elsenz(v10);
                     zgradpulse(-1.0*gzlvl1,gt1);
                   endif(v10);
                 }
                else zgradpulse(gzlvl1,gt1);
                if (satmode[1] == 'y')
                   { obspower(satpwr);
                     rgpulse(((del-del2)/4)-gt1-2.0*rof1,zero,rof1,rof1);
                     obspower(tpwr);
                   }
                else delay(((del-del2)/4)-gt1);
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(-1.0*gzlvl1,gt1);
                   elsenz(v10);
                     zgradpulse(gzlvl1,gt1);
                   endif(v10);
                 }
                else zgradpulse(-1.0*gzlvl1,gt1);
		delay(gstab); 
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(-1.0*gzlvl1,gt1);
                   elsenz(v10);
                     zgradpulse(gzlvl1,gt1);
                   endif(v10);
                 }
                else zgradpulse(-1.0*gzlvl1,gt1);
                if (satmode[1] == 'y')
                   { obspower(satpwr);
                     rgpulse(((del+del2)/4)-gt1-2.0*rof1,zero,rof1,rof1);
                     obspower(tpwr);
                   }
                else delay(((del+del2)/4)-gt1);
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(gzlvl1,gt1);
                   elsenz(v10);
                     zgradpulse(-1.0*gzlvl1,gt1);
                   endif(v10);
                 }
                else zgradpulse(gzlvl1,gt1);
		delay(gstab); 
		delay(d2/2.0); 
                if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */
	} 
else
        { 
	     rgpulse(pw, v1, rof1, rof1); 
                if (lkgate_flg[0] == 'y')  lk_hold(); /* turn lock sampling off */
         	delay(d2/2.0); 
        	delay(gstab); 
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(gzlvl1,gt1);
                   elsenz(v10);
                     zgradpulse(-1.0*gzlvl1,gt1);
                   endif(v10);
                 }
                else zgradpulse(gzlvl1,gt1);
                if (satmode[1] == 'y')
                   { obspower(satpwr);
                     rgpulse((del-p1-2.0*rof1-gt1)/2.0-2.0*rof1,zero,rof1,rof1);
                     obspower(tpwr);
                   }
                else delay((del-p1-2.0*rof1-gt1)/2.0);
             rgpulse(p1, v2, rof1, rof1); 
                if (satmode[1] == 'y')
                   { obspower(satpwr);
                     rgpulse((del-p1-2.0*rof1-gt1)/2.0-2.0*rof1,zero,rof1,rof1);
                     obspower(tpwr);
                   }
                else delay((del-p1-2.0*rof1-gt1)/2.0);
                if (alt_grd[0] == 'y')
                 { ifzero(v10);
                     zgradpulse(gzlvl1,gt1);
                   elsenz(v10);
                     zgradpulse(-1.0*gzlvl1,gt1);
                   endif(v10);
                 }
                else zgradpulse(gzlvl1,gt1);
        	delay(gstab); 
        	delay(d2/2.0); 
                if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */
	} 
    } 
   else 
	rgpulse(pw,oph,rof1,rof2); 
 status(C); 
} 
示例#3
0
boolean WiFlyDevice::enterCommandMode(boolean isAfterBoot) {
  /*

   */

  DEBUG_LOG(1, "Entered enterCommandMode");

  // Note: We used to first try to exit command mode in case we were
  //       already in it. Doing this actually seems to be less
  //       reliable so instead we now just ignore the errors from
  //       sending the "$$$" in command mode.

  for (int retryCount = 0;
       retryCount < COMMAND_MODE_ENTER_RETRY_ATTEMPTS;
       retryCount++) {

    // At first I tried automatically performing the
    // wait-send-wait-send-send process twice before checking if it
    // succeeded. But I removed the automatic retransmission even
    // though it makes things  marginally less reliable because it speeds
    // up the (hopefully) more common case of it working after one
    // transmission. We also now have automatic-retries for the whole
    // process now so it's less important anyway.

    if (isAfterBoot) {
      delay(1000); // This delay is so characters aren't missed after a reboot.
    }

    delay(COMMAND_MODE_GUARD_TIME);

    uart.print("$$$");

    delay(COMMAND_MODE_GUARD_TIME);

    // We could already be in command mode or not.
    // We could also have a half entered command.
    // If we have a half entered command the "$$$" we've just added
    // could succeed or it could trigger an error--there's a small
    // chance it could also screw something up (by being a valid
    // argument) but hopefully it's not a general issue.  Sending
    // these two newlines is intended to clear any partial commands if
    // we're in command mode and in either case trigger the display of
    // the version prompt (not that we actually check for it at the moment
    // (anymore)).

    // TODO: Determine if we need less boilerplate here.

    uart.println();
    uart.println();

    // TODO: Add flush with timeout here?

    // This is used to determine whether command mode has been entered
    // successfully.
    // TODO: Find alternate approach or only use this method after a (re)boot?
    uart.println("ver");

	//Why check for line break? from "\r\nWiFly Ver" - > "WiFly Ver"
    if (findInResponse("WiFly Ver", 1000)) {
      // TODO: Flush or leave remainder of output?
      return true;
    }
  }
  return false;
}
示例#4
0
// play an MF tone:
void mf(int digit) { // Store the digit IFF recording:
    if(rec && ((digit>=0&&digit<=9)||digit==-13||digit==-6)) {
        for(int i=0; i<=23; i++) { // ONLY record KP,ST,0-9
            if(store[i]==-1) {
                store[i]=digit;
                break;
            }
        }
    }
    int duration = bbdur[0]; // OKAY for DTMF too
    if(mode==1) {
        if(digit==49) { // international mode A
            digit=13;
        }
        if(digit==50) { // international mode B
            digit=14;
        }
        if(digit==51) {
            sf(2600,1000);
            return;
        }
    } else if(mode==4) { // DTMF
        Serial.println(digit);
        if((digit>=1&&digit<=3)) { // 1,2,3
            digit-=1;
        } else if(digit>=7&&digit<=9) {
            digit+=1;
        } else if(digit==49) {
            digit = 3; // A
        } else if(digit==50) {
            digit = 7; // B
        } else if(digit==51) {
            digit = 11;  // C
        } else if(digit==52) {
            digit = 15;  // D
        } else if(digit==-13) {
            digit = 12;  // *
        } else if(digit==-6) {
            digit = 14;  // #
        } else if(digit==0) {
            digit = 13; // 0
        } else if(digit==13) {
            duration=150;
        }
        Serial.println("and: ");
        Serial.println(digit);
        freq[0].play(dtmfFreq[dtmf[digit][0]],duration);
        freq[1].play(dtmfFreq[dtmf[digit][1]],duration);
        return;
    }
    if(digit<0) {
        duration = bbdur[1];
        if(digit==-13) {
            digit=10;
        }
        if(digit==-6) {
            digit=11;
        }
    }
    if(digit==-1) {
        return;    // -1 in storage?
    }
    if(digit==12) { // 85ms for international trunk seizing
        duration = 200;
    }
    if (mode==3) duration = 150; // SS4 Supervisory MF (150ms)
    freq[0].play(bb[digit][0],duration);
    freq[1].play(bb[digit][1],duration);
    (autoDial) ? delay(duration + 60) : delay(duration); // ? expression? statement?
    if(rec) {
        delay(25);
        sf(2600,33);
    }// chirp to signify recording
    return; // Now we can leave.
}
示例#5
0
void GLCD_Init (void) {
  unsigned short driverCode;

/* Configure the LCD Control pins --------------------------------------------*/
  RCC->AHB1ENR    |=((1UL <<  0) |      /* Enable GPIOA clock                 */
#ifndef __STM_EVAL                      /* MCBSTM32F200 and MCBSTMF400 board  */
                    (1UL <<  2)  |      /* Enable GPIOC clock                 */
#endif
                     (1UL <<  3) |      /* Enable GPIOD clock                 */
                     (1UL <<  4) |      /* Enable GPIOE clock                 */
                     (1UL <<  5) |      /* Enable GPIOF clock                 */
                     (1UL <<  6));      /* Enable GPIOG clock                 */

  /* PD.00(D2),  PD.01(D3),  PD.04(NOE), PD.05(NWE)                           */
  /* PD.08(D13), PD.09(D14), PD.10(D15), PD.14(D0), PD.15(D1)                 */
  GPIOD->MODER    &= ~0xF03F0F0F;       /* Clear Bits                         */
  GPIOD->MODER    |=  0xA02A0A0A;       /* Alternate Function mode            */
  GPIOD->OSPEEDR  &= ~0xF03F0F0F;       /* Clear Bits                         */
  GPIOD->OSPEEDR  |=  0xA02A0A0A;       /* 50 MHz Fast speed                  */
  GPIOD->AFR[0]   &= ~0x00FF00FF;       /* Clear Bits                         */
  GPIOD->AFR[0]   |=  0x00CC00CC;       /* Alternate Function mode AF12       */
  GPIOD->AFR[1]   &= ~0xFF000FFF;       /* Clear Bits                         */
  GPIOD->AFR[1]   |=  0xCC000CCC;       /* Alternate Function mode AF12       */

  /* PE.07(D4), PE.08(D5),  PE.09(D6),  PE.10(D7), PE.11(D8)                  */
  /* PE.12(D9), PE.13(D10), PE.14(D11), PE.15(D12)                            */
  GPIOE->MODER    &= ~0xFFFFC000;       /* Clear Bits                         */
  GPIOE->MODER    |=  0xAAAA8000;       /* Alternate Function mode            */
  GPIOE->OSPEEDR  &= ~0xFFFFC000;       /* Clear Bits                         */
  GPIOE->OSPEEDR  |=  0xAAAA8000;       /* 50 MHz Fast speed                  */
  GPIOE->AFR[0]   &= ~0xF0000000;       /* Clear Bits                         */
  GPIOE->AFR[0]   |=  0xC0000000;       /* Alternate Function mode AF12       */
  GPIOE->AFR[1]   &= ~0xFFFFFFFF;       /* Clear Bits                         */
  GPIOE->AFR[1]   |=  0xCCCCCCCC;       /* Alternate Function mode AF12       */

  /* PF.00(A0 (RS)) */ 
  GPIOF->MODER    &= ~0x00000003;       /* Clear Bits                         */
  GPIOF->MODER    |=  0x00000002;       /* Alternate Function mode            */
  GPIOF->OSPEEDR  &= ~0x00000003;       /* Clear Bits                         */
  GPIOF->OSPEEDR  |=  0x00000002;       /* 50 MHz Fast speed                  */
  GPIOF->AFR[0]   &= ~0x0000000F;       /* Clear Bits                         */
  GPIOF->AFR[0]   |=  0x0000000C;       /* Alternate Function mode AF12       */

#ifdef __STM_EVAL                       /* STM3220G-EVAL and STM3240G-EVAL    */
  /* PG.10(NE4 (LCD/CS)) - CE1(LCD /CS)                                       */
  GPIOG->MODER    &= ~0x00300000;       /* Clear Bits                         */
  GPIOG->MODER    |=  0x00200000;       /* Alternate Function mode            */
  GPIOG->OSPEEDR  &= ~0x00300000;       /* Clear Bits                         */
  GPIOG->OSPEEDR  |=  0x00200000;       /* 50 MHz Fast speed                  */
  GPIOG->AFR[1]   &= ~0x00000F00;       /* Clear Bits                         */
  GPIOG->AFR[1]   |=  0x00000C00;       /* Alternate Function mode AF12       */

  /* PA.08(LCD Backlight                                                      */
  GPIOA->BSRRH    |=  (1UL <<   8);     /* Backlight off                      */
  GPIOA->MODER    &= ~(3UL << 2*8);     /* Clear Bits                         */
  GPIOA->MODER    |=  (1UL << 2*8);     /* PA.9 is output                     */
  GPIOA->OTYPER   &= ~(1UL <<   8);     /* PA.9 is output Push-Pull           */
  GPIOA->OSPEEDR  &= ~(3UL << 2*8);     /* Clear Bits                         */
  GPIOA->OSPEEDR  |=  (2UL << 2*8);     /* PA.9 is 50MHz Fast Speed           */

#else                                   /* MCBSTM32F200 and MCBSTMF400 board  */
  /* PG.12(NE4 (LCD/CS)) - CE1(LCD /CS)                                       */
  GPIOG->MODER    &= ~0x03000000;       /* Clear Bits                         */
  GPIOG->MODER    |=  0x02000000;       /* Alternate Function mode            */
  GPIOG->OSPEEDR  &= ~0x03000000;       /* Clear Bits                         */
  GPIOG->OSPEEDR  |=  0x02000000;       /* 50 MHz Fast speed                  */
  GPIOG->AFR[1]   &= ~0x000F0000;       /* Clear Bits                         */
  GPIOG->AFR[1]   |=  0x000C0000;       /* Alternate Function mode AF12       */

  /* PC.07(LCD Backlight                                                      */
  GPIOC->BSRRH    |=  (1UL <<   7);     /* Backlight off                      */
  GPIOC->MODER    &= ~(3UL << 2*7);     /* Clear Bits                         */
  GPIOC->MODER    |=  (1UL << 2*7);     /* PC.7 is output                     */
  GPIOC->OTYPER   &= ~(1UL <<   7);     /* PC.7 is output Push-Pull           */
  GPIOC->OSPEEDR  &= ~(3UL << 2*7);     /* Clear Bits                         */
  GPIOC->OSPEEDR  |=  (2UL << 2*7);     /* PC.7 is 50MHz Fast Speed           */
#endif


/*-- FSMC Configuration ------------------------------------------------------*/
  RCC->AHB3ENR  |= (1UL << 0);          /* Enable FSMC clock                  */

#ifdef __STM_EVAL                       /* STM3220G-EVAL and STM3240G-EVAL    */
  FSMC_Bank1->BTCR[(3-1)*2 + 1] =       /* Bank3 NOR/SRAM timing register     */
                                        /* configuration                      */
#else                                   /* MCBSTM32F200 and MCBSTMF400 board  */
  FSMC_Bank1->BTCR[(4-1)*2 + 1] =       /* Bank4 NOR/SRAM timing register     */
                                        /* configuration                      */
#endif
                          (0 << 28) |   /* FSMC AccessMode A                  */
                          (0 << 24) |   /* Data Latency                       */
                          (0 << 20) |   /* CLK Division                       */
                          (0 << 16) |   /* Bus Turnaround Duration            */
                          (9 <<  8) |   /* Data SetUp Time                    */
                          (0 <<  4) |   /* Address Hold Time                  */
                          (1 <<  0);    /* Address SetUp Time                 */

#ifdef __STM_EVAL                       /* STM3220G-EVAL and STM3240G-EVAL    */
  FSMC_Bank1->BTCR[(3-1)*2 + 0] =
#else                                   /* MCBSTM32F200 and MCBSTMF400 board  */
  FSMC_Bank1->BTCR[(4-1)*2 + 0] =       /* Control register                   */
#endif
                          (0 << 19) |   /* Write burst disabled               */
                          (0 << 15) |   /* Async wait disabled                */
                          (0 << 14) |   /* Extended mode disabled             */
                          (0 << 13) |   /* NWAIT signal is disabled           */ 
                          (1 << 12) |   /* Write operation enabled            */
                          (0 << 11) |   /* NWAIT signal is active one data    */
                                        /* cycle before wait state            */
                          (0 << 10) |   /* Wrapped burst mode disabled        */
                          (0 <<  9) |   /* Wait signal polarity active low    */
                          (0 <<  8) |   /* Burst access mode disabled         */
                          (1 <<  4) |   /* Memory data  bus width is 16 bits  */
                          (0 <<  2) |   /* Memory type is SRAM                */
                          (0 <<  1) |   /* Address/Data Multiplexing disable  */
                          (1 <<  0);    /* Memory Bank enable                 */

  delay(5);                             /* Delay 50 ms                        */
  driverCode = rd_reg(0x00);

  if (driverCode == 0x47) {             /* LCD with HX8347-D LCD Controller   */
    Himax = 1;                          /* Set Himax LCD controller flag      */
    /* Driving ability settings ----------------------------------------------*/
    wr_reg(0xEA, 0x00);                 /* Power control internal used (1)    */
    wr_reg(0xEB, 0x20);                 /* Power control internal used (2)    */
    wr_reg(0xEC, 0x0C);                 /* Source control internal used (1)   */
    wr_reg(0xED, 0xC7);                 /* Source control internal used (2)   */
    wr_reg(0xE8, 0x38);                 /* Source output period Normal mode   */
    wr_reg(0xE9, 0x10);                 /* Source output period Idle mode     */
    wr_reg(0xF1, 0x01);                 /* RGB 18-bit interface ;0x0110       */
    wr_reg(0xF2, 0x10);

    /* Adjust the Gamma Curve ------------------------------------------------*/
    wr_reg(0x40, 0x01);
    wr_reg(0x41, 0x00);
    wr_reg(0x42, 0x00);
    wr_reg(0x43, 0x10);
    wr_reg(0x44, 0x0E);
    wr_reg(0x45, 0x24);
    wr_reg(0x46, 0x04);
    wr_reg(0x47, 0x50);
    wr_reg(0x48, 0x02);
    wr_reg(0x49, 0x13);
    wr_reg(0x4A, 0x19);
    wr_reg(0x4B, 0x19);
    wr_reg(0x4C, 0x16);

    wr_reg(0x50, 0x1B);
    wr_reg(0x51, 0x31);
    wr_reg(0x52, 0x2F);
    wr_reg(0x53, 0x3F);
    wr_reg(0x54, 0x3F);
    wr_reg(0x55, 0x3E);
    wr_reg(0x56, 0x2F);
    wr_reg(0x57, 0x7B);
    wr_reg(0x58, 0x09);
    wr_reg(0x59, 0x06);
    wr_reg(0x5A, 0x06);
    wr_reg(0x5B, 0x0C);
    wr_reg(0x5C, 0x1D);
    wr_reg(0x5D, 0xCC);

    /* Power voltage setting -------------------------------------------------*/
    wr_reg(0x1B, 0x1B);
    wr_reg(0x1A, 0x01);
    wr_reg(0x24, 0x2F);
    wr_reg(0x25, 0x57);
    wr_reg(0x23, 0x88);

    /* Power on setting ------------------------------------------------------*/
    wr_reg(0x18, 0x36);                 /* Internal oscillator frequency adj  */
    wr_reg(0x19, 0x01);                 /* Enable internal oscillator         */
    wr_reg(0x01, 0x00);                 /* Normal mode, no scrool             */
    wr_reg(0x1F, 0x88);                 /* Power control 6 - DDVDH Off        */
    delay(20);
    wr_reg(0x1F, 0x82);                 /* Power control 6 - Step-up: 3 x VCI */
    delay(5);
    wr_reg(0x1F, 0x92);                 /* Power control 6 - Step-up: On      */
    delay(5);
    wr_reg(0x1F, 0xD2);                 /* Power control 6 - VCOML active     */
    delay(5);

    /* Color selection -------------------------------------------------------*/
    wr_reg(0x17, 0x55);                 /* RGB, System interface: 16 Bit/Pixel*/
    wr_reg(0x00, 0x00);                 /* Scrolling off, no standby          */

    /* Interface config ------------------------------------------------------*/
    wr_reg(0x2F, 0x11);                 /* LCD Drive: 1-line inversion        */
    wr_reg(0x31, 0x00);
    wr_reg(0x32, 0x00);                 /* DPL=0, HSPL=0, VSPL=0, EPL=0       */

    /* Display on setting ----------------------------------------------------*/
    wr_reg(0x28, 0x38);                 /* PT(0,0) active, VGL/VGL            */
    delay(20);
    wr_reg(0x28, 0x3C);                 /* Display active, VGL/VGL            */

   #if (LANDSCAPE == 1)
    #if (ROTATE180 == 0)
     wr_reg (0x16, 0xA8);
    #else
     wr_reg (0x16, 0x68);
    #endif
   #else
    #if (ROTATE180 == 0)
     wr_reg (0x16, 0x08);
    #else
     wr_reg (0x16, 0xC8);
    #endif
   #endif

    /* Display scrolling settings --------------------------------------------*/
    wr_reg(0x0E, 0x00);                 /* TFA MSB                            */
    wr_reg(0x0F, 0x00);                 /* TFA LSB                            */
    wr_reg(0x10, 320 >> 8);             /* VSA MSB                            */
    wr_reg(0x11, 320 &  0xFF);          /* VSA LSB                            */
    wr_reg(0x12, 0x00);                 /* BFA MSB                            */
    wr_reg(0x13, 0x00);                 /* BFA LSB                            */
  }
AP_Autopilot::AP_Autopilot(AP_Navigator * navigator, AP_Guide * guide,
                           AP_Controller * controller, AP_Board * board,
                           float loopRate, float loop0Rate, float loop1Rate, float loop2Rate, float loop3Rate) :
    Loop(loopRate, callback, this), _navigator(navigator), _guide(guide),
    _controller(controller), _board(board),
    callbackCalls(0) {

    board->debug->printf_P(PSTR("initializing autopilot\n"));
    board->debug->printf_P(PSTR("free ram: %d bytes\n"),freeMemory());

    /*
     * Comm links
     */
    board->gcs = new MavlinkComm(board->gcsPort, navigator, guide, controller, board, 3);
    if (board->getMode() != AP_Board::MODE_LIVE) {
        board->hil = new MavlinkComm(board->hilPort, navigator, guide, controller, board, 3);
    }
    board->gcsPort->printf_P(PSTR("gcs hello\n"));

    board->gcs->sendMessage(MAVLINK_MSG_ID_HEARTBEAT);
    board->gcs->sendMessage(MAVLINK_MSG_ID_SYS_STATUS);

    /*
     * Calibration
     */
    controller->setState(MAV_STATE_CALIBRATING);
    board->gcs->sendMessage(MAVLINK_MSG_ID_HEARTBEAT);
    board->gcs->sendMessage(MAVLINK_MSG_ID_SYS_STATUS);

    if (navigator) navigator->calibrate();

    /*
     * Look for valid initial state
     */
    while (_navigator) {

        // letc gcs known we are alive
        board->gcs->sendMessage(MAVLINK_MSG_ID_HEARTBEAT);
        board->gcs->sendMessage(MAVLINK_MSG_ID_SYS_STATUS);
        if (board->getMode() == AP_Board::MODE_LIVE) {
            _navigator->updateSlow(0);
            if (board->gps) {
                if (board->gps->fix) {
                    break;
                } else {
                    board->gps->update();
                    board->gcs->sendText(SEVERITY_LOW,
                                       PSTR("waiting for gps lock\n"));
                    board->debug->printf_P(PSTR("waiting for gps lock\n"));
                }
            } else { // no gps, can skip
                break;
            }
        } else if (board->getMode() == AP_Board::MODE_HIL_CNTL) { // hil
            board->hil->sendMessage(MAVLINK_MSG_ID_HEARTBEAT);
            board->hil->receive();
            if (_navigator->getTimeStamp() != 0) {
                // give hil a chance to send some packets
                for (int i = 0; i < 5; i++) {
                    board->debug->println_P(PSTR("reading initial hil packets"));
                    board->gcs->sendText(SEVERITY_LOW, PSTR("reading initial hil packets"));
                    delay(1000);
                }
                break;
            }
            board->debug->println_P(PSTR("waiting for hil packet"));
            board->gcs->sendText(SEVERITY_LOW, PSTR("waiting for hil packets"));
        }
        delay(500);
    }

    AP_MavlinkCommand::home.setAlt(_navigator->getAlt());
    AP_MavlinkCommand::home.setLat(_navigator->getLat());
    AP_MavlinkCommand::home.setLon(_navigator->getLon());
    AP_MavlinkCommand::home.setCommand(MAV_CMD_NAV_WAYPOINT);
    AP_MavlinkCommand::home.save();
    _board->debug->printf_P(PSTR("\nhome before load lat: %f deg, lon: %f deg, cmd: %d\n"),
                          AP_MavlinkCommand::home.getLat()*rad2Deg,
                          AP_MavlinkCommand::home.getLon()*rad2Deg,
                          AP_MavlinkCommand::home.getCommand());
    AP_MavlinkCommand::home.load();
    _board->debug->printf_P(PSTR("\nhome after load lat: %f deg, lon: %f deg, cmd: %d\n"),
                          AP_MavlinkCommand::home.getLat()*rad2Deg,
                          AP_MavlinkCommand::home.getLon()*rad2Deg,
                          AP_MavlinkCommand::home.getCommand());

    guide->setCurrentIndex(0);
    controller->setMode(MAV_MODE_LOCKED);
    controller->setState(MAV_STATE_STANDBY);
  
    /*
     * Attach loops, stacking for priority
     */
    board->debug->println_P(PSTR("attaching loops"));
    subLoops().push_back(new Loop(loop0Rate, callback0, this));
    subLoops().push_back(new Loop(loop1Rate, callback1, this));
    subLoops().push_back(new Loop(loop2Rate, callback2, this));
    subLoops().push_back(new Loop(loop3Rate, callback3, this));

    board->debug->println_P(PSTR("running"));
    board->gcs->sendText(SEVERITY_LOW, PSTR("running"));
}
示例#7
0
void main()

{
x=0;
counter = 0;
fw=0;
ew=0;
bz=0;


 TMOD=0x20; //Enable Timer 1

 TH1=0XFD;

 SCON=0x50;

 TR1=1; // Triggering Timer 1

 lcd_init();

lcd_cmd(0x81); //Place cursor to second position of first line 
lcd_cmd(0x01); //clear screen
lcd_string("SoS App");

 delay(200);
//recieve();
//SBUF=" ";
lcd_init();
lcd_cmd(0x81); //Place cursor to second position of first line 
//lcd_cmd(0x01); //clear screen
lcd_cmd(0xC1); //Place cursor to second position of second line
//lcd_string("UNIQUE ID:");
//recieve();
 while(1)

 {
 int l;


if (fw == 1 && counter == 0)
{
counter = 1;
bz = 1;
 for(l=0;l<12;l++)

 { 
 
 lcd_data(flood[l]);

 }

  // Mobile communication start
          		
          		serial_init();                                                                                                 //serial initialization
           // LED = 0x00; 
            printf("AT+CMGF=1%c",13);                                        
             delay2(20);  //Text Mode            | hex value of 13 is 0x0D (CR )
            printf("AT+CMGS=\"8939965828\"%c",13); delay2(20);           //Type your mobile number Eg : "9884467058"
           // led_left();                 //scroll left
                        delay1(20);
            printf("Sos-Warning:");                   
              delay2(20);  //Type text as u want
                printf(flood);                   
              delay2(20);  //Type text as u want
            printf("%c",0x1A);                                                             
            delay2(20);  //line feed command

          		// Mobile Communication end
}

if (ew == 1 && counter == 0)
{

counter = 1;
bz =1;
 for(l=0;l<17;l++)

 { 
 
 lcd_data(earthquake[l]);

 }
  // Mobile communication start
          		
          		serial_init();                                                                                                 //serial initialization
           // LED = 0x00; 
            printf("AT+CMGF=1%c",13);                                        
             delay2(20);  //Text Mode            | hex value of 13 is 0x0D (CR )
            printf("AT+CMGS=\"8939965828\"%c",13); delay2(20);           //Type your mobile number Eg : "9884467058"
           // led_left();                 //scroll left
                        delay1(20);
            printf("Sos-Warning:");                   
              delay2(20);  //Type text as u want
                printf(earthquake);                   
              delay2(20);  //Type text as u want
            printf("%c",0x1A);                                                             
            delay2(20);  //line feed command

          		// Mobile Communication end
}
 

 
}
 } 
//this one is slow and unsave....
long readMultiValueContinuousAVG(int amount, int delayMilis){
	long value = 0;
	char bufDataRead[] = { 0x5C }; //select Data reg for continous read 
	transfer(bufDataRead, sizeof(bufDataRead));
	
	int valuesRead=0;
	int emptyCount=0;
	long fullData=0;
	int rdy=1;
	while (emptyCount<20 && valuesRead<amount) {
		/*
		char buf[] = { 0x00 };
		transfer(buf, 1);
		
		if (buf[0] == 0xFF){
			delay(100); //Data not yet available, wait 100ms
			++emptyCount;
		} else {
			fullData = buf[0];
			
			char buf[] = { 0x00, 0x00 };
			transfer(buf, 2);
			
			fullData = (fullData << 8) | buf[0];
			fullData = (fullData << 8) | buf[1];
			if (fullData != 0){ //it's not possible to be value 0
				value += fullData;
				valuesRead++;
			} else {
				++emptyCount;
			}
		}
		*/
		
		/*
		char buf[] = { 0x00, 0x00, 0x00 };
		transfer(buf, 3);
		
		fullData = buf[0];
		fullData = (fullData << 8) | buf[1];
		fullData = (fullData << 8) | buf[2];
		if (fullData != 0 && fullData != 0xFFFFFF){
			value += fullData;
			valuesRead++;
		}
		*/
		
		/* //This is not the correct way for check rdy-pin is fall low
		rdy=1;
		int rdyTimes=0;
		while(rdy==1 && rdyTimes<10000){
			delayMicroseconds(100);
			rdy = bcm2835_gpio_lev(RDY_PIN);
			++rdyTimes;
		}
		printf("%d times check if ready\n",rdyTimes);
		
		char buf[] = { 0x00, 0x00, 0x00 };
		transfer(buf, 3);
		
		fullData = buf[0];
		fullData = (fullData << 8) | buf[1];
		fullData = (fullData << 8) | buf[2];
		value += fullData;
		valuesRead++;
		*/
		
		/* //logic error, this wouldn't use value if a byte of it have realy the value 0xFF
		if (buf[0] == 0xFF){
			nanosleep(100000); //Data not yet available, wait 100ms
			emptyCount++;
			if (valIndex != 0){
				printf("uncomplete data");
				valIndex=0;
			}
		} else {
			value[valIndex] = buf[0];
			if (valIndex<2) {
				valIndex++;
			} else {
				long fullData = value[0];
				fullData = (fullData << 8) | value[1];
				fullData = (fullData << 8) | value[2];
				valIndex=0;
				value += fullData;
				valuesRead++;
			}
		}
		*/
		
		/*if (valuesRead>0){
			printf("Value at input %d: %d / %06X sum %d avg %d\n", currentInput, fullData, fullData, value, value / valuesRead);
		} else {
			printf("Value at input %d: %d / %06X sum %d\n", currentInput, fullData, fullData, value);
		}*/
		if (delayMilis>0){
			delay(delayMilis);
		}
	}
	
	char bufDataEndRead[] = { 0x58, 0x00, 0x00, 0x00 }; //stop continous read -> select Data reg for read   and read 3 bytes(to be sure it's back in command promt mode.)
	transfer(bufDataEndRead, sizeof(bufDataEndRead));
	
	if (valuesRead == 0){
		return -1;
	} else {
		return value / valuesRead;
	}
}
long readSingleValueFromInput(int input){
	changeInput(input);
	delay(120);
	return readSingleValue();
}
示例#10
0
文件: relayh.c 项目: timburrow/ovj3
pulsesequence()
{
   int          i,
		relay;

/* GET NEW PARAMETERS */
   relay = (int) (getval("relay") + 0.5);

/* CHECK CONDITIONS */
   if (p1 == 0.0)
      p1 = pw;


/* CALCULATE PHASES */
   sub(ct, ssctr, v11);		     /* v11 = ct-ss */
   initval(256.0, v12);
   add(v11, v12, v11);		     /* v11 = ct-ss+256 */
   hlv(v11, v1);		     /* v1 = cyclops = 00112233 */
   for (i = 0; i < relay + 1; i++)
      hlv(v1, v1);		     /* cyclops = 2**(relay+2) 0's, 1's, 2's,
					3's */

   mod4(v11, v2);		     /* v2 = 0123 0123... */
   dbl(v2, oph);		     /* oph = 0202 0202 */
   add(v2, v1, v2);		     /* v2 = 0123 0123 + cyclops */
   add(oph, v1, oph);		     /* oph = 0202 0202 + cyclops */
   hlv(v11, v3);		     /* v3 = 0011 2233 4455 ... */


/* PULSE SEQUENCE */
   status(A);
      if (rof1 == 0.0)
      {
         rof1 = 1.0e-6;		     /* phase switching time */
         rcvroff();
      }
      hsdelay(d1);		     /* preparation period */

   status(B);
      rgpulse(pw, v1, rof1, rof1);
      delay(d2);		     /* evolution period */
   status(A);
      if (relay == 0)
         delay(tau);		     /* for delayed cosy */
      rgpulse(p1, v2, rof1, rof1);   /* start of mixing period */
      if (relay == 0)
         delay(tau);		     /* for delayed cosy */

      for (i = 0; i < relay; i++)    /* relay coherence */
      {
         hlv(v3, v3);		     /* v3=2**(relay+1) 0's, 1's, 2's, 3's */
         dbl(v3, v4);		     /* v4=2**(relay+1) 0's, 2's, 0's, 2's */
         add(v2, v4, v5);	     /* v5=v4+v2 (including cyclops) */
         delay(tau/2);
         rgpulse(2.0*pw, v2, rof1, rof1);
         delay(tau/2);
         rgpulse(pw, v5, rof1, rof1);
      }

   status(C);
      delay(rof2);
      rcvron();
}
示例#11
0
文件: xfs_dquot.c 项目: ditsing/xfsd
/*
 * Given the file system, inode OR id, and type (UDQUOT/GDQUOT), return a
 * a locked dquot, doing an allocation (if requested) as needed.
 * When both an inode and an id are given, the inode's id takes precedence.
 * That is, if the id changes while we don't hold the ilock inside this
 * function, the new dquot is returned, not necessarily the one requested
 * in the id argument.
 */
int
xfs_qm_dqget(
	xfs_mount_t	*mp,
	xfs_inode_t	*ip,	  /* locked inode (optional) */
	xfs_dqid_t	id,	  /* uid/projid/gid depending on type */
	uint		type,	  /* XFS_DQ_USER/XFS_DQ_PROJ/XFS_DQ_GROUP */
	uint		flags,	  /* DQALLOC, DQSUSER, DQREPAIR, DOWARN */
	xfs_dquot_t	**O_dqpp) /* OUT : locked incore dquot */
{
	struct xfs_quotainfo	*qi = mp->m_quotainfo;
	struct radix_tree_root *tree = XFS_DQUOT_TREE(qi, type);
	struct xfs_dquot	*dqp;
	int			error;

	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
	if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) ||
	    (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) ||
	    (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) {
		return (ESRCH);
	}

#ifdef DEBUG
	if (xfs_do_dqerror) {
		if ((xfs_dqerror_target == mp->m_ddev_targp) &&
		    (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) {
			xfs_debug(mp, "Returning error in dqget");
			return (EIO);
		}
	}

	ASSERT(type == XFS_DQ_USER ||
	       type == XFS_DQ_PROJ ||
	       type == XFS_DQ_GROUP);
	if (ip) {
		ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
		ASSERT(xfs_inode_dquot(ip, type) == NULL);
	}
#endif

restart:
	mutex_lock(&qi->qi_tree_lock);
	dqp = radix_tree_lookup(tree, id);
	if (dqp) {
		xfs_dqlock(dqp);
		if (dqp->dq_flags & XFS_DQ_FREEING) {
			xfs_dqunlock(dqp);
			mutex_unlock(&qi->qi_tree_lock);
			trace_xfs_dqget_freeing(dqp);
			delay(1);
			goto restart;
		}

		dqp->q_nrefs++;
		mutex_unlock(&qi->qi_tree_lock);

		trace_xfs_dqget_hit(dqp);
		XFS_STATS_INC(xs_qm_dqcachehits);
		*O_dqpp = dqp;
		return 0;
	}
	mutex_unlock(&qi->qi_tree_lock);
	XFS_STATS_INC(xs_qm_dqcachemisses);

	/*
	 * Dquot cache miss. We don't want to keep the inode lock across
	 * a (potential) disk read. Also we don't want to deal with the lock
	 * ordering between quotainode and this inode. OTOH, dropping the inode
	 * lock here means dealing with a chown that can happen before
	 * we re-acquire the lock.
	 */
	if (ip)
		xfs_iunlock(ip, XFS_ILOCK_EXCL);

	error = xfs_qm_dqread(mp, id, type, flags, &dqp);

	if (ip)
		xfs_ilock(ip, XFS_ILOCK_EXCL);

	if (error)
		return error;

	if (ip) {
		/*
		 * A dquot could be attached to this inode by now, since
		 * we had dropped the ilock.
		 */
		if (xfs_this_quota_on(mp, type)) {
			struct xfs_dquot	*dqp1;

			dqp1 = xfs_inode_dquot(ip, type);
			if (dqp1) {
				xfs_qm_dqdestroy(dqp);
				dqp = dqp1;
				xfs_dqlock(dqp);
				goto dqret;
			}
		} else {
			/* inode stays locked on return */
			xfs_qm_dqdestroy(dqp);
			return XFS_ERROR(ESRCH);
		}
	}

	mutex_lock(&qi->qi_tree_lock);
	error = -radix_tree_insert(tree, id, dqp);
	if (unlikely(error)) {
		WARN_ON(error != EEXIST);

		/*
		 * Duplicate found. Just throw away the new dquot and start
		 * over.
		 */
		mutex_unlock(&qi->qi_tree_lock);
		trace_xfs_dqget_dup(dqp);
		xfs_qm_dqdestroy(dqp);
		XFS_STATS_INC(xs_qm_dquot_dups);
		goto restart;
	}

	/*
	 * We return a locked dquot to the caller, with a reference taken
	 */
	xfs_dqlock(dqp);
	dqp->q_nrefs = 1;

	qi->qi_dquots++;
	mutex_unlock(&qi->qi_tree_lock);

 dqret:
	ASSERT((ip == NULL) || xfs_isilocked(ip, XFS_ILOCK_EXCL));
	trace_xfs_dqget_miss(dqp);
	*O_dqpp = dqp;
	return (0);
}
示例#12
0
static bool hmc5883lInit(void)
{
    int16_t magADC[3];
    int32_t xyz_total[3] = { 0, 0, 0 }; // 32 bit totals so they won't overflow.
    bool bret = true;           // Error indicator

    delay(50);
    i2cWrite(MAG_I2C_INSTANCE, MAG_ADDRESS, HMC58X3_R_CONFA, 0x010 + HMC_POS_BIAS);   // Reg A DOR = 0x010 + MS1, MS0 set to pos bias
    // Note that the  very first measurement after a gain change maintains the same gain as the previous setting.
    // The new gain setting is effective from the second measurement and on.
    i2cWrite(MAG_I2C_INSTANCE, MAG_ADDRESS, HMC58X3_R_CONFB, 0x60); // Set the Gain to 2.5Ga (7:5->011)
    delay(100);
    hmc5883lRead(magADC);

    int validSamples1 = 0;
    int failedSamples1 = 0;
    int saturatedSamples1 = 0;
    while (validSamples1 < 10 && failedSamples1 < INITIALISATION_MAX_READ_FAILURES) { // Collect 10 samples
        i2cWrite(MAG_I2C_INSTANCE, MAG_ADDRESS, HMC58X3_R_MODE, 1);
        delay(70);
        if (hmc5883lRead(magADC)) { // Get the raw values in case the scales have already been changed.
            // Detect saturation.
            if (-4096 >= MIN(magADC[X], MIN(magADC[Y], magADC[Z]))) {
                ++saturatedSamples1;
                ++failedSamples1;
            } else {
                ++validSamples1;
                // Since the measurements are noisy, they should be averaged rather than taking the max.
                xyz_total[X] += magADC[X];
                xyz_total[Y] += magADC[Y];
                xyz_total[Z] += magADC[Z];

            }
        } else {
            ++failedSamples1;
        }
        LED1_TOGGLE;
    }

    // Apply the negative bias. (Same gain)
    i2cWrite(MAG_I2C_INSTANCE, MAG_ADDRESS, HMC58X3_R_CONFA, 0x010 + HMC_NEG_BIAS);   // Reg A DOR = 0x010 + MS1, MS0 set to negative bias.
    int validSamples2 = 0;
    int failedSamples2 = 0;
    int saturatedSamples2 = 0;
    while (validSamples2 < 10 && failedSamples2 < INITIALISATION_MAX_READ_FAILURES) { // Collect 10 samples
        i2cWrite(MAG_I2C_INSTANCE, MAG_ADDRESS, HMC58X3_R_MODE, 1);
        delay(70);
        if (hmc5883lRead(magADC)) { // Get the raw values in case the scales have already been changed.
            // Detect saturation.
            if (-4096 >= MIN(magADC[X], MIN(magADC[Y], magADC[Z]))) {
                ++saturatedSamples2;
                ++failedSamples2;
            } else {
                ++validSamples2;
                // Since the measurements are noisy, they should be averaged.
                xyz_total[X] -= magADC[X];
                xyz_total[Y] -= magADC[Y];
                xyz_total[Z] -= magADC[Z];
            }
        } else {
            ++failedSamples2;
        }
        LED1_TOGGLE;
    }

    if (failedSamples1 >= INITIALISATION_MAX_READ_FAILURES || failedSamples2 >= INITIALISATION_MAX_READ_FAILURES) {
        addBootlogEvent4(BOOT_EVENT_HMC5883L_READ_OK_COUNT, BOOT_EVENT_FLAGS_NONE, validSamples1, validSamples2);
        addBootlogEvent4(BOOT_EVENT_HMC5883L_READ_FAILED, BOOT_EVENT_FLAGS_WARNING, failedSamples1, failedSamples2);
        bret = false;
    }
    if (saturatedSamples1 > 0 || saturatedSamples2 > 0) {
        addBootlogEvent4(BOOT_EVENT_HMC5883L_SATURATION, BOOT_EVENT_FLAGS_WARNING, saturatedSamples1, saturatedSamples2);
    }

    if (bret) {
        magGain[X] = fabsf(660.0f * HMC58X3_X_SELF_TEST_GAUSS * 2.0f * 10.0f / xyz_total[X]);
        magGain[Y] = fabsf(660.0f * HMC58X3_Y_SELF_TEST_GAUSS * 2.0f * 10.0f / xyz_total[Y]);
        magGain[Z] = fabsf(660.0f * HMC58X3_Z_SELF_TEST_GAUSS * 2.0f * 10.0f / xyz_total[Z]);
    } else {
        // Something went wrong so get a best guess
        magGain[X] = 1.0f;
        magGain[Y] = 1.0f;
        magGain[Z] = 1.0f;
    }

    // leave test mode
    i2cWrite(MAG_I2C_INSTANCE, MAG_ADDRESS, HMC58X3_R_CONFA, 0x70);   // Configuration Register A  -- 0 11 100 00  num samples: 8 ; output rate: 15Hz ; normal measurement mode
    i2cWrite(MAG_I2C_INSTANCE, MAG_ADDRESS, HMC58X3_R_CONFB, 0x20);   // Configuration Register B  -- 001 00000    configuration gain 1.3Ga
    i2cWrite(MAG_I2C_INSTANCE, MAG_ADDRESS, HMC58X3_R_MODE, 0x00);    // Mode register             -- 000000 00    continuous Conversion Mode
    delay(100);

    hmc5883lConfigureDataReadyInterruptHandling();

    return bret;
}
示例#13
0
void main5()
{
int gd=DETECT,gm=0,col=0,dol=600;
initgraph(&gd,&gm,"c:/tc/bgi");

settextstyle(10,HORIZ_DIR,1);
outtextxy(30,30,"");
settextstyle(11,HORIZ_DIR,1);
settextstyle(10,HORIZ_DIR,1);
outtextxy(30,200,"Hit ENTER to Start the Magic...");
settextstyle(12,HORIZ_DIR,1);
getch();
cleardevice();

while(!kbhit())
{
for(int j=0;j<=50;j++)
{
{
setcolor(2);
circle(col,100,50+j);
setfillstyle(4,2);
floodfill(col,100,2);
delay(3);
col++;
if(col>=600)
col=0;
}


 {
setcolor(4);
circle(dol,330,50+j);
setfillstyle(5,4);
floodfill(dol,330,4);
delay(3);
dol--;
if(dol<=0)
dol=600;
}


for(int i=1;i<=15;i++)
{
if(col==200)
{
setbkcolor(random(i));
}
if(col==400)
{
setbkcolor(random(i));
}
}//for inner close
}//for outer loop

for(int k=1;k<=120;k++)
{
setcolor(random(15));
circle(300,250,1+k);
delay(1);

}

cleardevice();

}
closegraph();
getch();

}
boolean ALB_DHT11::read(bool force)
{
	// Check if sensor was read less than two seconds ago and return early
	// to use last reading.
	uint32_t currenttime = millis();
	if (!force && ((currenttime - _lastreadtime) < 2000))
	{
		return _lastresult; // return last correct measurement
	}
	_lastreadtime = currenttime;

	// Reset 40 bits of received data to zero.
	data[0] = data[1] = data[2] = data[3] = data[4] = 0;

	// Send start signal.  See DHT datasheet for full signal diagram:
	//   http://www.adafruit.com/datasheets/Digital%20humidity%20and%20temperature%20sensor%20AM2302.pdf

	// Go into high impedence state to let pull-up raise data line level and
	// start the reading process.
	digitalWrite(_pin, HIGH);
	delay(250);

	// First set data line low for 20 milliseconds.
	pinMode(_pin, OUTPUT);
	digitalWrite(_pin, LOW);
	delay(20);

	uint32_t cycles[80];
	{
		// Turn off interrupts temporarily because the next sections are timing critical
		// and we don't want any interruptions.
		InterruptLock lock;

		// End the start signal by setting data line high for 40 microseconds.
		digitalWrite(_pin, HIGH);
		delayMicroseconds(40);

		// Now start reading the data line to get the value from the DHT sensor.
		pinMode(_pin, INPUT_PULLUP);
		delayMicroseconds(10);  // Delay a bit to let sensor pull data line low.

		// First expect a low signal for ~80 microseconds followed by a high signal
		// for ~80 microseconds again.
		if (expectPulse(LOW) == 0)
		{
			_lastresult = false;
			return _lastresult;
		}
		if (expectPulse(HIGH) == 0)
		{
			_lastresult = false;
			return _lastresult;
		}

		// Now read the 40 bits sent by the sensor.  Each bit is sent as a 50
		// microsecond low pulse followed by a variable length high pulse.  If the
		// high pulse is ~28 microseconds then it's a 0 and if it's ~70 microseconds
		// then it's a 1.  We measure the cycle count of the initial 50us low pulse
		// and use that to compare to the cycle count of the high pulse to determine
		// if the bit is a 0 (high state cycle count < low state cycle count), or a
		// 1 (high state cycle count > low state cycle count). Note that for speed all
		// the pulses are read into a array and then examined in a later step.
		for (int i = 0; i < 80; i += 2)
		{
			cycles[i]   = expectPulse(LOW);
			cycles[i + 1] = expectPulse(HIGH);
		}
	} // Timing critical code is now complete.

	// Inspect pulses and determine which ones are 0 (high state cycle count < low
	// state cycle count), or 1 (high state cycle count > low state cycle count).
	for (int i = 0; i < 40; ++i)
	{
		uint32_t lowCycles  = cycles[2 * i];
		uint32_t highCycles = cycles[2 * i + 1];
		if ((lowCycles == 0) || (highCycles == 0))
		{
			_lastresult = false;
			return _lastresult;
		}
		data[i / 8] <<= 1;
		// Now compare the low and high cycle times to see if the bit is a 0 or 1.
		if (highCycles > lowCycles)
		{
			// High cycles are greater than 50us low cycle count, must be a 1.
			data[i / 8] |= 1;
		}
		// Else high cycles are less than (or equal to, a weird case) the 50us low
		// cycle count so this must be a zero.  Nothing needs to be changed in the
		// stored data.
	}

	// Check we read 40 bits and that the checksum matches.
	if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF))
	{
		_lastresult = true;
		return _lastresult;
	}
	else
	{
		_lastresult = false;
		return _lastresult;
	}
}
示例#15
0
//use only 4 char titles (should be changed soon)
void generic_dual_display (char title1[ ], long high1, long cur_value1, long peak1, long hiWarn1, long loWarn1, boolean hilo1, char title2[ ], long high2, long cur_value2, long peak2, long hiWarn2, long loWarn2, boolean hilo2){
  int ndigits = 0;
  Serial.print(0xFE, BYTE);  
  Serial.print(128, BYTE);
  Serial.print(title1);
  Serial.print(" ");
  if ( (hilo1 == true) && (cur_value1 == 0) ){
   Serial.print("LOW  "); 
  }
  else if ( (hilo1 == true) && (cur_value1 == 9999) ){
   Serial.print("HIGH  "); 
  }
  else {
    Serial.print(cur_value1/10);
    Serial.print(".");
    Serial.print(cur_value1%10);
    ndigits = numberofdigits(cur_value1) + 1;
    if (ndigits <= 2){ ndigits = ndigits + 1;}
    for (int i = 0; i < 5 - ndigits; i++) {
     Serial.print(" "); 
    }
  }
  Serial.print("/");
  ndigits = numberofdigits(peak1) + 1;
  if (ndigits <= 2){ ndigits = ndigits + 1;}
  for (int i = 0; i < 6 - ndigits; i++){
   Serial.print(" "); 
  }
  Serial.print(peak1/10);
  Serial.print(".");
  Serial.print(peak1%10);
  if ( (cur_value1 > hiWarn1) || (cur_value1 < loWarn1) ){ //blink if warning threshold is met
    warn_flash();
  }
   Serial.print(0xFE, BYTE);   //select the second line
   Serial.print(192, BYTE);  
  Serial.print(title2);
  Serial.print(" ");
  if ( (hilo2 == true) && (cur_value2 == 0) ){
    Serial.print("LOW  ");
  }
  else if ( (hilo2 == true) && (cur_value2 == 9999) ){
    Serial.print("HIGH ");
  }
  else {
    Serial.print(cur_value2/10);
    Serial.print(".");
    Serial.print(cur_value2%10);
    ndigits = numberofdigits(cur_value2) + 1;
    if (ndigits <= 2){ ndigits = ndigits + 1;}
    for (int i = 0; i < 5 - ndigits; i++) {
     Serial.print(" "); 
    }
  }
  Serial.print("/");
  ndigits = numberofdigits(peak2) + 1;
  if (ndigits <= 2){ ndigits = ndigits + 1;}
  for (int i = 0; i < 6 - ndigits; i++){
   Serial.print(" "); 
  }
  Serial.print(peak2/10);
  Serial.print(".");
  Serial.print(peak2%10);
  if ( (cur_value2 > hiWarn2) || (cur_value2 < loWarn2) ){ //blink if warning threshold is met
     warn_flash();
  }
  delay(100);
}
long readAvgValueFromInput(int input, int avgOver, int delayMilis){
	changeInput(input);
	delay(120);
	return readMultiValueAVG(avgOver, delayMilis);
}
示例#17
0
int GSM::begin(long baud_rate){
	int response=-1;
	int cont=0;
	boolean norep=false;
	boolean turnedON=false;
	SetCommLineStatus(CLS_ATCMD);
	_cell.begin(baud_rate);
	setStatus(IDLE); 

	
	for (cont=0; cont<3; cont++){
		if (AT_RESP_ERR_NO_RESP == SendATCmdWaitResp("AT", 500, 100, "OK", 5)&&!turnedON) {		//check power
	    // there is no response => turn on the module
			#ifdef DEBUG_ON
				Serial.println("DB:NO RESP");
			#endif
			// generate turn on pulse
			digitalWrite(GSM_ON, HIGH);
			delay(1200);
			digitalWrite(GSM_ON, LOW);
			delay(10000);
			norep=true;
		}
		else{
			#ifdef DEBUG_ON
				Serial.println("DB:ELSE");
			#endif
			norep=false;
		}
	}
	
	if (AT_RESP_OK == SendATCmdWaitResp("AT", 500, 100, "OK", 5)){
		#ifdef DEBUG_ON
			Serial.println("DB:CORRECT BR");
		#endif
		turnedON=true;
	}
	if(cont==3&&norep){
		Serial.println("Trying to force the baud-rate to 9600\n");
		for (int i=0;i<8;i++){
		switch (i) {
			case 0:
			  _cell.begin(1200);
			  _cell.print(F("AT+IPR=9600\r"));
			  break;
			  
			case 1:
			  _cell.begin(2400);
			  _cell.print(F("AT+IPR=9600\r"));
			  break;
			  
			case 2:
			  _cell.begin(4800);
			  _cell.print(F("AT+IPR=9600\r"));
			  break;
			  
			case 3:
			  _cell.begin(9600);
			  _cell.print(F("AT+IPR=9600\r"));
			  break;
			   
			case 4:
			  _cell.begin(19200);
			  _cell.print(F("AT+IPR=9600\r"));
			  break;
			  
			case 5:
			  _cell.begin(38400);
			  _cell.print(F("AT+IPR=9600\r"));
			  break;
			  
			case 6:
			  _cell.begin(57600);
			  _cell.print(F("AT+IPR=9600\r"));
			  break;
			  
			case 7:
			  _cell.begin(115200);
			  _cell.print(F("AT+IPR=9600\r"));
			  break;
			}	
		}
		Serial.println("ERROR: SIM900 doesn't answer. Check power and serial pins in GSM.cpp");
		return 0;
	}


	if (AT_RESP_ERR_DIF_RESP == SendATCmdWaitResp("AT", 500, 100, "OK", 5)&&!turnedON){		//check OK
		#ifdef DEBUG_ON
			Serial.println("DB:DIFF RESP");
		#endif
		for (int i=0;i<8;i++){
			switch (i) {
			case 0:
			  _cell.begin(1200);
			  break;
			  
			case 1:
			  _cell.begin(2400);
			  break;
			  
			case 2:
			  _cell.begin(4800);
			  break;
			  
			case 3:
			  _cell.begin(9600);
			  break;
			   
			case 4:
			  _cell.begin(19200);
			  break;
			  
			case 5:
			  _cell.begin(38400);
			  break;
			  
			case 6:
			  _cell.begin(57600);
			  break;
			  
			case 7:
			  _cell.begin(115200);
			  _cell.print(F("AT+IPR=9600\r"));
			  _cell.begin(9600);
			  delay(500);
			  break;
  
			// if nothing else matches, do the default
			// default is optional
			}
					
			delay(100);

			#ifdef DEBUG_PRINT
				// parameter 0 - because module is off so it is not necessary 
				// to send finish AT<CR> here
				DebugPrint("DEBUG: Stringa ", 0);
				DebugPrint(buff, 0);
			#endif
				

			if (AT_RESP_OK == SendATCmdWaitResp("AT", 500, 100, "OK", 5)){
				#ifdef DEBUG_ON
					Serial.println("DB:FOUND PREV BR");
				#endif
				_cell.print(F("AT+IPR="));
				_cell.print(baud_rate);    
				_cell.print("\r"); // send <CR>
				delay(500);
				_cell.begin(baud_rate);
				delay(100);
				if (AT_RESP_OK == SendATCmdWaitResp("AT", 500, 100, "OK", 5)){
					#ifdef DEBUG_ON
						Serial.println("DB:OK BR");
					#endif
				}
				turnedON=true;
				break;					
			}
			#ifdef DEBUG_ON
				Serial.println("DB:NO BR");
			#endif			
		}
		// communication line is not used yet = free
		SetCommLineStatus(CLS_FREE);
		// pointer is initialized to the first item of comm. buffer
		p_comm_buf = &comm_buf[0];
	}

	SetCommLineStatus(CLS_FREE);

	if(turnedON){
		WaitResp(50, 50);
		InitParam(PARAM_SET_0);
		InitParam(PARAM_SET_1);//configure the module  
		Echo(0);               //enable AT echo
		setStatus(READY);
		return(1);

	}
	else{
		//just to try to fix some problems with 115200 baudrate
		_cell.begin(115200);
		delay(1000);
		_cell.print(F("AT+IPR="));
		_cell.print(baud_rate);    
		_cell.print("\r"); // send <CR>		
		return(0);
	}
}
示例#18
0
void
sbscn_attach_channel(struct sbscn_softc *sc, int chan, int intr)
{
	struct sbscn_channel *ch = &sc->sc_channels[chan];
	u_long chan_addr;
	struct tty *tp;

	ch->ch_sc = sc;
	ch->ch_num = chan;

	chan_addr = sc->sc_addr + (0x100 * chan);
	ch->ch_base = (void *)MIPS_PHYS_TO_KSEG1(chan_addr);
	ch->ch_isr_base =
	    (void *)MIPS_PHYS_TO_KSEG1(sc->sc_addr + 0x220 + (0x20 * chan));
	ch->ch_imr_base =
	    (void *)MIPS_PHYS_TO_KSEG1(sc->sc_addr + 0x230 + (0x20 * chan));
#ifdef XXXCGDnotyet
	ch->ch_inchg_base =
	    (void *)MIPS_PHYS_TO_KSEG1(sc->sc_addr + 0x2d0 + (0x10 * chan));
#endif

	ch->ch_i_dcd = ch->ch_i_dcd_pin = 0 /* XXXCGD */;
	ch->ch_i_cts = ch->ch_i_cts_pin = 0 /* XXXCGD */;
	ch->ch_i_dsr = ch->ch_i_dsr_pin = 0 /* XXXCGD */;
	ch->ch_i_ri = ch->ch_i_ri_pin = 0 /* XXXCGD */;
	ch->ch_i_mask =
	    ch->ch_i_dcd | ch->ch_i_cts | ch->ch_i_dsr | ch->ch_i_ri;
	ch->ch_o_dtr = ch->ch_o_dtr_pin = 0 /* XXXCGD */;
	ch->ch_o_rts = ch->ch_o_rts_pin = 0 /* XXXCGD */;
	ch->ch_o_mask = ch->ch_o_dtr | ch->ch_o_rts;

	ch->ch_intrhand = cpu_intr_establish(intr, IPL_SERIAL, sbscn_intr, ch);
	callout_init(&ch->ch_diag_callout, 0);

	/* Disable interrupts before configuring the device. */
	ch->ch_imr = 0;
	WRITE_REG(ch->ch_imr_base, ch->ch_imr);

	if (sbscn_cons_present &&
	    sbscn_cons_addr == chan_addr && sbscn_cons_chan == chan) {
		sbscn_cons_attached = 1;

		/* Make sure the console is always "hardwired". */
		delay(1000);			/* wait for output to finish */
		SET(ch->ch_hwflags, SBSCN_HW_CONSOLE);
		SET(ch->ch_swflags, TIOCFLAG_SOFTCAR);
	}

	tp = ttymalloc();
	tp->t_oproc = sbscn_start;
	tp->t_param = sbscn_param;
	tp->t_hwiflow = sbscn_hwiflow;

	ch->ch_tty = tp;
	ch->ch_rbuf = malloc(sbscn_rbuf_size << 1, M_DEVBUF, M_NOWAIT);
	if (ch->ch_rbuf == NULL) {
		printf("%s: channel %d: unable to allocate ring buffer\n",
		    sc->sc_dev.dv_xname, chan);
		return;
	}
	ch->ch_ebuf = ch->ch_rbuf + (sbscn_rbuf_size << 1);

	tty_attach(tp);

	if (ISSET(ch->ch_hwflags, SBSCN_HW_CONSOLE)) {
		int maj;

		/* locate the major number */
		maj = cdevsw_lookup_major(&sbscn_cdevsw);

		cn_tab->cn_dev = makedev(maj,
		    (device_unit(&sc->sc_dev) << 1) + chan);

		printf("%s: channel %d: console\n", sc->sc_dev.dv_xname, chan);
	}

#ifdef KGDB
	/*
	 * Allow kgdb to "take over" this port.  If this is
	 * the kgdb device, it has exclusive use.
	 */
	if (sbscn_kgdb_present &&
	    sbscn_kgdb_addr == chan_addr && sbscn_kgdb_chan == chan) {
		sbscn_kgdb_attached = 1;

		SET(sc->sc_hwflags, SBSCN_HW_KGDB);
		printf("%s: channel %d: kgdb\n", sc->sc_dev.dv_xname, chan);
	}
#endif

	ch->ch_si = softint_establish(SOFTINT_SERIAL, sbscn_soft, ch);

#if NRND > 0 && defined(RND_SBSCN)
	rnd_attach_source(&ch->ch_rnd_source, sc->sc_dev.dv_xname,
			  RND_TYPE_TTY, 0);
#endif

	sbscn_config(ch);

	SET(ch->ch_hwflags, SBSCN_HW_DEV_OK);
}
示例#19
0
pulsesequence() 
{ 
   double          gzlvl2 = getval("gzlvl2"), 
                   gt2 = getval("gt2"), 
                   gzlvl0 = getval("gzlvl0"), 
                   gt0 = getval("gt0"), 
                   gstab = getval("gstab"), 
                   phincr1 = getval("phincr1"), 
                   trim = getval("trim"),
                   trimpwr = getval("trimpwr"),
                   flippwr = getval("flippwr"),
                   flippwrf = getval("flippwrf"),
                   flippw = getval("flippw"),
		   wrefpwr = getval("wrefpwr"),
                   wrefpw = getval("wrefpw"),
                   wrefpwrf = getval("wrefpwrf");
 
   char  sspul[MAXSTR],wrefshape[MAXSTR],flipshape[MAXSTR],flipback[MAXSTR],
	 trim_flg[MAXSTR],alt_grd[MAXSTR]; 
 
/* LOAD VARIABLES */ 
 
   rof1 = getval("rof1"); if (rof1 > 2.0e-6) rof1=2.0e-6;
   getstr("sspul",sspul); 
   getstr("wrefshape", wrefshape);
   getstr("flipshape", flipshape);
   getstr("flipback", flipback);
   getstr("trim_flg", trim_flg);
   getstr("alt_grd",alt_grd);
   if (phincr1 < 0.0) phincr1=360+phincr1;
   initval(phincr1,v9);
 
/* CALCULATE PHASECYCLE */ 
         
   settable(t1,1,ph1); 
   settable(t2,16,ph2); 
   settable(t3,16,ph3); 
   settable(t4,4,ph4);
   settable(t5,4,ph5);
   settable(t6,16,phr); 
 
   sub(ct,ssctr,v12); 
   getelem(t1,v12,v1); 
   getelem(t2,v12,v2); 
   getelem(t3,v12,v3); 
   getelem(t4,v12,v4);
   getelem(t5,v12,v5);
   getelem(t6,v12,oph); 
 
   if (alt_grd[0] == 'y') mod2(ct,v6);
               /* alternate gradient sign on every 2nd transient */
 
/* BEGIN THE ACTUAL PULSE SEQUENCE */ 
 status(A); 
      obspower(tpwr); 
      if (sspul[A] == 'y') 
      { 
       zgradpulse(gzlvl0,gt0); 
       rgpulse(pw,zero,rof1,rof1); 
       zgradpulse(gzlvl0,gt0); 
      } 
      if (satmode[A] == 'y') 
       { 
        if (d1>satdly) delay(d1-satdly);
        if (fabs(tof-satfrq)>0.0) obsoffset(satfrq); 
        obspower(satpwr); 
        rgpulse(satdly,zero,rof1,rof1); 
        if (fabs(tof-satfrq)>0.0) obsoffset(tof); 
        obspower(tpwr); 
       } 
      else 
       delay(d1); 

     status(B); 
      if (flipback[A] == 'y') 
      { 
      obsstepsize(1.0);
      xmtrphase(v9);
      add(v1,two,v8);
      obspower(flippwr+6); obspwrf(flippwrf);
      shaped_pulse(flipshape,flippw,v8,rof1,rof1); 
      xmtrphase(zero);
      obspower(tpwr); obspwrf(4095.0);
      } 
      rgpulse(pw, v1, rof1, rof1); 
 
       ifzero(v6); zgradpulse(gzlvl2,gt2);
              elsenz(v6); zgradpulse(-gzlvl2,gt2); endif(v6);
       obspower(wrefpwr+6); obspwrf(wrefpwrf);
       delay(gstab);
       shaped_pulse(wrefshape,wrefpw,v2,rof1,rof1);
       obspower(tpwr); obspwrf(4095.0);
       rgpulse(2.0*pw,v3,rof1,rof1);
       ifzero(v6); zgradpulse(gzlvl2,gt2);
              elsenz(v6); zgradpulse(-gzlvl2,gt2); endif(v6);
       obspower(wrefpwr+6); obspwrf(wrefpwrf);
       delay(gstab);
       ifzero(v6); zgradpulse(1.2*gzlvl2,gt2);
              elsenz(v6); zgradpulse(-1.2*gzlvl2,gt2); endif(v6);
       delay(gstab);
       shaped_pulse(wrefshape,wrefpw,v4,rof1,rof1);
       obspower(tpwr); obspwrf(4095.0);
       if (trim_flg[A] == 'y') rgpulse(2.0*pw,v5,rof1,0.0);
       else        rgpulse(2.0*pw,v5,rof1,rof2);
       ifzero(v6); zgradpulse(1.2*gzlvl2,gt2);
              elsenz(v6); zgradpulse(-1.2*gzlvl2,gt2); endif(v6);
       delay(gstab);
       if (trim_flg[A] == 'y')
           { obspower(trimpwr);
             add(v1,one,v10);
            rgpulse(trim,v10,rof1,rof2);
           }
     status(C);
} 
示例#20
0
// Mount the specified SD card, returning true if done, false if needs to be called again.
// If an error occurs, return true with the error message in 'reply'.
// This may only be called to mount one card at a time.
GCodeResult MassStorage::Mount(size_t card, const StringRef& reply, bool reportSuccess)
{
	if (card >= NumSdCards)
	{
		reply.copy("SD card number out of range");
		return GCodeResult::error;
	}

	SdCardInfo& inf = info[card];
	MutexLocker lock1(fsMutex);
	MutexLocker lock2(inf.volMutex);
	if (!inf.mounting)
	{
		if (inf.isMounted)
		{
			if (AnyFileOpen(&inf.fileSystem))
			{
				// Don't re-mount the card if any files are open on it
				reply.copy("SD card has open file(s)");
				return GCodeResult::error;
			}
			(void)InternalUnmount(card, false);
		}

		inf.mountStartTime = millis();
		inf.mounting = true;
		delay(2);
	}

	if (inf.cardState == CardDetectState::notPresent)
	{
		reply.copy("No SD card present");
		inf.mounting = false;
		return GCodeResult::error;
	}

	if (inf.cardState != CardDetectState::present)
	{
		return GCodeResult::notFinished;						// wait for debounce to finish
	}

	const sd_mmc_err_t err = sd_mmc_check(card);
	if (err != SD_MMC_OK && millis() - inf.mountStartTime < 5000)
	{
		delay(2);
		return GCodeResult::notFinished;
	}

	inf.mounting = false;
	if (err != SD_MMC_OK)
	{
		reply.printf("Cannot initialise SD card %u: %s", card, TranslateCardError(err));
		return GCodeResult::error;
	}

	// Mount the file systems
	const char path[3] = { (char)('0' + card), ':', 0 };
	const FRESULT mounted = f_mount(&inf.fileSystem, path, 1);
	if (mounted != FR_OK)
	{
		reply.printf("Cannot mount SD card %u: code %d", card, mounted);
		return GCodeResult::error;
	}

	inf.isMounted = true;
	if (reportSuccess)
	{
		float capacity = ((float)sd_mmc_get_capacity(card) * 1024) / 1000000;		// get capacity and convert from Kib to Mbytes
		const char* capUnits;
		if (capacity >= 1000.0)
		{
			capacity /= 1000;
			capUnits = "Gb";
		}
		else
		{
			capUnits = "Mb";
		}
		reply.printf("%s card mounted in slot %u, capacity %.2f%s", TranslateCardType(sd_mmc_get_type(card)), card, (double)capacity, capUnits);
	}

	return GCodeResult::ok;
}
示例#21
0
uint16_t WaspSensorGas::pulse(uint16_t sensor)
{
	uint16_t aux=0;
	
	switch( sensor )
	{
		case	SENS_SOCKET3B	:	digitalWrite(DIGITAL7, HIGH); 
  						delay(14);
						digitalWrite(DIGITAL7, LOW);
						delay(980);
						digitalWrite(DIGITAL1, HIGH);
						delay(3); 
						aux = analogRead(ANALOG7);
						delay(2);
						digitalWrite(DIGITAL1, LOW);
						break;
		case	SENS_SOCKET3C	:	digitalWrite(DIGITAL7, HIGH); 
  						delay(2);
						digitalWrite(DIGITAL1, HIGH);
						delay(4);
						aux = analogRead(ANALOG7);
						delay(1);
						digitalWrite(DIGITAL1, LOW);
						delay(7); 
						digitalWrite(DIGITAL7, LOW);
						delay(236);
						break;
		case	SENS_SOCKET4B	:	digitalWrite(DIGITAL5, HIGH); 
  						delay(14);
						digitalWrite(DIGITAL5, LOW);
						delay(980);
						digitalWrite(DIGITAL3, HIGH);
						delay(3); 
						aux = analogRead(ANALOG6);
						delay(2);
						digitalWrite(DIGITAL3, LOW);
						break;
		case	SENS_SOCKET4C	:	digitalWrite(DIGITAL5, HIGH); 
  						delay(2);
						digitalWrite(DIGITAL3, HIGH);
						delay(4);
						aux = analogRead(ANALOG6);
						delay(1);
						digitalWrite(DIGITAL3, LOW);
						delay(7); 
						digitalWrite(DIGITAL5, LOW);
						delay(236);
						break;
	}
	return aux;
}
示例#22
0
//	VBUS or counting frames
//	Any frame counting?
u8 USBConnected()
{
	u8 f = UDFNUML;
	delay(3);
	return f != UDFNUML;
}
示例#23
0
// Process buttons:
void procButton(KeypadEvent b) {
    b -= 48;
    switch (keypad.getState()) {
    case RELEASED: // drop right away
        return;
    case PRESSED: // momentary
        if(mode==2) { // Signal Switching 4
            ss4Signal(b);
            break;
        } else if(mode==3) {
            pulse(b); // pulse it
            return;
        }
        if(mode==4&&(b<10&&b>=0||b==-13||b==-6||(b>=49&&b<=52))) { // MF tone
            mf(b);
        }
        if(b<10&&b>=0||b==-13||b==-6) { // MF tone
            mf(b);
        } else if(b==52) { // D
            if (stored) playStored(); // don't copy function onto stack if not needed
            return;
        } else if(mode==1) { // international kp2/st2
            if(b>=49&&b<=51) {
                mf(b);
                return;
            }
        }
        else if(mode==0&&(b<=51&&b>=49)) { // A,B,C redbox
            redBox(b); // pass it to RedBox()
            return;
        }
        break;
    case HOLD: // HELD (special functions)
        if(b==50&&mode==3) { // HOLD B for MF2 in PD Mode
            (mf2)? mf2 = 0 : mf2 = 1; // turn off if on, or on if off
            freq[0].play(440,70);
            delay(140);
            freq[0].play(440,70);
            delay(140);
        }
        if(b<10&&b>=0||b==-13||b==-6) {
            dial(b);
        } else if(b==51) { // C takes care of recording now
            if(rec) { // we are done recording:
                digitalWrite(13, LOW); // turn off LED
                rec = 0;
                stored=1; // we have digits stored
                recNotify();
            } else { // we start recording
                digitalWrite(13, HIGH); // light up LED
                rec = 1;
                for(int i=0; i<=23; i++) { // reset array
                    store[i] = -1;
                }
                recNotify();
            } // END recording code
        } else if(b==49) { // ('A' HELD) switching any mode "on" changes to mode, all "off" is domestic
            if(mode==0) { // mf to international
                mode=1;
            } else if(mode==1) { // international to ss4 mode
                mode=2;
            } else if(mode==2) { // ss4 mode to pulse mode
                mode=3;
            } else if(mode==3) { // pulse mode to DTMF
                mode=4;
            } else if(mode==4) { // DTMF to domestic
                mode=0;
            }
            notifyMode();
            return;
        }
        break;
    }
    return;
}
示例#24
0
/**
* Method to send an HTTP Request. Allocate variables in your application code
* in the aResponse struct and set the headers and the options in the aRequest
* struct.
*/
void HttpClientMod::request(http_request_t &aRequest, http_response_t &aResponse, http_header_t headers[], const char* aHttpMethod)
{
    // If a proper response code isn't received it will be set to -1.
    aResponse.status = -1;

    // NOTE: The default port tertiary statement is unpredictable if the request structure is not initialised
    // http_request_t request = {0} or memset(&request, 0, sizeof(http_request_t)) should be used
    // to ensure all fields are zero
    bool connected = false;
    if(aRequest.hostname!=NULL) {
        connected = client.connect(aRequest.hostname.c_str(), (aRequest.port) ? aRequest.port : 80 );
    }   else {
        connected = client.connect(aRequest.ip, aRequest.port);
    }

    #ifdef LOGGING
    if (connected) {
        if(aRequest.hostname!=NULL) {
            Serial.print("HttpClient>\tConnecting to: ");
            Serial.print(aRequest.hostname);
        } else {
            Serial.print("HttpClient>\tConnecting to IP: ");
            Serial.print(aRequest.ip);
        }
        Serial.print(":");
        Serial.println(aRequest.port);
    } else {
        Serial.println("HttpClient>\tConnection failed.");
    }
    #endif

    if (!connected) {
        client.stop();
        // If TCP Client can't connect to host, exit here.
        return;
    }

    //
    // Send HTTP Headers
    //

    // Send initial headers (only HTTP 1.0 is supported for now).
    client.print(aHttpMethod);
    client.print(" ");
    client.print(aRequest.path);
    client.print(" HTTP/1.0\r\n");

    #ifdef LOGGING
    Serial.println("HttpClient>\tStart of HTTP Request.");
    Serial.print(aHttpMethod);
    Serial.print(" ");
    Serial.print(aRequest.path);
    Serial.print(" HTTP/1.0\r\n");
    #endif

    // Send General and Request Headers.
    sendHeader("Connection", "close"); // Not supporting keep-alive for now.
    if(aRequest.hostname!=NULL) {
        sendHeader("HOST", aRequest.hostname.c_str());
    }

    //Send Entity Headers
    // TODO: Check the standard, currently sending Content-Length : 0 for empty
    // POST requests, and no content-length for other types.
    if (aRequest.body != NULL) {
        sendHeader("Content-Length", (aRequest.body).length());
    } else if (strcmp(aHttpMethod, HTTP_METHOD_POST) == 0) { //Check to see if its a Post method.
        sendHeader("Content-Length", 0);
    }

    if (headers != NULL)
    {
        int i = 0;
        while (headers[i].header != NULL)
        {
            if (headers[i].value != NULL) {
                sendHeader(headers[i].header, headers[i].value);
            } else {
                sendHeader(headers[i].header);
            }
            i++;
        }
    }

    // Empty line to finish headers
    client.println();
    client.flush();

    //
    // Send HTTP Request Body
    //

    if (aRequest.body != NULL) {
        client.println(aRequest.body);

        #ifdef LOGGING
        Serial.println(aRequest.body);
        #endif
    }

    #ifdef LOGGING
    Serial.println("HttpClient>\tEnd of HTTP Request.");
    #endif

    // clear response buffer
    buffer->clear();


    //
    // Receive HTTP Response
    //
    // The first value of client.available() might not represent the
    // whole response, so after the first chunk of data is received instead
    // of terminating the connection there is a delay and another attempt
    // to read data.
    // The loop exits when the connection is closed, or if there is a
    // timeout or an error.

    unsigned long lastRead = millis();
    unsigned long firstRead = millis();
    bool error = false;
    bool timeout = false;
    char lastChar = 0;
    bool inHeaders = true;

    do {
        #ifdef LOGGING
        int bytes = client.available();
        if(bytes) {
            Serial.print("\r\nHttpClient>\tReceiving TCP transaction of ");
            Serial.print(bytes);
            Serial.println(" bytes.");
        }
        #endif

        while (client.available()) {
            char c = client.read();
            #ifdef LOGGING
            Serial.print(c);
            #endif
            lastRead = millis();

            if (c == -1) {
                error = true;

                #ifdef LOGGING
                Serial.println("HttpClient>\tError: No data available.");
                #endif

                break;
            }

            if (inHeaders) {
                if ((c == '\n') && (lastChar == '\n')) {
                    // End of headers.  Grab the status code and reset the buffer.
                    const char * const ptr = buffer->getBuffer();
                    if (ptr != NULL) {
                        aResponse.status = atoi(&ptr[9]);
                    }
                    
                    buffer->clear();
                    inHeaders = false;
                    #ifdef LOGGING
                    Serial.print("\r\nHttpClient>\tEnd of HTTP Headers (");
                    Serial.print(aResponse.status);
                    Serial.println(")");
                    #endif
                    continue;
                } else if (c != '\r') {
                    lastChar = c;
                }
            }

            if (!buffer->append(c)) {
                client.stop();
                error = true;

                #ifdef LOGGING
                Serial.println("\r\nHttpClient>\tError: Response body larger than buffer.");
                #endif
                break;
            }
        }

        #ifdef LOGGING
        if (bytes) {
            Serial.print("\r\nHttpClient>\tEnd of TCP transaction.");
        }
        #endif

        // Check that there hasn't been more than 5s since last read.
        timeout = millis() - lastRead > TIMEOUT;

        // Unless there has been an error or timeout wait 200ms to allow server
        // to respond or close connection.
        if (!error && !timeout) {
            delay(200);
        }
    } while (client.connected() && !timeout && !error);

    #ifdef LOGGING
    if (timeout) {
        Serial.println("\r\nHttpClient>\tError: Timeout while reading response.");
    }
    Serial.print("\r\nHttpClient>\tEnd of HTTP Response (");
    Serial.print(millis() - firstRead);
    Serial.println("ms).");
    #endif
    client.stop();

    #ifdef LOGGING
    Serial.print("HttpClient>\tStatus Code: ");
    Serial.println(aResponse.status);
    #endif

    if (inHeaders) {
        #ifdef LOGGING
        Serial.println("HttpClient>\tError: Can't find HTTP response body.");
        #endif

        return;
    }
    // Return the entire message body from bodyPos+4 till end.
    aResponse.body = buffer->getBuffer();
    buffer->clear();
}
示例#25
0
void Adafruit_PCD8544::begin(uint8_t contrast, uint8_t bias) {
  if (isHardwareSPI()) {
    // Setup hardware SPI.
    SPI.begin();
    SPI.setClockDivider(PCD8544_SPI_CLOCK_DIV);
    SPI.setDataMode(SPI_MODE0);
    SPI.setBitOrder(MSBFIRST);
  }
  else {
    // Setup software SPI.

    // Set software SPI specific pin outputs.
    pinMode(_din, OUTPUT);
    pinMode(_sclk, OUTPUT);

    // Set software SPI ports and masks.
    // clkport     = portOutputRegister(digitalPinToPort(_sclk));
    // clkpinmask  = digitalPinToBitMask(_sclk);
    // mosiport    = portOutputRegister(digitalPinToPort(_din));
    // mosipinmask = digitalPinToBitMask(_din);
  }

  // Set common pin outputs.
  pinMode(_dc, OUTPUT);
  if (_rst > 0)
      pinMode(_rst, OUTPUT);
  if (_cs > 0)
      pinMode(_cs, OUTPUT);

  // toggle RST low to reset
  if (_rst > 0) {
    digitalWrite(_rst, LOW);
    delay(500);
    digitalWrite(_rst, HIGH);
  }

  // get into the EXTENDED mode!
  command(PCD8544_FUNCTIONSET | PCD8544_EXTENDEDINSTRUCTION );

  // LCD bias select (4 is optimal?)
  command(PCD8544_SETBIAS | bias);

  // set VOP
  if (contrast > 0x7f)
    contrast = 0x7f;

  command( PCD8544_SETVOP | contrast); // Experimentally determined


  // normal mode
  command(PCD8544_FUNCTIONSET);

  // Set display to Normal
  command(PCD8544_DISPLAYCONTROL | PCD8544_DISPLAYNORMAL);

  // initial display line
  // set page address
  // set column address
  // write display data

  // set up a bounding box for screen updates

  updateBoundingBox(0, 0, LCDWIDTH-1, LCDHEIGHT-1);
  // Push out pcd8544_buffer to the Display (will show the AFI logo)
  display();
}
示例#26
0
/*-----------------------------------------------------------------------------

-----------------------------------------------------------------------------*/
void delay_milliseconds::operator ()()
{
	delay(saved_delay);
}
示例#27
0
boolean WiFlyDevice::findInResponse(const char *toMatch,
                                    unsigned int timeOut = 0) {
  /*

   */

  // TODO: Change 'sendCommand' to use 'findInResponse' and have timeouts,
  //       and then use 'sendCommand' in routines that call 'findInResponse'?

  // TODO: Don't reset timer after successful character read? Or have two
  //       types of timeout?

  int byteRead;

  unsigned int timeOutTarget; // in milliseconds


  DEBUG_LOG(1, "Entered findInResponse");
  DEBUG_LOG(2, "Want to match2:");
  DEBUG_LOG(2, toMatch);
  DEBUG_LOG(3, "Found:");

  for (unsigned int offset = 0; offset < strlen(toMatch); offset++) {

    // Reset after successful character read
    timeOutTarget = millis() + timeOut; // Doesn't handle timer wrapping

    while (!uart.available()) {
      // Wait, with optional time out.
      if (timeOut > 0) {
        if (millis() > timeOutTarget) {
          return false;
        }
      }
      delay(1); // This seems to improve reliability slightly
    }

    // We read this separately from the conditional statement so we can
    // log the character read when debugging.
    byteRead = uart.read();

    delay(1); // Removing logging may affect timing slightly

    DEBUG_LOG(7, "Offset:");
    DEBUG_LOG(7, offset);
    DEBUG_LOG(7, (char) byteRead);
    DEBUG_LOG(7, byteRead);
	
	/*
	//DEBUG_LOG(6,(char)byteRead);
	//DEBUG_LOG(6," <-> ");
	//DEBUG_LOG(6,toMatch[offset]);
	//DEBUG_LOG(6,toMatch[0]);
	if(byteRead==toMatch[offset]){
		DEBUG_LOG(6,"Match --> ");
		DEBUG_LOG(6,byteRead==toMatch[offset]);
	}
	*/
	Serial.print((char)byteRead);
	Serial.print(" <-> ");
	Serial.print(toMatch[offset]);
	if(byteRead==toMatch[offset]){
		Serial.print("Match --> ");
		Serial.print(byteRead==toMatch[offset]);
	}
	Serial.println();
	
	
    if (byteRead != toMatch[offset]) {
      offset = 0;
      // Ignore character read if it's not a match for the start of the string
      if (byteRead != toMatch[offset]) {
        offset = -1;
      }
      continue;
    }
  }

  return true;
}
示例#28
0
void setup(){
   pinMode(piezoTriggerPin, OUTPUT);
  //delay(10000);
  //setup the accelerometer and screen
  //Serial.begin(9600); 
  //Serial.print("IPA"); //to vdip logger
  //Serial.print(13, BYTE); //to vdip logger
  //delay(10000);
  //pinMode(sprayTriggerPin, OUTPUT);
  //digitalWrite(sprayTriggerPin, LOW);
  Serial.begin(9600);
  //put wait code to look and see if there is a
  //response from the VDIP1.  If there isn't try connecting again
  
  //read the root dir in the memstick to set the 
  //log file's name/number (its sequential)
  //Serial.print("DIR");
  //Serial.print(13, BYTE);
  //Serial.print(0xFE, BYTE);   //command flag
   //Serial.print(128, BYTE); 
  //while(Serial.available() > 0){
   //Serial.print(Serial.read()); 
  //}
  
  //Serial.print(0xFE, BYTE);   //command flag
   //Serial.print(128, BYTE); 
  //Serial.print("initialized");
  //read
  //int tfilenum = 0;
  /*if(Serial.available() > 0){
    //look for "LOG"
    int input = Serial.read();
    Serial.print(input);
    if (input == 76){  //L
      input = Serial.read();
       if (input == 79){ //O
       input = Serial.read();
        if (input == 71){ //G
          //get the numers after "LOG"
          input = Serial.read();
          tfilenum = input - 48;
          input = Serial.read();
          while (input > 48 && input < 58){
            input = Serial.read();
            tfilenum = tfilenum * 10 + input - 48;
          }
        } 
      }
    }
  }*/
  
  //logfilecount = tfilenum + 1;
 // Serial.print("OPW LOG555");
  //Serial.print(13, BYTE);
   Serial.print(0xFE, BYTE);   
   Serial.print(128, BYTE);  
   Serial.print("Welcome!"); //change this to the users greeting...also useful as a LCD communication test
   Serial.print(0xFE, BYTE);  
   Serial.print(192, BYTE); 
   Serial.print("    Ben"); //line two of the users splash screen
  /* for (int i=0; i<100; i++){
     play_piezo();
   } */
   delay(1000);  //how long to delay on the 
  //Serial.print("file write");
  //Serial.print("CFL LOG555");
  //Serial.print(13,BYTE);
  
  //this next line for debug only
  //delay(10000);
  Serial.print(0x7C, BYTE);  
  Serial.print(157, BYTE);   //light level to 150 out of 157
   //Serial.print(0xFE, BYTE);   
   //Serial.print(0x01, BYTE);
  //zero the accelerometer...but only for small tilts
  delay(1000);
  int tempreading = analogRead(yval);
  if ((tempreading < 800) && (tempreading > 200)){
    zerogy = tempreading;
  }
  else {
    zerogy = 512;
  }
  tempreading = analogRead(xval);
  if (true) { //((tempreading < 800) && (tempreading > 200)){
    zerogx = tempreading;
  }
  else {
    zerogx = 512;
  }
  //setup the buttons as inputs
  pinMode(buttonApin, INPUT);
  pinMode(buttonBpin, INPUT);
  Serial.print(0xFE, BYTE);  
  Serial.print(0x01, BYTE); //clear LCD
}
示例#29
0
void testallblock(void)
{
    Uint32 i;
	Uint32 temp;
    Uint32 *SDRAM_StartAdd;
	Uint32 *temp_add;
    Uint32 Length=96;
    SDRAM_StartAdd = (Uint32 *)0xc0000000;

  	for(i=0;i<Length;i++)
	{
		temp_add = SDRAM_StartAdd+i;
		*(temp_add) = 0;
	}

	for(i=0;i<Length;i++)
	{
		temp = *(SDRAM_StartAdd+i);
		if(temp != 0x00000000)
		{
			temp = *(SDRAM_StartAdd+i);
			printf("\nWhen writing 0x00000000, Address 0x%x is error!",i);
			SW_BREAKPOINT;
		}
	}
	printf("\nWriting 0x00000000 is ok.");

	for(i=0;i<Length;i++)
	{
		*(SDRAM_StartAdd+i) = 0xffff;

	}
	for(i=0;i<Length;i++)
	{
		if(*(SDRAM_StartAdd+i) != 0xffff)
		{
			printf("\nWhen writing 0xffff, Address 0x%x is error!",i);
			SW_BREAKPOINT;
		}
	}
	printf("\nWriting 0xffff is ok.");

	for(i=0;i<Length;i++)
	{
		*(SDRAM_StartAdd+i) = 0xAAAA;
	}
	for(i=0;i<Length;i++)
	{
		if(*(SDRAM_StartAdd+i) != 0xAAAA)
		{
			printf("\nWhen writing 0xAAAA, Address 0x%x is error!",i);
			SW_BREAKPOINT;
		}
	}
	printf("\nWriting 0xAAAA is ok.");

	for(i=0;i<Length;i++)
	{
		*(SDRAM_StartAdd+i) = 0x5555;
	}
	delay(10);
	for(i=0;i<Length;i++)
	{
		if(*(SDRAM_StartAdd+i) != 0x5555)
		{

			printf("\nWhen writing 0x5555, Address 0x%x is error!",i);
		}
	}
	printf("\nWriting 0x5555 is ok.");

	for(i=0;i<Length;i++)
	{

	//	*(SDRAM_StartAdd+i) = i;
		temp_add = SDRAM_StartAdd+i;
		*(temp_add) = i;
	}
	i=0;
	for(i=0;i<Length;i++)
	{
		if(*(SDRAM_StartAdd+i) != i)
		{
			printf("\nWhen writing sequence data, Address 0x%x is error!",i);
			SW_BREAKPOINT;
		}
	}

    printf("\nTesting is success.");
}
示例#30
0
void main()
{


	randomize();
	clrscr();
	int i;
	int xcoord;
	int ycoord;
	int xleft;
	int yup;
	int soundon;
	xcoord=1;
	ycoord=1;
	xleft=0;
	yup=0;
	int col;
	while(!kbhit())
	{
		if(xcoord>=55)
		{
			xleft=1;
			goto sstart;

		}
		if(xcoord<=1)
		{
			xleft=0;
			goto sstart;
		}
		if(ycoord>=25)
		{
			yup=1;
			goto sstart;
		}
		if(ycoord<=1)
		{
			yup=0;
			goto sstart;
		}
		goto paststart;

		sstart:
		sound(1000);
		soundon=1;
		col=(random(14))+1;
		textcolor(col);

		paststart:
		gotoxy(xcoord,ycoord);
		cout << "Chops is God";

		clrscr();


		if(xleft==0)
		{
			xcoord++;
		}
		if(xleft==1)
		{
			xcoord=xcoord-1;
		}
		if(yup==0)
		{
			ycoord++;
		}
		if(yup==1)
		{
			ycoord=ycoord-1;
		}

		//gotoxy(xcoord,ycoord);
		//cout << xcoord << endl << ycoord << endl;
		gotoxy(xcoord,ycoord);
		cout << "Chops made this in C++";
		delay(15);
		if(soundon==1)
		{
			nosound();
			soundon=0;
		}
		//delay(10);
	}

	clrscr();
	gotoxy(35,12);
	{
	//textcolor();

	cout << "Coded by Chops"<< endl;
	cout << "Mike Gaynor is my god"<<endl;
	cout << "Mike Gaynor is better than I can ever hope to be";
	sleep(3);
	}

}