예제 #1
0
void error (const PropWare::ErrorCode err) {
    // Set the Quickstart LEDs for output (used to display the error code)
    PropWare::SimplePort debugLEDs(PropWare::Port::P16, 8, PropWare::Pin::OUT);

    while (1) {
        debugLEDs.write((uint32_t) err);
        waitcnt(CLKFREQ / 5 + CNT);
        debugLEDs.write(0);
        waitcnt(CLKFREQ / 5 + CNT);
    }
}
int getQTIs(int highPin, int lowPin)           // Function - getQTIs
{
  int dt = (CLKFREQ / 1000000) * 230;          // Set up 230 us time increment
  set_outputs(highPin, lowPin, 0b1111);        // highPin...lowPin set high
  set_directions(highPin, lowPin, 0b1111);     // highPin...lowPin set to output
  waitcnt(dt + CNT);                           // Wait 230 us
  set_directions(highPin, lowPin, 0b0000);     // highPin...lowPin st to input
  waitcnt(dt + CNT);                           // Wait 230 us
  int qtis = get_states(highPin, lowPin);      // Get 4-bit pattern QTIs apply
  return qtis;                                 // Return val containing pattern
}
void error (const PropWare::ErrorCode err) {
    PropWare::SimplePort debugLEDs(PropWare::Port::P16, 8, PropWare::Pin::OUT);

    pwSyncOut.printf("Unknown error: %u\n", err);

    while (1) {
        debugLEDs.write((uint32_t) err);
        waitcnt(100 * MILLISECOND);
        debugLEDs.write(0);
        waitcnt(100 * MILLISECOND);
    }
}
int main()                                    // Main function
{
  All_LED( 0 );
  InitSerial();

  Sensors_Start( PIN_SDI, PIN_SDO, PIN_SCL, PIN_CS_AG, PIN_CS_M, PIN_CS_ALT, PIN_LED, (int)&LEDValue[0], LED_COUNT );

  loopTimer = CNT;
  int filter = 256;

  while(1)
  {
    //Read ALL inputs from the sensors into local memory, starting at Temperature
    memcpy( &sens, Sensors_Address(), Sensors_ParamsSize );


    S4_Put( 0, '$' );   // Send a $ as a signature (like a packet start)

    LogInt( sens.GyroY );    // Sends an integer, followed by a space
    LogInt( sens.AccelX );   // Sends an integer, followed by a space
    LogInt( sens.AccelZ );   // Sends an integer, followed by a space

    S4_Put( 0, 13 );    // Send a carriage return


    ++counter;
    loopTimer += 80000000 / 100;

    waitcnt( loopTimer );
  }
}
예제 #5
0
/**
 * @example     L3G_Demo.cpp
 *
 * Read the gyrometer data and print it to the terminal
 *
 * @include PropWare_L3G/CMakeLists.txt
 */
int main () {
    int16_t       gyroValues[3];
    PropWare::SPI *spi = PropWare::SPI::get_instance();
    PropWare::L3G gyro(spi, CS);

    gyro.start();
    gyro.set_dps(PropWare::L3G::DPS_500);

    // Though this functional call is not necessary (default value is 0), I
    // want to bring attention to this function. It will determine whether the
    // l3g_read* functions will always explicitly set the SPI modes before
    // each call, or assume that the SPI driver is still running in the proper
    // configuration
    gyro.always_set_spi_mode(1);

    while (1) {
        gyro.read_all(gyroValues);
        //pwOut << "Gyro vals DPS... X: " << gyro.convert_to_dps(gyroValues[PropWare::L3G::X])
        //        << "\tY: " << gyro.convert_to_dps(gyroValues[PropWare::L3G::Y])
        //        << "\tZ: " << gyro.convert_to_dps(gyroValues[PropWare::L3G::Z]) << '\n';

        pwOut << "Gyro vals DPS... X: " << gyroValues[PropWare::L3G::X]
                << "\tY: " << gyroValues[PropWare::L3G::Y]
                << "\tZ: " << gyroValues[PropWare::L3G::Z] << '\n';

        waitcnt(50*MILLISECOND + CNT);
    }

    return 0;
}
예제 #6
0
void ultrasonic_run()
{
  while(1)
  {
    high(PIN_RANGE_TRIG);
    waitcnt(CNT + CLKFREQ/100000); // 10 uS
    low(PIN_RANGE_TRIG);

    int duration = pulse_in(PIN_RANGE_ECHO, 1)/58;

    if (duration > 400)
      duration = 400;
    range = duration;
    waitcnt(CNT + CLKFREQ/17);
  }
}
예제 #7
0
__attribute__((constructor)) void init(void) {
	/* assert tx pin low for QuickStart */
	OUTA &= ~(1<<30);
	DIRA |=  (1<<30); 
	/* wait a second for terminal to start */
	//sleep(1);
	waitcnt(CLKFREQ+CNT);
}
예제 #8
0
파일: fds.c 프로젝트: dbetz/xbee-server
/**
 * drain waits for all bytes to be sent
 */
