Example #1
0
interrupt(PORT1_VECTOR) PORT1_ISR(void)
{
    P1IFG &= ~BIT0;                 // Clear interrupt flag
#else
void exti2_isr(void)
{
    exti_reset_request(EXTI2);		// Clear interrupt flag
#endif
	int s;

	// set ACK payload to next squence number
	ptx.data[0]++;
	s = nrf_write_ack_pl(&ptx, 0);

	if(s == NRF_ERR_TX_FULL) {
		cio_printf("Unable to send back ACK payload (TX_FULL)\n\r");
	}

	// receive non-blocking since IRQ already indicates that payload arived
	s = nrf_receive(&prx);

	if(s == NRF_ERR_RX_FULL) {
		cio_printf("Unable to receive any more (RX_FULL)\n\r");
	}
	else {
		cio_printf("Received payload: %c; sending back %u\n\r", prx.data[0], ptx.data[0]);
	}
}
Example #2
0
int shell_cmd_laser(shell_cmd_args *args) {
	//XOR current state of laser output pin
	//when low acts as ground to complete circuit
	//If 2.3 DIR is 0 then laser is on

	P2DIR ^= BIT3; //toggle

	if(~(P2DIR & BIT3)){
		cio_printf("Laser disabled.\n\r");
	} else{
		cio_printf("Laser enabled.\n\r");
	}
	__delay_cycles(50);
	return 0;
}
Example #3
0
int main(void)
{
	clock_init();
	serial_init(9600);
	nrf_init();

	cio_print("nRF2401 v0.1, TestClient\n\r");

	nrf_configure_esb_rx();
	nrf_dump_regs(&nrf_reg_def);

	static nrf_payload   p;

	int s;

	// set payload size according to the payload size configured for the RX channel
	p.size = 1;

	while (1) {
		s = nrf_receive_blocking(&p);

		cio_printf("Received payload: %x; bytes received: %u\n\r", p.data[0], s);
	}

	return 0;
}
Example #4
0
void dump_regs(const char *msg) 
{

	cio_printf("REGDUMP(%s): P1DIR=%x; P2DIR=%x; P1OUT=%x; P2OUT=%x; P1REN=%x; P2REN=%x; P1IN=%x, P2IN=%x\n\r",
				msg,
				P1DIR, P2DIR, P1OUT, P2OUT, P1REN, P2REN, P1IN, P2IN);
}
Example #5
0
/*******************************************
			SHELL CALLBACK HANDLERS
*******************************************/
int shell_cmd_help(shell_cmd_args *args) {
	int k;

	for(k = 0; k < my_shell_cmds.count; k++) {
		cio_printf("%s: %s\n\r", my_shell_cmds.cmds[k].cmd, my_shell_cmds.cmds[k].desc);
	}

	return 0;
}
Example #6
0
int shell_cmd_argt(shell_cmd_args *args)
{
  int k;

  cio_print((char *)"args given:\n\r");

  for(k = 0; k < args->count; k++) {
    cio_printf(" - %s\n\r", args->args[k].val);
  }

  return 0;
}
Example #7
0
void nrf_dump_regs(nrf_regs *r) {

	int i;
	int j;

	cio_print("\n\r** START nRF2401 Register DUMP **\n\r");

	nrf_reg_buf buf;

	for(i = 0; i < r->count; i++) {

		nrf_read_reg(i, &buf);

		if(r->data[i].size == 0) continue;

		cio_printf("%s: ", r->data[i].name);

		for(j = 0; j < buf.size; j++) {
			cio_printb(buf.data[j], 8);
			cio_printf(" (%u) ", buf.data[j]);
		}

		cio_print("\n\r - ");

		for(j = 0; j < r->data[i].fields->count; j++) {
			cio_printf("%u[%u]:%s=%u ", j,
				r->data[i].fields->data[j].size,
				r->data[i].fields->data[j].name,
				nrf_get_reg_field(i, j, &buf));
		}

		cio_print("-\n\r");
	}

	cio_print("** END nRF2401 Register DUMP **\n\r");
}
Example #8
0
int shell_cmd_ysweep(shell_cmd_args *args) {

        // Move forward toward the maximum position
        for (cntr = MIN_DUTYCYCLE; cntr < (MAX_DUTYCYCLE)/2; cntr++) {
            TA1CCR1 = cntr;
            __delay_cycles(2000);
        }   
        // Move backward toward the manimum step value
        for (cntr = ((MAX_DUTYCYCLE)/2); cntr > MIN_DUTYCYCLE; cntr--) {
            TA1CCR1 = cntr;
            __delay_cycles(2000);
        }   

	cio_printf("Vertical patrol complete.\n\r");

	return 0;
}
Example #9
0
int shell_cmd_encr(shell_cmd_args *args)
{
  if(args->count == 0) {
    cio_print((char *) "ERROR, no string to encrypt\n\r");
    return -1;
  }
  if(strlen(args->args[0].val) > 20) {
    cio_print((char *) "ERROR, string to encrypt is too long\n\r");
    return -1;
  }
  int k;
  char string[21];
  strncpy(string, args->args[0].val, 20);

  for(k = 0; k < strlen(string); k++) {
    string[k] = string[k] ^ key[k];
  }

  cio_printf("encrypted string: %s\n\r", string);

  return 0;
}
Example #10
0
int pin_setup(unsigned char pin, unsigned char function)
{
	int port;
	int bit;

	if((port = pin2port(pin)) < 0) return port;
	if((bit  = pin2bit(pin))  < 0) return bit;

	unsigned char f;

	f = pin_function(pin); 
	
#ifdef PIN_DBG
	cio_printf("pin %x has current function %x\n\r", pin, f);
#endif

	// see if PIN is already configured for the given function
	if(f == function) { 
		return PIN_STAT_OK;
	}
	// PIN is reserved
	else if(f == PIN_FUNCTION_RESERVED) {
		return PIN_STAT_ERR_UNSUPFUNC;
	}

	switch(function) {
	case PIN_FUNCTION_INPUT_FLOAT:
		if(!pin_has_capabilities(pin, PIN_CAP_INPUT)) {
			return PIN_STAT_ERR_UNSUPFUNC;
		}
		if(port == 1) {
			P1DIR &= ~bit;					// make sure to clear OUT flag for the pin                 
			P1REN &= ~bit; 	                // disable pull-up/down 
  			P1SEL &= ~bit;                  // remove option
		}
		else if(port == 2) {
			P2DIR &= ~bit;					// make sure to clear OUT flag for the pin                 
			P2REN &= ~bit; 	                // disable pull-up/down 
  			P2SEL &= ~bit;                  // remove option
		}
		break;
	case PIN_FUNCTION_INPUT_PULLUP:
		if(!pin_has_capabilities(pin, PIN_CAP_INPUT_RE)) { 
			return PIN_STAT_ERR_UNSUPFUNC;
		}
		if(port == 1) {
			P1DIR &= ~bit;					// make sure to clear OUT flag for the pin                 
  			P1OUT |=  bit;					// setting out to HIGH enables pull-up                     
			P1REN |=  bit; 	                // enable pull-up/down 
  			P1SEL &= ~bit;                  // remove option
		}
		else if(port == 2) {
			P2DIR &= ~bit;					// make sure to clear OUT flag for the pin                 
  			P2OUT |=  bit;					// setting out to HIGH enables pull-up                     
			P2REN |=  bit; 	                // enable pull-up/down 
  			P2SEL &= ~bit;                  // remove option
		}
		break;
	case PIN_FUNCTION_INPUT_PULLDOWN:
		if(!pin_has_capabilities(pin, PIN_CAP_INPUT_RE)) { 
			return PIN_STAT_ERR_UNSUPFUNC;
		}
		if(port == 1) {
			P1DIR &= ~bit;					// make sure to clear OUT flag for the pin                 
  			P1OUT &= ~bit;					// setting out to LOW enables pull-down                     
			P1REN |=  bit; 	                // enable pull-up/down 
  			P1SEL &= ~bit;                  // remove option
		}
		else if(port == 2) {
			P2DIR &= ~bit;					// make sure to clear OUT flag for the pin                 
  			P2OUT &= ~bit;					// setting out to LOW enables pull-down                     
			P2REN |=  bit; 	                // enable pull-up/down 
  			P2SEL &= ~bit;                  // remove option
		}
		break;
	case PIN_FUNCTION_OUTPUT:
		if(!pin_has_capabilities(pin, PIN_CAP_OUTPUT)) { 
			return PIN_STAT_ERR_UNSUPFUNC;
		}
		if(port == 1) {
			P1DIR |=  bit;					// set direction to out                 
  			P1OUT &= ~bit;					// set to LOW initially                     
			P1REN &= ~bit; 	                // disable pull-up/down 
  			P1SEL &= ~bit;                  // remove option
		}
		else if(port == 2) {
			P2DIR |=  bit;					// set direction to out                 
  			P2OUT &= ~bit;					// set to LOW initially                     
			P2REN &= ~bit; 	                // disable pull-up/down 
  			P2SEL &= ~bit;                  // remove option
		}
		break;
	case PIN_FUNCTION_ANALOG_IN:
		if(!pin_has_capabilities(pin, PIN_CAP_ANALOG_IN)) { 
			return PIN_STAT_ERR_UNSUPFUNC;
		}

		P1DIR &= ~bit;						// make sure to clear OUT flag for the pin                 
		P1REN &= ~bit; 	                	// disable pull-up/down 
  		P1SEL &= ~bit;                  	// remove option

		// VCC as +VRef, VSS as -VRef, 16 x ADC10CLKs
   		ADC10CTL0 = SREF_0 + ADC10SHT_2 + REFON + ADC10ON;

		break;
	case PIN_FUNCTION_PWM:
		if(!pin_has_capabilities(pin, PIN_CAP_PWM)) { 
			return PIN_STAT_ERR_UNSUPFUNC;
		}

		if(port == 1) {
			// only one pin on port 1 is able to perform PWM
			unsigned char pf = pin_with_function(PIN_1_0, function);

			if(pf > 0 && pf < PIN_2_0) { 
				return PIN_STAT_ERR_UNSUPFUNC;
			}
			P1DIR |=  bit;					// set direction to out                 
  			P1OUT &= ~bit;					// set to LOW initially                     
			P1REN &= ~bit; 	                // disable pull-up/down 
  			P1SEL |=  bit;                  // select TA option
		}
		else if(port == 2) {
			// only one pin on port 2 is able to perform PWM
			if(pin_with_function(PIN_2_0, function)) { 
				return PIN_STAT_ERR_UNSUPFUNC;
			}
			P2DIR |=  bit;					// set direction to out                 
  			P2OUT &= ~bit;					// set to LOW initially                     
			P2REN &= ~bit; 	                // disable pull-up/down 
  			P2SEL |=  bit;                  // select TA option
		}
		break;
	default:
		return PIN_STAT_ERR_UNSUPFUNC;
	}

	pin_set_curr_func(pin, function);

	return PIN_STAT_OK;
}
int main(void)
{

    /* Initialize Leds mounted on STM32F0-discovery */
    STM_EVAL_LEDInit(LED3);
    STM_EVAL_LEDInit(LED4);

    /* Turn on LED3 and LED4 */
    STM_EVAL_LEDOn(LED3);
    STM_EVAL_LEDOn(LED4);
    
    /* Initialize other outputs and inputs */
    STM_EVAL_LEDInit(RELAIS1);
    STM_EVAL_LEDInit(RELAIS2);
    STM_EVAL_LEDInit(OUT_12V_1);
    STM_EVAL_LEDInit(OUT_12V_2);
    STM_EVAL_PBInit(IN_12V_1, BUTTON_MODE_PDOWN);
    STM_EVAL_PBInit(IN_12V_2, BUTTON_MODE_PDOWN);
    
    /* Initialize the User_Button */
    STM_EVAL_PBInit(BUTTON_USER, BUTTON_MODE_EXTI);

    /* Setup SysTick Timer for 1 msec interrupts. */
    if (SysTick_Config(SystemCoreClock / 1000))
    {
        /* Capture error */
        while (1);
    }

    usart_1_init();

#ifndef WIFI_CONNECTED
    /* Output a message on Hyperterminal using printf function */
    cio_printf("%s", welcome_msg);
#else
    wifi_intit_pins();
    wifi_init_connections();
    
    // If the button is pressed on power on,
    // do not init the WiFi module to keep current WiFi connections
    // and save development time
    if (!STM_EVAL_PBGetState(BUTTON_USER))
        wifi_init_ap_mode();
#endif

    while (1)
    {
        // Everything should be non-blocking

#ifndef WIFI_CONNECTED
        if (serve_command_promt(line_buffer, LINEBUFFERSIZE, "microcli> ") > 0)
        {
            shell_process(line_buffer);
        }
#else
        if (wifi_get_msg(line_buffer, LINEBUFFERSIZE, &cid) > 0)
        {
            bool add_header = (cid != -1); // send back to the current connection
            if (add_header)
            {
                cio_printf("\x1bS%c", cid);
                cio_printf("microcli> %s\r\n", line_buffer);
            }
            shell_process(line_buffer);

            if (add_header)
            {
                cio_print("[end]\r\n");
                cio_print("\x1b" "E");
            }
        }
#endif

        if (timeout_0 == 0)
        {
            static uint8_t counter = 0;
            switch (counter++)
            {
            case 0:
                /* Toggle LED4 */
                if (options.elements[TOGGLE_LEDS_IDX].value == 1)
                    STM_EVAL_LEDToggle(LED4);
                break;
            case 1:
                /* Toggle LED3 */
                if (options.elements[TOGGLE_LEDS_IDX].value == 1)
                    STM_EVAL_LEDToggle(LED3);
                break;
            case 2:
                break;
            default:
                counter = 0;
            }
            timeout_0 = TIMEOUT_0_DEFAULT;
        }
        
        if (options.elements[REALTIME_MSG_IDX].value == 1)
        {
            enum {WAITFOR_PRESSED, WAITFOR_RELEASED};
            static uint8_t what = WAITFOR_PRESSED;
            char msg[30];
            msg[0] = '\0';
            if (what == WAITFOR_PRESSED)
            {
                if (UserButtonPressed != 0x00) // Interrupt based, don't miss an event
                //if (STM_EVAL_PBGetState(BUTTON_USER) == 1)
                {
                    strcpy(msg, "User button pressed");
                    what = WAITFOR_RELEASED;
                }
            }
            else if (what == WAITFOR_RELEASED)
            {
                if (STM_EVAL_PBGetState(BUTTON_USER) == 0)
                {
                    UserButtonPressed = 0x00;
                    strcpy(msg, "User button released");
                    what = WAITFOR_PRESSED;
                }
            }
            if (msg[0] != '\0')
            {
#ifndef WIFI_CONNECTED
                cio_printf("\r\n[info] %s %i\r\n", msg, uptime);
#else
                // send message to each client
                for(int i=0; i<16; i++)
                {
                    if(wifi_connections[i].state == CONNECTED)
                    {
                        cio_printf("\x1bS%c[info] %s %i\r\n\x1b""E", wifi_connections[i].cid, msg, uptime);
                    }
                }
#endif
            }
        }
    }
}
Example #12
0
int main(void)
{
	clock_init();

	pin_reserve(PIN_1_1);
	pin_reserve(PIN_1_2);

	serial_init(9600);

	cio_print("** ROCKETuC - librocketcore PIN test **\n\r");

	dump_regs("initial");

	// invalid port
	if(pin_setup(0x30, PIN_FUNCTION_OUTPUT) == PIN_STAT_ERR_INVALPORT) {
		cio_print("0x30 is an invalid port\n\r");
	}
	
	// invalid pin
	if(pin_setup(0x2A, PIN_FUNCTION_OUTPUT) == PIN_STAT_ERR_INVALPIN) {
		cio_print("0x2A is an invalid pin\n\r");
	}

	// P1.1 + P1.2 are reserved for UART1
	if(pin_setup(PIN_1_1, PIN_FUNCTION_OUTPUT) == PIN_STAT_ERR_INVALPIN) {
		cio_print("0x11 is an invalid (reserved) pin\n\r");
	}
	if(pin_setup(PIN_1_2, PIN_FUNCTION_OUTPUT) == PIN_STAT_ERR_INVALPIN) {
		cio_print("0x12 is an invalid (reserved) pin\n\r");
	}

	// pins on port 2 do not support ADC
	int p;

	for(p = 0; p < 8; p++) { 
		if(pin_setup(PIN_2_0 + p, PIN_FUNCTION_ANALOG_IN) == PIN_STAT_ERR_UNSUPFUNC) {
			cio_printf("0x2%i does not support ADC\n\r", p);
		}
	}
	
	// set P1.0 + P1.6 + P2.5 to output (the build in LEDs)
	pin_setup(PIN_1_0, PIN_FUNCTION_OUTPUT);
	pin_setup(PIN_1_6, PIN_FUNCTION_OUTPUT);
	pin_setup(PIN_2_5, PIN_FUNCTION_OUTPUT);

	
	dump_regs("p1.0+p1.6+p2.5 output");

	// set P1.0 + P1.6 + P2.5 to HIGH
	pin_set(PIN_1_0);
	pin_set(PIN_1_6);
	pin_set(PIN_2_5);

	dump_regs("p1.0+p1.6+p2.5 set");

	// read P1.0 + P1.6 + p2.5 states
	cio_printf("P1.0 is %x\n\r", pin_digital_read(PIN_1_0));	
	cio_printf("P1.6 is %x\n\r", pin_digital_read(PIN_1_6));	
	cio_printf("P2.5 is %x\n\r", pin_digital_read(PIN_2_5));	
	
	// clear P1.0 + p1.6 + p2.5 to LOW 
	pin_clear(PIN_1_0);
	pin_clear(PIN_1_6);
	pin_clear(PIN_2_5);

	dump_regs("p1.0+p1.6+p2.5 clear");

	// read P1.0 + P1.6 + 2.5 states
	cio_printf("P1.0 is %x\n\r", pin_digital_read(PIN_1_0));	
	cio_printf("P1.6 is %x\n\r", pin_digital_read(PIN_1_6));	
	cio_printf("P2.5 is %x\n\r", pin_digital_read(PIN_2_5));	

	// toggle P1.0 + P1.6 + P2.5
	pin_toggle(PIN_1_0);
	pin_toggle(PIN_1_6);
	pin_toggle(PIN_2_5);

	dump_regs("p1.0+p1.6+p2.5 toggle");

	// read P1.0 + P1.6 states
	cio_printf("P1.0 is %x\n\r", pin_digital_read(PIN_1_0));	
	cio_printf("P1.6 is %x\n\r", pin_digital_read(PIN_1_6));	
	cio_printf("P2.5 is %x\n\r", pin_digital_read(PIN_2_5));	

	// toggle P1.0 + P1.6 + P2.5
	pin_toggle(PIN_1_0);
	pin_toggle(PIN_1_6);
	pin_toggle(PIN_2_5);

	dump_regs("p1.0+p1.6+p2.5 toggle");

	// read P1.0 + P1.6 states
	cio_printf("P1.0 is %x\n\r", pin_digital_read(PIN_1_0));	
	cio_printf("P1.6 is %x\n\r", pin_digital_read(PIN_1_6));	
	cio_printf("P2.5 is %x\n\r", pin_digital_read(PIN_2_5));	

	// set P1.3 to input float
	pin_setup(PIN_1_3, PIN_FUNCTION_INPUT_FLOAT);

	dump_regs("p1.3 input float");

	cio_print("Press button on P1.3 to continue ...");

	while(pin_digital_read(PIN_1_3)) __asm__("nop");

	cio_print(" OK\n\r");
	
	// set P2.3 to input pull-down 
	pin_setup(PIN_2_3, PIN_FUNCTION_INPUT_PULLDOWN);

	dump_regs("p2.3 input pull-down");

	cio_print("Press button on P2.3 to continue ...");

	while(!pin_digital_read(PIN_2_3)) __asm__("nop");

	cio_print(" OK\n\r");
	
	// set P2.4 to input pull-down 
	pin_setup(PIN_2_4, PIN_FUNCTION_INPUT_PULLUP);

	dump_regs("p2.4 input pull-up");

	cio_print("Press button on P2.4 to continue ...");

	while(pin_digital_read(PIN_2_4)) __asm__("nop");

	cio_print(" OK\n\r");

	int pl = 0;

	cio_print("Press button on P1.3 for pulselength read ...");

	delay(50000);

	pl = pin_pulselength_read(PIN_1_3);

	cio_printf(" OK, pl=%i\n\r", pl);

	cio_print("Press button on P2.3 for pulselength read ...");

	delay(50000);

	pl = pin_pulselength_read(PIN_2_3);

	cio_printf(" OK, pl=%i\n\r", pl);

	cio_print("Press button on P2.4 for pulselength read ...");

	delay(50000);

	pl = pin_pulselength_read(PIN_2_4);

	cio_printf(" OK, pl=%i\n\r", pl);
	
	pin_set(PIN_1_0);
	pin_clear(PIN_1_6);
	pin_clear(PIN_2_5);

	// set P1.5 to analog in
	int i = 0;

	cio_printf("setup 1.5 for analog in: %i\n\r", pin_setup(PIN_1_5, PIN_FUNCTION_ANALOG_IN));
	dump_regs("p1.5 analog in");
	
	int adcin1 = pin_analog_read(PIN_1_5); 
	int adcin2 = 0; 
	cio_printf("Analog read p1.5: %x\n\r", adcin1);

	// set P2.2 to PWM with period of 20ms and duty cycle of 7.5%
	cio_printf("setup 2.2 for PWM: %i\n\r", pin_setup(PIN_2_2, PIN_FUNCTION_PWM));
	dump_regs("p2.2 PWM");

	// only one of the two possible pins on port two are allowed to be set to PWM
	cio_printf("setup 2.1 for PWM: %i\n\r", pin_setup(PIN_2_1, PIN_FUNCTION_PWM));

	// period 
	pin_pwm_function(PIN_2_2, 20000);
	pin_pwm_control(PIN_2_2, adc2dc(adcin1));

	while (1) {
		delay();

		pin_toggle(PIN_1_0);
		pin_toggle(PIN_1_6);

		if(i++ % 2 == 0) {
			pin_toggle(PIN_2_5);
		}

		if(!pin_digital_read(PIN_1_3)) {
			pin_toggle(PIN_1_6);
			while(!pin_digital_read(PIN_1_3)) __asm__("nop");
		}

		adcin2 = pin_analog_read(PIN_1_5); 

		// only output ADC value if delta was more then 5
		if(adcin2 - adcin1 > 5 || adcin1 - adcin2 > 5) {
			adcin1 = adcin2;
			cio_printf("Analog read at p1.5: %x (%i)\n\r", adcin2, adcin2);
			pin_pwm_control(PIN_2_2, adc2dc(adcin1));
		}
	}

	return 0;
}
Example #13
0
int main(void){
int count = 0;
short int retval;
short int c,v,save;

  WDTCTL  = WDTHOLD | WDTPW;
	BCSCTL1 = CALBC1_1MHZ;
	DCOCTL  = CALDCO_1MHZ;

  // turn the LEDs off
  P1DIR &= ~(0b00000001);
  P1DIR &= ~(0b01000000);

	serial_init(9600);

// The check is done in a loop
for (;;)
{
  // get status from assembly file with Status function
  retval = Status();

  // turn the LEDs off
  P1DIR &= ~(0b00000001);
  P1DIR &= ~(0b01000000);

  // increment the value by one
  count = count + 1;
  save = count;
  // check if c or v are on
  if (retval & 1 == 1)
  {
    c = 1;
    // red light on
    P1DIR |= 0b00000001;
    // delay to see the lights
    __delay_cycles(100000);
  }

  else if (retval & 0x0100 == 1)
  {
    v = 1;
    // green light on
    P1DIR |= 0b01000000;
    // delay to see the lights
    __delay_cycles(100000);
  }

  // print the values of carry before the flag
  if (c == 1)
  {
    cio_printf("Value before carry: %u\n\r", save);
  }

  // print the values of overflow before the flag
  if (v == 1)
  {
    cio_printf("Value before overflow: %u\n\r", save);
  }
}

	return 0;
}