Example #1
0
int main(void)
{
  // Configure cpu and mandatory peripherals
  systemInit();

  uint32_t currentSecond, lastSecond;
  currentSecond = lastSecond = 0;

  while (1)
  {
    // Toggle LED once per second ... rollover = 136 years :)
    currentSecond = systickGetSecondsActive();
    if (currentSecond != lastSecond)
    {
      lastSecond = currentSecond;
      if (gpioGetValue(CFG_LED_PORT, CFG_LED_PIN) == CFG_LED_OFF)
      {
        gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_ON); 
      }
      else
      {
        gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_OFF); 
      }
    }

    // Poll for CLI input if CFG_INTERFACE is enabled in projectconfig.h
    #ifdef CFG_INTERFACE 
      cmdPoll(); 
    #endif
  }

  return 0;
}
Example #2
0
void cmdInit()
{
  #if defined CFG_INTERFACE && defined CFG_INTERFACE_UART
    // Check if UART is already initialised
    uart_pcb_t *pcb = uartGetPCB();
    if (!pcb->initialised)
    {
      uartInit(CFG_UART_BAUDRATE);
    }
  #endif

  #if CFG_INTERFACE_ENABLEIRQ != 0
    // Set IRQ pin as output
    gpioSetDir(CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, gpioDirection_Output);
    gpioSetValue(CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, 1);
  #endif

  // init the msg ptr
  msg_ptr = msg;

  // Show the menu
  cmdMenu();

  // Set the IRQ pin low by default
  #if CFG_INTERFACE_ENABLEIRQ  != 0
    gpioSetValue(CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, 0);
  #endif
}
int main(void)
{
  // Configure cpu and mandatory peripherals
  systemInit();

  // Make sure that projectconfig.h is properly configured for this example
  #if !defined CFG_CHIBI
    #error "CFG_CHIBI must be enabled in projectconfig.h for this example"
  #endif
  #if CFG_CHIBI_PROMISCUOUS != 0
    #error "CFG_CHIBI_PROMISCUOUS must be set to 0 in projectconfig.h for this example"
  #endif

  #ifdef CFG_CHIBI
    uint32_t counter = 0;
    chb_pcb_t *pcb = chb_get_pcb();

    while(1)
    {
      // Enable LED
      gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_ON); 
      // Create and send the message
      char text[10];
      counter++;
      itoa(counter, text, 10);
      chb_write(0xFFFF, text, strlen(text) + 1);
      // Disable LED
      gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_OFF); 
      systickDelay(250);
    }
  #endif

  return 0;
}
void cmd_chibi_tx(uint8_t argc, char **argv)
{
  uint8_t i, len, *data_ptr, data[50];
  uint16_t addr;

  // Try to convert supplied address to an integer
  int32_t addr32;
  getNumber (argv[0], &addr32);
  
  // Check for invalid values (getNumber may complain about this as well)
  if (addr32 <= 0 || addr32 > 0xFFFF)
  {
    printf("Invalid Address: 1-65534 or 0x0001-0xFFFE required.%s", CFG_PRINTF_NEWLINE);
    return;
  }

  // Address seems to be OK
  addr = (uint16_t)addr32;

  // Get message contents
  data_ptr = data;
  for (i=0; i<argc-1; i++)
  {
    len = strlen(argv[i+1]);
    strcpy((char *)data_ptr, (char *)argv[i+1]);
    data_ptr += len;
    *data_ptr++ = ' ';
  }
  *data_ptr++ = '\0';

  // Send message
  gpioSetValue(CFG_LED_PORT, CFG_LED_PIN, CFG_LED_ON);
  chb_write(addr, data, data_ptr - data);
  gpioSetValue(CFG_LED_PORT, CFG_LED_PIN, CFG_LED_OFF);
}
Example #5
0
void tsReadZ(uint32_t* z1, uint32_t* z2)
{
  if (!_tsInitialised) tsInit();

  // Make sure that X+/Y- are set to GPIO
  TS_XP_FUNC_GPIO;
  TS_YM_FUNC_GPIO;

  // Set X- and Y+ to inputs (necessary?)
  gpioSetDir (TS_XM_PORT, TS_XM_PIN, 0);
  gpioSetDir (TS_YP_PORT, TS_YP_PIN, 0);

  // Set X+ and Y- to output
  gpioSetDir (TS_XP_PORT, TS_XP_PIN, 1);
  gpioSetDir (TS_YM_PORT, TS_YM_PIN, 1);

  // X+ goes low, Y- goes high
  gpioSetValue(TS_XP_PORT, TS_XP_PIN, 0);   // GND
  gpioSetValue(TS_YM_PORT, TS_YM_PIN, 1);   // 3.3V

  // Set X- and Y+ to ADC
  TS_XM_FUNC_ADC;  
  TS_YP_FUNC_ADC;  

  // Get ADC results
  *z1 = adcRead(TS_YP_ADC_CHANNEL);     // Z1 (Read Y+)
  *z2 = adcRead(TS_XM_ADC_CHANNEL);     // Z2 (Read X-)
}
Example #6
0
int main ()
{
	init ();

	gpioSetDir (3, 1, 1);
	gpioSetValue (3, 1, 1);

	int availBytes;
	char buf[32];
	uint8_t frame[64];
	for (int i = 0; i < 64; ++i) {
		frame[i] = i;
	} 
	while (1) {
		systickDelay (1);
		USB_WriteEP (CDC_DEP_IN, frame, 64);
		// CDC_WrOutBuf (text, &textLen);

		CDC_OutBufAvailChar (&availBytes);
		if (availBytes > 0) {
			int bytesToRead = availBytes > 32 ? 32 : availBytes;
			int bytesRead = CDC_RdOutBuf (buf, &bytesToRead);
			gpioSetValue (3, 1, 0);
		}
	}
}
void samsungvfdWrite(uint8_t value) 
{
  gpioSetValue(SAMSUNGVFD_STB_PORT, SAMSUNGVFD_STB_PIN, 0);
  samsungvfd_sendByte(SAMSUNGVFD_SPIDATA);
  samsungvfd_sendByte(value);
  gpioSetValue(SAMSUNGVFD_STB_PORT, SAMSUNGVFD_STB_PIN, 1);
}
Example #8
0
File: avrspi.c Project: x29a/r0ket
void avrspi_tx(uint8_t byteToSend) {
	uint8_t spiBuf = byteToSend;
	
	gpioSetValue(RB_LED0, 1);
	sspSend(0, (uint8_t *)&spiBuf, 1);
	gpioSetValue(RB_LED0, 0);
}
Example #9
0
void tsReadZ(uint32_t* z1, uint32_t* z2)
{
  if (!_tsInitialised) tsInit();

  // XP = ADC
  // XM = GPIO Output Low
  // YP = GPIO Output High
  // YM = GPIO Input

  TS_XM_FUNC_GPIO;
  TS_YP_FUNC_GPIO;
  TS_YM_FUNC_GPIO;

  gpioSetDir (TS_XM_PORT, TS_XM_PIN, 1);
  gpioSetDir (TS_YP_PORT, TS_YP_PIN, 1);
  gpioSetDir (TS_YM_PORT, TS_YM_PIN, 0);

  gpioSetValue(TS_XM_PORT, TS_XM_PIN, 0);   // GND
  gpioSetValue(TS_YP_PORT, TS_YP_PIN, 1);   // 3.3V

  TS_XP_FUNC_ADC;
  *z1 = adcRead(TS_XP_ADC_CHANNEL);

  // XP = GPIO Input
  // XM = GPIO Output Low
  // YP = GPIO Output High
  // YM = ADC

  TS_XP_FUNC_GPIO;
  gpioSetDir (TS_YM_PORT, TS_YM_PIN, 0);

  TS_YM_FUNC_ADC;
  *z2 = adcRead(TS_YM_ADC_CHANNEL);
}
Example #10
0
uint32_t tsReadY(void)
{
  if (!_tsInitialised) tsInit();

  // YP = GPIO Output High
  // YM = GPIO Output Low
  // XP = GPIO Input
  // XM = ADC

  TS_YP_FUNC_GPIO;
  TS_YM_FUNC_GPIO;
  TS_XP_FUNC_GPIO;

  gpioSetDir (TS_YP_PORT, TS_YP_PIN, 1);
  gpioSetDir (TS_YM_PORT, TS_YM_PIN, 1);
  gpioSetDir (TS_XP_PORT, TS_XP_PIN, 0);

  gpioSetValue(TS_YP_PORT, TS_YP_PIN, 1);   // 3.3V
  gpioSetValue(TS_YM_PORT, TS_YM_PIN, 0);   // GND

  TS_XM_FUNC_ADC;

  // Return the ADC results
  return adcRead(TS_XM_ADC_CHANNEL);
}
void samsungvfd_command(uint8_t value) 
{
  gpioSetValue(SAMSUNGVFD_STB_PORT, SAMSUNGVFD_STB_PIN, 0);
  samsungvfd_sendByte(SAMSUNGVFD_SPICOMMAND);
  samsungvfd_sendByte(value);
  gpioSetValue(SAMSUNGVFD_STB_PORT, SAMSUNGVFD_STB_PIN, 1);
}
Example #12
0
void cmdParse(char *cmd)
{
  size_t argc, i = 0;
  char *argv[30];

  argv[i] = strtok(cmd, " ");
  do
  {
      argv[++i] = strtok(NULL, " ");
  } while ((i < 30) && (argv[i] != NULL));
  
  argc = i;
  for (i=0; i < CMD_COUNT; i++)
  {
      if (!strcmp(argv[0], cmd_tbl[i].command))
      {
        if ((argc == 2) && !strcmp (argv [1], "?"))
        {
          // Display parameter help menu on 'command ?'
          printf ("%s%s%s", cmd_tbl[i].description, CFG_PRINTF_NEWLINE, CFG_PRINTF_NEWLINE);
          printf ("%s%s", cmd_tbl[i].parameters, CFG_PRINTF_NEWLINE);
        }
        else if ((argc - 1) < cmd_tbl[i].minArgs)
        {
          // Too few arguments supplied
          printf ("Too few arguments (%d expected)%s", cmd_tbl[i].minArgs, CFG_PRINTF_NEWLINE);
          printf ("%sType '%s ?' for more information%s%s", CFG_PRINTF_NEWLINE, cmd_tbl[i].command, CFG_PRINTF_NEWLINE, CFG_PRINTF_NEWLINE);
        }
        else if ((argc - 1) > cmd_tbl[i].maxArgs)
        {
          // Too many arguments supplied
          printf ("Too many arguments (%d maximum)%s", cmd_tbl[i].maxArgs, CFG_PRINTF_NEWLINE);
          printf ("%sType '%s ?' for more information%s%s", CFG_PRINTF_NEWLINE, cmd_tbl[i].command, CFG_PRINTF_NEWLINE, CFG_PRINTF_NEWLINE);
        }
        else
        {
          #if CFG_INTERFACE_ENABLEIRQ != 0
          // Set the IRQ pin high at start of a command
          gpioSetValue(CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, 1);
          #endif
          // Dispatch command to the appropriate function
          cmd_tbl[i].func(argc - 1, &argv [1]);
          #if CFG_INTERFACE_ENABLEIRQ  != 0
          // Set the IRQ pin low to signal the end of a command
          gpioSetValue(CFG_INTERFACE_IRQPORT, CFG_INTERFACE_IRQPIN, 0);
          #endif
        }

        // Refresh the command prompt
        cmdMenu();
        return;
      }
  }
  printf("Command not recognized: '%s'%s%s", cmd, CFG_PRINTF_NEWLINE, CFG_PRINTF_NEWLINE);
  #if CFG_INTERFACE_SILENTMODE == 0
  printf("Type '?' for a list of all available commands%s", CFG_PRINTF_NEWLINE);
  #endif

  cmdMenu();
}
Example #13
0
void chb_drvr_init()
{
    // ToDo: Make sure gpioInit has been called
    // ToDo: Make sure CT32B0 has been initialised and enabled

    // config SPI for at86rf230 access
    chb_spi_init();

    // Setup 16-bit timer 0 (used for us delays)
    timer16Init(0, 0xFFFF);
    timer16Enable(0);

    // Set sleep and reset as output
    gpioSetDir(CHB_SLPTRPORT, CHB_SLPTRPIN, 1);
    gpioSetDir(CHB_RSTPORT, CHB_RSTPIN, 1);

    // configure IOs
    gpioSetValue(CHB_SLPTRPORT, CHB_SLPTRPIN, 1);  // Set sleep high
    gpioSetValue(CHB_RSTPORT, CHB_RSTPIN, 1);      // Set reset high

    // Set internal resistors
    gpioSetPullup (&CHB_SLPTRPIN_IOCONREG, gpioPullupMode_Inactive);
    gpioSetPullup (&CHB_RSTPIN_IOCONREG, gpioPullupMode_Inactive);

    // config radio
    chb_radio_init();
}
Example #14
0
// let the robot stop
// usage: go_stop()
int go_stop(void)
{
  gpioSetValue(OUT1, off);
  gpioSetValue(OUT2, off);
  gpioSetValue(OUT3, off);
  gpioSetValue(OUT4, off);
  return 0;
}
Example #15
0
/** reaction.c
 *  First l0dable for my r0ket
 *  Improvement is welcome
 *
 * AUTHOR: hubba
*/
void ram(void)
{
    char x = gpioGetValue(RB_LED1);
    int rand_wait = 0;
    int react_time=0;
    int start_time = 0;
    int end_time = 0;

    gpioSetValue (RB_LED1,0);           //upperleft LED off
    lcdClear();
    lcdPrintln("Hello");
    lcdPrintln(GLOBAL(nickname));
    lcdPrintln("ReACTION");
    lcdRefresh();
    delayms(500);
    while(1)
    {
        react_time = 0;
        lcdPrintln("Press ENTER if ");
        lcdPrintln("LED is on!");
        lcdRefresh();
        rand_wait = getRandom();
        rand_wait = rand_wait%50;
        rand_wait = 40 + rand_wait*4;        // Minimum pause time is 400ms
        for(int i =0; i<=rand_wait; i++)     //directly calling delayms(rand_wait) didn't work
        {
            delayms(10);
        }
        gpioSetValue (RB_LED1, 1);          //upperleft LED ON
        getInputWaitRelease();
        start_time = getTimer()*(SYSTICKSPEED);
        while (getInputWait() != BTN_ENTER);    //wait for user input
        {

        }
        end_time =  getTimer()*(SYSTICKSPEED);
        react_time = end_time - start_time;     //measure  used time
        lcdClear();
        lcdPrint("Needed ");
        lcdPrintInt(react_time);
        lcdPrintln(" ms");
        lcdPrintln("DOWN: Exit");
        lcdPrintln("0ther: New game");
        lcdRefresh();
        gpioSetValue (RB_LED1,0);           //upperleft LED off

        getInputWaitRelease();
        if(getInputWait() ==  BTN_DOWN)     //Check for Exit/new game
        {
            gpioSetValue (RB_LED1, x);      //upperleft LED as before l0dable executed
            return;
        }
    }
    /* NEVER LAND HERE */
    lcdPrintln("Flow-Error");
    lcdRefresh();
    return;
};
Example #16
0
File: avrspi.c Project: x29a/r0ket
uint8_t avrspi_rx(void) {
	uint8_t spiBuf;

	gpioSetValue(RB_LED2, 1);
	sspReceive(0, (uint8_t *)&spiBuf, 1);
	gpioSetValue(RB_LED2, 0);

	return spiBuf;
}
Example #17
0
void ram(void){
    char x = gpioGetValue(RB_LED1);

	for (int x=0;x<20;x++){
		gpioSetValue (RB_LED1, x%2); 
		delayms(50);
	};
    gpioSetValue (RB_LED1, x); 
}
Example #18
0
uint32_t tsReadY(void)
{
  if (!_tsInitialised) tsInit();

  lcdOrientation_t orientation;
  orientation = lcdGetOrientation();

  if (orientation == LCD_ORIENTATION_LANDSCAPE)
  {
    // Make sure Y+/Y- are set to GPIO
    TS_YP_FUNC_GPIO;
    TS_YM_FUNC_GPIO;
  
    // Set X- and X+ to inputs
    gpioSetDir (TS_XM_PORT, TS_XM_PIN, 0);
    gpioSetDir (TS_XP_PORT, TS_XP_PIN, 0);
    
    // Set Y- and Y+ to output
    gpioSetDir (TS_YM_PORT, TS_YM_PIN, 1);
    gpioSetDir (TS_YP_PORT, TS_YP_PIN, 1);
  
    // Y+ goes high, Y- goes low
    gpioSetValue(TS_YP_PORT, TS_YP_PIN, 1);   // 3.3V
    gpioSetValue(TS_YM_PORT, TS_YM_PIN, 0);   // GND
  
    // Set pin 1.0 (X+) to ADC1
    TS_XP_FUNC_ADC;  
  
    // Return the ADC results
    return adcRead(TS_XP_ADC_CHANNEL);
  }
  else
  {
    // Make sure X+/X- are set to GPIO
    TS_XP_FUNC_GPIO;
    TS_XM_FUNC_GPIO;
  
    // Set Y- and Y+ to inputs
    gpioSetDir (TS_YM_PORT, TS_YM_PIN, 0);
    gpioSetDir (TS_YP_PORT, TS_YP_PIN, 0);
    
    // Set X- and X+ to output
    gpioSetDir (TS_XM_PORT, TS_XM_PIN, 1);
    gpioSetDir (TS_XP_PORT, TS_XP_PIN, 1);
  
    // X+ goes high, X- goes low
    gpioSetValue(TS_XP_PORT, TS_XP_PIN, 1);   // 3.3V
    gpioSetValue(TS_XM_PORT, TS_XM_PIN, 0);   // GND
  
    // Set pin 0.11 (Y+) to ADC0
    TS_YP_FUNC_ADC;
  
    // Return the ADC results
    return adcRead(TS_YP_ADC_CHANNEL);
  }
}
void samsungvfdWriteString(const char * str)
{
  while(*str)
  {
    gpioSetValue(SAMSUNGVFD_STB_PORT, SAMSUNGVFD_STB_PIN, 0);
    samsungvfd_sendByte(SAMSUNGVFD_SPIDATA);
    samsungvfd_sendByte(*str++);
    gpioSetValue(SAMSUNGVFD_STB_PORT, SAMSUNGVFD_STB_PIN, 1);
  }
}
Example #20
0
static portTASK_FUNCTION(leduj2, pvParameters)
{
  while(1)
  {
    vTaskDelay(600/portTICK_RATE_MS);
    gpioSetValue(2, 2, 1);
    vTaskDelay(600/portTICK_RATE_MS);
    gpioSetValue(2, 2, 0);
  }
}
Example #21
0
File: main.c Project: DragonWar/RSL
int main(void)
{
  // Configure cpu and mandatory peripherals
  systemInit();

  // Check if projectconfig.h is properly configured for this example
  #if !defined CFG_CHIBI
    #error "CFG_CHIBI must be enabled in projectconfig.h for this example"
  #endif
  #if CFG_CHIBI_PROMISCUOUS == 0
    #error "CFG_CHIBI_PROMISCUOUS must set to 1 in projectconfig.h for this example"
  #endif
  #if !defined CFG_PRINTF_UART
    #error "CFG_PRINTF_UART must be enabled in projectconfig.h for this example"
  #endif
  #if defined CFG_INTERFACE
    #error "CFG_INTERFACE must be disabled in projectconfig.h for this example"
  #endif

  #if defined CFG_CHIBI && CFG_CHIBI_PROMISCUOUS != 0
    // Get a reference to the Chibi peripheral control block
    chb_pcb_t *pcb = chb_get_pcb();
    
    // Wait for incoming frames and transmit the raw data over uart
    while(1)
    {
      // Check for incoming messages 
      while (pcb->data_rcv) 
      { 
        // get the length of the data
        rx_data.len = chb_read(&rx_data);
        // make sure the length is nonzero
        if (rx_data.len)
        {
          // Enable LED to indicate message reception 
          gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_ON); 

          // Send raw data to UART for processing on
          // the PC (requires WSBridge - www.freaklabs.org)
          uint8_t i;
          for (i=0; i<rx_data.len; i++)
          {
            // Send output to UART
            uartSendByte(rx_data.data[i]);
          }

          // Disable LED
          gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_OFF); 
        }
      }
    }
  #endif

  return 0;
}
Example #22
0
void chb_set_hgm(U8 enb)
{
    if (enb)
    {
        gpioSetValue(CHB_CC1190_HGM_PORT, CHB_CC1190_HGM_PIN, 1);
    }
    else
    {
        gpioSetValue(CHB_CC1190_HGM_PORT, CHB_CC1190_HGM_PIN, 0);
    }
}
Example #23
0
int main(void)
{
  #ifndef CFG_PWM
    #ERROR "CFG_PWM must be enabled in projectconfig.h for this example."
  #endif

  // Configure cpu and mandatory peripherals
  // PWM is initialised in systemInit and defaults to using P1.9
  systemInit();

  // Set duty cycle to 50% for square wave output
  pwmSetDutyCycle(50);

  // Frequency can be set anywhere from 2khz and 10khz (4khz is loudest)
  // Note: Since this is a 16-bit timer, make sure the delay is not
  //       greater than 0xFFFF (65535), though anything 2khz and higher
  //       is within an acceptable range
  // The piezo buzzer used for this example is the PS1240, available at
  // http://www.adafruit.com/index.php?main_page=product_info&cPath=35&products_id=160
  pwmSetFrequencyInTicks(CFG_CPU_CCLK / 2000);

  uint32_t currentSecond, lastSecond;
  currentSecond = lastSecond = 0;

  while (1)
  {
    // Beep the piezo buzzer very briefly once per second, toggling the LED at the same time
    currentSecond = systickGetSecondsActive();
    // Make sure that at least one second has passed
    if (currentSecond != lastSecond)
    {
      // Update the second tracker
      lastSecond = currentSecond;
      // Set the LED state and buzzer loudness depending on the current LED state
      if (gpioGetValue(CFG_LED_PORT, CFG_LED_PIN) == CFG_LED_OFF)
      {
        pwmSetFrequencyInTicks(CFG_CPU_CCLK / 4000);            // 4khz (louder)
        pwmStartFixed(200);                                     // 2x as long as @ 2khz since it's 2x faster
        gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_ON);   // Turn the LED on
      }
      else
      {
        pwmSetFrequencyInTicks(CFG_CPU_CCLK / 2000);            // 2khz (softer)
        pwmStartFixed(100);                                    
        gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, CFG_LED_OFF);  // Turn the LED off
      }
    }
  }

  return 0;
}
void samsungvfdInit(uint8_t brightness)
{
  // Set all pins to output
  gpioSetDir(SAMSUNGVFD_SIO_PORT, SAMSUNGVFD_SIO_PIN, gpioDirection_Output);
  gpioSetDir(SAMSUNGVFD_STB_PORT, SAMSUNGVFD_STB_PIN, gpioDirection_Output);
  gpioSetDir(SAMSUNGVFD_SCK_PORT, SAMSUNGVFD_SCK_PIN, gpioDirection_Output);

  // Set strobe and clock pins high by default
  gpioSetValue(SAMSUNGVFD_STB_PORT, SAMSUNGVFD_STB_PIN, 1);
  gpioSetValue(SAMSUNGVFD_SCK_PORT, SAMSUNGVFD_SCK_PIN, 1);

  // Default to 2x20 display (SAMSUNG 20T202DA2JA)
  samsungvfd_begin(20, 2, brightness);
}
Example #25
0
void PIOINT0_IRQHandler(void)
{
  uint32_t regVal;

#ifdef CFG_BRD_LPC1343_ARMBY
  regVal = gpioIntStatus(CFG_PB_PORT, CFG_PB_PIN);
  if (regVal)
  {
	    gpioIntClear(CFG_PB_PORT, CFG_PB_PIN);
	    gpioSetValue(CFG_PB_PORT,CFG_PB_PIN,0); // turn off
	    gpioSetValue(CFG_REGEN_PORT,CFG_REGEN_PIN,0); // turn off

  }		
#endif
  return;
}
Example #26
0
int
main(void)
{
  // Configure cpu and mandatory peripherals
  systemInit();

  uint32_t currentSecond, lastSecond;
  currentSecond = lastSecond = 0;
  
  // uartInit(115200);
  prt();

  while (1)
  {
    // Toggle LED once per second
    currentSecond = systickGetSecondsActive();
    if (currentSecond != lastSecond)
    {
      lastSecond = currentSecond;
      gpioSetValue(CFG_LED_PORT, CFG_LED_PIN, !(gpioGetValue(CFG_LED_PORT, CFG_LED_PIN)));
      uartSendByte('*');
    }

    // Poll for CLI input if CFG_INTERFACE is enabled in projectconfig.h
    #ifdef CFG_INTERFACE 
      cmdPoll(); 
    #endif
  }

  return 0;
}
// Grabs line sensor data using i2c and dumps into LineSensor array. 
// Returns 1 if successful, 0 if encountered a timeout error 
//	(timeout probably means the line sensor isn't connected correctly)
int readLineSensor(int LineSensor[8]) {
	int i;
	char cmd;

	gpioSetValue(2, 10, 1);
	for(i=0; i<8; i++) //clear i2c buffers
	{
		I2CMasterBuffer[i] = 0;
		I2CSlaveBuffer[i] = 0;
	}

	cmd = 0x84; //1 CH# 01 XX for request conversion. e.g 1 000 01 00 is for channel 2

	for(i=0; i<8; i++)
	{
		////printf("Reading channel %d\n\r", i);
		I2CWriteLength = 2;
		I2CReadLength = 1;
		I2CMasterBuffer[0] = ADS7830_ADDR;
		I2CMasterBuffer[1] = cmd; 
		cmd += 0x10; //increment channel
		I2CMasterBuffer[2] = ADS7830_ADDR | READ_BIT; //not included in writelength b/c its a repeated start
		int timeout = i2cEngine(); //run the transaction and waits for value to be read back
		if (timeout > MAX_TIMEOUT) {
			//printf("ERROR: timeout (device not connected correctly)\n\r");
			return 0;
		}
		LineSensor[i] = I2CSlaveBuffer[0]; //> 100 ? 999 : 0; //sadly after each transaction the RdIndex is returned to 0, could change i2c driver...
	} 

	return 1;
}
Example #28
0
File: high.c Project: astro/lun1k
void ram() {
  char *nick = "Pentagon V1LLAG3";
  char nickbuf[32];  // 16?

  do {
    lcdFill(0);
    DoString(0, 0, "Getting");
    lcdDisplay();
    uint32_t score = highscore_get(nickbuf);

    gpioSetValue (RB_LED2, 1);
    lcdFill(0);
    DoString(0, 0, "Highscore:");
    DoString(0, 16, nickbuf);
    DoInt(0, 32, score);
    lcdDisplay();

    if (strcmp(nick, nickbuf) != 0) {
      lcdFill(0);
      DoString(0, 48, "Setting");
      lcdDisplay();
      delayms_queue(500);
      highscore_set(score+1, nick);
    }

  } while(getInputWaitTimeout(500) != BTN_UP);

}
Example #29
0
void usbHIDSetOutReport (uint8_t dst[], uint32_t length)
{
  uint8_t PCOutReportData = dst[0];
  // Check bit 0 in the incoming report to determine is LED should
  // be enabled or disabled (1 = enabled, 0 = disabled)
  if (PCOutReportData & (1<<0))
  {
    // Enable LED (set low)
    gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, 0);
  }
  else
  {
    // Disable LED (set high)
    gpioSetValue (CFG_LED_PORT, CFG_LED_PIN, 1);
  }
}
Example #30
0
void VoltageCheck(void){

    chrg=gpioGetValue(RB_PWR_CHRG);

	results = adcRead(1);
	results *= 10560;
	results /= 1024;

	if( results < 3500 ){
        nrf_off();
	    gpioSetValue (RB_PWR_GOOD, 0); 
	    gpioSetValue (RB_LCD_BL, 0); 
	    SCB_SCR |= SCB_SCR_SLEEPDEEP;
	    PMU_PMUCTRL = PMU_PMUCTRL_DPDEN_DEEPPOWERDOWN;
	    __asm volatile ("WFI");
    };