void
FdSerial_drain(FdSerial_t *data)
{
  while(data->tx_tail != data->tx_head)
    ;
  /* wait for transmission */
  waitcnt(_clkfreq + data->ticks);
}
예제 #9
0
파일: rtc.c 프로젝트: jnlocke/proplib
void
pause(int secs)
{
  while (secs > 0) {
    waitcnt(_CNT+_clkfreq);
    --secs;
  }
}
예제 #10
0
파일: imu.c 프로젝트: QuantumPhi/Quadcopter
void imu_run()
{
  while(1)
  {
    last = CNT;
    waitcnt(CNT + CLKFREQ/1000*IMU_UPDATE_DELAY);
    imu_update();
  }
}
예제 #11
0
terminal *simpleterm_open(void)
{
    if(dport_ptr != 0)
        return dport_ptr;

    dport_ptr = serial_open(31,30,0,115200);
    waitcnt(CLKFREQ+CNT);
    return dport_ptr;
}
예제 #12
0
// Function runs in another cog
void ms_timer(void *par)                      
{
  dt = CLKFREQ/1000;
  int ticks = CNT;
  while(1)                                   
  {
    waitcnt(ticks+=dt);                              
    t++;                                     
  }                            
}
void Listener::init () {
    this->m_listener.set_rx_mask(RX_PIN);
    this->m_listener.set_baud_rate(BAUD_RATE);
    this->m_listener.set_parity(PARITY);
    memset(m_buffer, 0, sizeof(m_buffer));

    // A very short wait to ensure the main cog has finished printing its "I'm ready" statement before we start
    // printing ours
    waitcnt(10 * MILLISECOND + CNT);
}
예제 #14
0
void pwm_run()
{
  servo_start();
  waitcnt(CNT + CLKFREQ/2);
  while(1)
  {
    for (int i=0;i<4;i++)
      servo_set(motors[i]->pin, motors[i]->current_val);
  }
}
예제 #15
0
int32_t screenSpin::Fadein(void)
{
  int32_t	Contrastnum;
  Contrastnum = 0;
  while (Contrastnum < 16) {
    Contrast(Contrastnum);
    Contrastnum = (Contrastnum + 1);
    waitcnt(((CLKFREQ / 8000) + CNT));
  }
  return 0;
}
예제 #16
0
int32_t screenSpin::Fadeout(void)
{
  int32_t	Contrastnum;
  Contrastnum = 15;
  while (Contrastnum > (-1)) {
    Contrast(Contrastnum);
    Contrastnum = (Contrastnum - 1);
    waitcnt(((CLKFREQ / 8000) + CNT));
  }
  return 0;
}
예제 #17
0
void wait(int time)                          // pause function definition
{
  // If dt not initialized, set it up to 1 us.
  /*
  if(!st_iodt)                                  // If dt not initialized
  { 
    set_io_dt(CLKFREQ/1000000);              // Set up timed I/O time increment
    set_io_timeout(CLKFREQ/4);               // Set up timeout
  }
  */
  time *= st_iodt;                              // Calculate system clock ticks
  waitcnt(st_mark += time);                   // Wait for system clock target
}
예제 #18
0
int Sirc::getPulseWidth(){
   //Var we are using to count time.
   int count = 0;
   //Wait for incoming signal
   //Start waiting for the pin to get low.
   //This indicates the start of a transmission.
   while(true){
      //Check if the pin is low.
      if(input(pin) == 0){
        //Get out of the loop.
        break; 
      }
      //Increase the counter.
      //Each tick is 100 microseconds.        
      count++;
      //Check if the timeout is enabled.
      //Check if we need to time out already.
      if(timeout > 0 && count >= (timeout*10)){
        //Return the timeout value (-1).
        return TIMEOUT;  
      }
      //Wait for 100 microseconds.         
      waitcnt(CNT+100*us);  
   }  
   //Reset the counter.
   //We are going to use it to count the pulse width now.
   count = 0;
   //Run until the pin becomes high again.
   while(input(pin) == 0){
    //Increase the counter.
    //Each tick represents 100 us.
    count++;
    //Wait for 100 microseconds.  
    waitcnt(CNT+100*us);   
   }
   //Return the counted value.    
   return count; 
}  
/**
 * @example     DuplexUART_Demo.cpp
 *
 * Write "Hello world!" out via UART protocol and receive an echo
 *
 * @include PropWare_DuplexUART/CMakeLists.txt
 */
int main () {
    uint32_t              threadStack[256];
    Listener              listener(threadStack);
    PropWare::SimplexUART speaker(TX_PIN);

    // Start our new cog and initialize the speaking UART
    speaker.set_baud_rate(BAUD_RATE);
    speaker.set_parity(PARITY);
    pwSyncOut.printf("New cog ID: %d. Ready to send!!!\n", PropWare::Runnable::invoke(listener));

    while (1) {
        waitcnt(200 * MILLISECOND + CNT);
        speaker.puts(TEST_STRING);
    }
}
예제 #20
0
파일: toggle.c 프로젝트: neutered/propgcc
int main(int argc, char* argv[])
{
#if defined(__USE_XMM__)
    int mask = 0x00008000;  /* only toggle the C3 board LED */
#else
    int mask = 0x3fffffff;  /* toggle all pins except the serial */
#endif
    int freq;

    freq = CLKFREQ;

    DIRA = mask;
    OUTA = mask;
    for(;;) {
        OUTA ^= mask;
        waitcnt(freq+CNT);
    }    
}
예제 #21
0
파일: spi.c 프로젝트: Blindstar/PropWare
void SPIShiftIn_fast (const uint8_t bits, void *data, const uint8_t bytes) {
    uint8_t *par8;
    uint16_t *par16;
    uint32_t *par32;

    // Wait until idle state, then send function and mode bits
    SPIWait();
    g_mailbox = SPI_FUNC_READ_FAST | (bits << SPI_BITS_OFFSET);

    // Wait for a value to be written
    while ((uint32_t) -1 == g_mailbox)
        waitcnt(SPI_TIMEOUT_WIGGLE_ROOM + CNT);

    // Determine if output variable is char, short or long and write data to that location
    switch (bytes) {
        case 1:
            par8 = data;
            *par8 = g_mailbox;
            break;
        case 2:
            par16 = data;
            *par16 = g_mailbox;
            break;
        case 4:
            par32 = data;
            *par32 = g_mailbox;
            break;
        default:
#ifdef SPI_DEBUG
            SPIError(SPI_INVALID_BYTE_SIZE);
#else
            return;
#endif
            break;
    }

    // Signal that value is saved and GAS cog can continue execution
    g_mailbox = -1;
}
예제 #22
0
파일: pwm.c 프로젝트: Redacacia/BlocklyProp
void pw(void *par)
{
  FRQA = 1;
  FRQB = 1;
  int pin;
  unsigned int dt = tCycle;
  unsigned int t = CNT;
  while(1)
  {
    waitcnt(t+=dt);
    if(ctra != CTRA)
    {
      if(ctra != 0)
      {
        pin = CTRA & 0b111111;
        DIRA &= ~(1 << pin);
      }
      CTRA = ctra;
      pin = CTRA & 0b111111;      
      DIRA |= (1 << pin);
    }
    if(ctrb != CTRB)
    {
      if(ctrb != 0)
      {
        pin = CTRB & 0b111111;
        DIRB &= ~(1 << pin);
      }
      CTRB = ctrb;
      pin = CTRB & 0b111111;      
      DIRA |= (1 << pin);
    }
    PHSA = -ticksA;    
    PHSB = -ticksB;    
  }
}
예제 #23
0
// Main function
void main (void) {
	uint8_t err;
	char c;

	sd_file f, f2;

#ifndef LOW_RAM_MODE
	/* Option 1: Create at least one new sd_buffer variable
	 *
	 * An extra 526 bytes of memory are required to create a new sd_buffer
	 * for the file variable, but speed will be increased if files are
	 * being switched often. Using this option will allow the directory
	 * contents to be kept in RAM while a file is loaded.
	 *
	 */
	sd_buffer fileBuf;	// If extra RAM is available
	sd_buffer fileBuf2;
	f.buf = &fileBuf;
	f2.buf = &fileBuf2;
#else
	/* Option 2: Use the generic buffer [i.e. g_sd_buf] as the buffer
	 *
	 * Good for low-RAM situations due to the re-use of g_sd_buf. Speed is
	 * decreased when multiple files are used often.
	 *
	 */
	f.buf = &g_sd_buf;
	f2.buf = &g_sd_buf;
#endif

#ifdef DEBUG
	printf("Beginning SD card initialization...\n");
#endif

	// Start your engines!!!
	if ((err = SDStart(MOSI, MISO, SCLK, CS, -1)))
		error(err);

#ifdef DEBUG
	printf("SD routine started. Mounting now...\n");
#endif
	if ((err = SDMount()))
		error(err);
#ifdef DEBUG
	printf("FAT partition mounted!\n");
#endif

#ifdef TEST_SHELL
	SD_Shell(&f);
#elif (defined TEST_WRITE)
	// Create a blank file and copy the contents of STUFF.TXT into it
	SDfopen(OLD_FILE, &f, SD_FILE_MODE_R);
	SDfopen(NEW_FILE, &f2, SD_FILE_MODE_R_PLUS);

#ifdef DEBUG
	printf("Both files opened...\n");
#endif

	while (!SDfeof(&f)) {
		c = SDfgetc(&f);
		SDfputc(c, &f2);
#ifdef _STDIO_H
		putchar(SDfgetc(&f2));
#endif
	}

#ifdef DEBUG
	printf("\nFile printed...\n");

	printf("Now closing read-only file!\n");
#endif
	SDfclose(&f);
#ifdef DEBUG
	printf("***Now closing the modified file!***\n");
#endif
	SDfclose(&f2);

#ifdef DEBUG
	printf("Files closed...\n");

	SDfopen(NEW_FILE, &f2, SD_FILE_MODE_R);
	printf("File opened for a second time, now printing new contents...\n");
	while (!SDfeof(&f2))
		putchar(SDfgetc(&f2));
	SDfclose(&f2);
#endif

	SDUnmount();
#else
	SDchdir("JAZZ");
	SDfopen("DESKTOP.INI", &f, SD_FILE_MODE_R);

	while (!SDfeof(&f))
#ifdef DEBUG
		putchar(SDfgetc(&f));
#endif
#endif

#ifdef DEBUG
	printf("Execution complete!\n");
#endif

	GPIODirModeSet(BIT_16, GPIO_DIR_OUT);
	while (1) {
		GPIOPinToggle(BIT_16);
		waitcnt(CLKFREQ/2 + CNT);
	}
}
예제 #24
0
void test123::Pauseabit(void)
{
  waitcnt((40000000 + CNT));
}
예제 #25
0
void btest005::pausems(uint32_t ms)
{
  uint32_t 	tim;
  tim = ms * mscycles;
  waitcnt(tim + getcnt());
}
예제 #26
0
파일: main.c 프로젝트: mam1/XMMC-cogs-demo
/****************************** start main routine ******************************/
int main(void)
{
    char        input_buffer[INPUT_BUFFER]; //buffer for user input
    waitcnt(500000 + _CNT);                 //wait until initialization is complete
    printf("XMMC-cogc demo v%s",VERSION);   //display startup message  

/* start monitoring the real time clock DS3231 */
    int         cog;
    rtc_cb.rtc.tdb_lock = locknew();
    lockclr(rtc_cb.rtc.tdb_lock);
    cog = start_rtc(&rtc_cb.rtc);
    if(cog == -1)
    {
        printf("** error attempting to start rtc cog\n  cognew returned %i\n\n",cog);
        return 1;
    }     
    printf("  DS3231 monitored by code running on cog %i\n",cog);


/* set all cogs to not running */
    parA.A.cog = -1; 
    parB.B.cog = -1; 
    parC.C.cog = -1; 
/* loop forever */
    while(1) 
    {
        printf("\nenter command > ");                //prompt user
        fgets(input_buffer,INPUT_BUFFER,stdin);      //get a line of input
        input_buffer[strlen(input_buffer)-1] = '\0'; //get rid of trailing new line character
        switch(process(input_buffer))                //test input,take appropriate action
        {
            case 0:     //startA
                if(start_cogA(&parA.A)== -1)
                    printf("  problem starting cogA\n");
                else
                    printf("  cogA started\n");
                break;
            case 1:     //startB
                if(start_cogB(&parB.B)== -1)
                    printf("  problem starting cogB\n");
                else
                    printf("  cogB started\n");
                break;
            case 2:     //startC
                if(start_cogC(&parC.C)== -1)
                    printf("  problem starting cogC\n");
                else
                    printf("  cogC started\n");
                break;
            case 3:     //stopA
                cogstop(parA.A.cog);
                printf("  cog A stopped\n");
                parA.A.cog = -1;
                break;
            case 4:     //stopB
                cogstop(parB.B.cog);
                printf("  cog B stopped\n");
                parB.B.cog = -1;
                break;
            case 5:     //stopC
                cogstop(parC.C.cog);
                printf("  cog C stopped\n");
                parC.C.cog = -1;
                break;
            case 6:     //queryA
                if(parA.A.cog == -1)
                    printf("cog A is not running\n");              
                else
                    parA.A.query_flag = 1;
                break;
            case 7:     //queryB
                if(parB.B.cog == -1)
                    printf("cog B is not running\n");              
                else
                    parB.B.query_flag = 1;
                break;
            case 8:     //queryC
                if(parC.C.cog == -1)
                    printf("cog C is not running\n");              
                else
                    parC.C.query_flag = 1;
                break;
            case 9:     //status
                status();
                break;
            case 10:    //exit
                printf("exiting program\n");
                return 0;
            case 11:    //time
                printf("%s, %i:%02i:%02i  %i/%i/%i\n\n",
                    day_names_long[rtc_cb.rtc.dow-1],
                    rtc_cb.rtc.hour,
                    rtc_cb.rtc.min,
                    rtc_cb.rtc.sec,

                    rtc_cb.rtc.month,
                    rtc_cb.rtc.day,
                    rtc_cb.rtc.year+2000);
                break;
            default:
                printf("<%s> is not a valid command\n",input_buffer);

        }
    }
    return 0;
}
// Wait for command to be cleared, signifying receipt
int32_t screen_init(int32_t ChipSelect, int32_t DataCommand, int32_t TheData, int32_t TheClock, int32_t Reset, int32_t VCC_state, int32_t Type)
{
  // Startup the SPI system
  screen_start();
  // Initialize variables and initialize the display
  self->CS = ChipSelect;
  self->DC = DataCommand;
  self->DATA = TheData;
  self->CLK = TheClock;
  self->RST = Reset;
  self->vccstate = VCC_state;
  self->displayType = Type;
  if (self->displayType == TYPE_128X32) {
    self->displayWidth = SSD1306_LCDWIDTH;
    self->displayHeight = SSD1306_LCDHEIGHT32;
  } else {
    self->displayWidth = SSD1306_LCDWIDTH;
    self->displayHeight = SSD1306_LCDHEIGHT64;
  }
  // Setup reset and pin direction  
  screen_HIGH(self->RST);
  // VDD (3.3V) goes high at start; wait for a ms
  waitcnt(((CLKFREQ / 100000) + CNT));
  // force reset low
  screen_LOW(self->RST);
  // wait 10ms
  waitcnt(((CLKFREQ / 100000) + CNT));
  // remove reset
  screen_HIGH(self->RST);
  if (self->displayType == TYPE_128X32) {
    // ************************************
    // Init sequence for 128x32 OLED module
    // ************************************
    screen_ssd1306_Command(SSD1306_DISPLAYOFF);
    screen_ssd1306_Command(SSD1306_SETDISPLAYCLOCKDIV);
    screen_ssd1306_Command(128);
    screen_ssd1306_Command(SSD1306_SETMULTIPLEX);
    screen_ssd1306_Command(31);
    screen_ssd1306_Command(SSD1306_SETDISPLAYOFFSET);
    screen_ssd1306_Command(0);
    screen_ssd1306_Command((SSD1306_SETSTARTLINE | 0x0));
    screen_ssd1306_Command(SSD1306_CHARGEPUMP);
    if (self->vccstate == SSD1306_EXTERNALVCC) {
      screen_ssd1306_Command(16);
    } else {
      screen_ssd1306_Command(20);
    }
    screen_ssd1306_Command(SSD1306_MEMORYMODE);
    screen_ssd1306_Command(0);
    screen_ssd1306_Command((SSD1306_SEGREMAP | 0x1));
    screen_ssd1306_Command(SSD1306_COMSCANDEC);
    screen_ssd1306_Command(SSD1306_SETCOMPINS);
    screen_ssd1306_Command(2);
    screen_ssd1306_Command(SSD1306_SETCONTRAST);
    screen_ssd1306_Command(143);
    screen_ssd1306_Command(SSD1306_SETPRECHARGE);
    if (self->vccstate == SSD1306_EXTERNALVCC) {
      screen_ssd1306_Command(34);
    } else {
      // SSD1306_SWITCHCAPVCC 
      screen_ssd1306_Command(241);
    }
    screen_ssd1306_Command(SSD1306_SETVCOMDETECT);
    screen_ssd1306_Command(64);
    screen_ssd1306_Command(SSD1306_DISPLAYALLON_RESUME);
    screen_ssd1306_Command(SSD1306_NORMALDISPLAY);
    // --turn on oled panel
    screen_ssd1306_Command(SSD1306_DISPLAYON);
  } else {
    // ************************************   
    // Init sequence for 128x64 OLED module
    // ************************************
    screen_ssd1306_Command(SSD1306_DISPLAYOFF);
    // low col = 0
    screen_ssd1306_Command(SSD1306_SETLOWCOLUMN);
    // hi col = 0
    screen_ssd1306_Command(SSD1306_SETHIGHCOLUMN);
    // line #0
    screen_ssd1306_Command(SSD1306_SETSTARTLINE);
    screen_ssd1306_Command(SSD1306_SETCONTRAST);
    if (self->vccstate == SSD1306_EXTERNALVCC) {
      screen_ssd1306_Command(159);
    } else {
      screen_ssd1306_Command(207);
    }
    screen_ssd1306_Command(161);
    screen_ssd1306_Command(SSD1306_NORMALDISPLAY);
    screen_ssd1306_Command(SSD1306_DISPLAYALLON_RESUME);
    screen_ssd1306_Command(SSD1306_SETMULTIPLEX);
    screen_ssd1306_Command(63);
    screen_ssd1306_Command(SSD1306_SETDISPLAYOFFSET);
    // No offset                            
    screen_ssd1306_Command(0);
    screen_ssd1306_Command(SSD1306_SETDISPLAYCLOCKDIV);
    screen_ssd1306_Command(128);
    screen_ssd1306_Command(SSD1306_SETPRECHARGE);
    if (self->vccstate == SSD1306_EXTERNALVCC) {
      screen_ssd1306_Command(34);
    } else {
      screen_ssd1306_Command(241);
    }
    screen_ssd1306_Command(SSD1306_SETVCOMDETECT);
    screen_ssd1306_Command(64);
    screen_ssd1306_Command(SSD1306_SETCOMPINS);
    screen_ssd1306_Command(18);
    screen_ssd1306_Command(SSD1306_MEMORYMODE);
    screen_ssd1306_Command(0);
    screen_ssd1306_Command((SSD1306_SEGREMAP | 0x1));
    screen_ssd1306_Command(SSD1306_COMSCANDEC);
    screen_ssd1306_Command(SSD1306_CHARGEPUMP);
    if (self->vccstate == SSD1306_EXTERNALVCC) {
      screen_ssd1306_Command(16);
    } else {
      screen_ssd1306_Command(20);
    }
    // --turn on oled panel
    screen_ssd1306_Command(SSD1306_DISPLAYON);
  }
  self->crsrX = 0;
  self->crsrY = 0;
  self->charSize = LARGE;
  invert(0);
  //screen_AutoUpdateOff();              // commented 8/23 5:26 PM
  //clear();
  return 0;
}
예제 #28
0
void pause(int time)                          // pause function definition
{ // If st_pauseTicks not initialized, set it up to 1 ms.
  // if(!st_pauseTicks) set_pause_dt(CLKFREQ/1000);
  time *= st_pauseTicks;                         // Calculate system clock ticks
  waitcnt(time+CNT);                          // Wait for system clock target
}
예제 #29
0
void pause() {
    waitcnt(CLKFREQ+CNT);
}
예제 #30
0
void quad_time(int power, int time) {
  int tmp = CNT;
  quad_power(power);
  waitcnt(tmp + CLKFREQ*time);
}