コード例 #1
0
ファイル: ping_main.c プロジェクト: stevew817/ElecanismsTeam
int16_t main(void) {
	//initialize all system clocks
    init_clock();
	//initialize serial communications
    init_uart();
	//initialize pin driving library (to be able to use the &D[x] defs)
	init_pin();
	//initialize the UI library
    init_ui();
	//initialize the timer module
    init_timer();
	//initialize the OC module (used by the servo driving code)
	init_oc();
	
	//Set servo control pins as output
	pin_digitalOut(PAN_PIN);
	pin_digitalOut(TILT_PIN);
	pin_digitalOut(SONIC_OUT_PIN);
	pin_digitalIn(SONIC_IN_PIN);
	
	//Set LED off
	led_off(LED);
	//Configure blinking rate for LED when connected
    timer_setPeriod(LED_TIM, 0.2);
    timer_start(LED_TIM);
	

    //Configure timer for reciever timeout
    timer_setPeriod(DIST_TIM, 0.05);


	//configure PWM on sonic output pin
	oc_pwm(PWM_OC, SONIC_OUT_PIN, NULL, SONIC_FREQ, 0x0000);
	
	//According to HobbyKing documentation: range .8 through 2.2 msec
	//Set servo control pins as OC outputs on their respective timers
	oc_servo(SERVO1_OC, PAN_PIN, 	SERVO1_TIM, SERVO_PERIOD, SERVO_MIN, SERVO_MAX, pan_set_val);
	oc_servo(SERVO2_OC, TILT_PIN, 	SERVO2_TIM, SERVO_PERIOD, SERVO_MIN, SERVO_MAX, tilt_set_val);

    InitUSB();                              // initialize the USB registers and serial interface engine
    while (USB_USWSTAT!=CONFIG_STATE) {     // while the peripheral is not configured...
        ServiceUSB();                       // ...service USB requests
		led_on(LED);
		//There's no point in driving the servos when there's no one connected yet.
    }
	
    while (1) {
        ServiceUSB();                       // service any pending USB requests
		
		//blink the LED
		if (timer_flag(LED_TIM)) {
            timer_lower(LED_TIM);
            led_toggle(LED);
        }
		
		//Update the servo control values.
		pin_write(PAN_PIN, pan_set_val);
		pin_write(TILT_PIN, tilt_set_val);
    }
}
コード例 #2
0
ファイル: haptic.c プロジェクト: kstegner/elec_mini4
//INITIALIZE MOTOR
void initMotor(void) {
    pin_write(ENA, 1);  //set enable pin to ON
    pin_write(SLEW, 1); //set slew rate to HIGH
    pin_write(INV, 0);  //set invert OFF
    pin_write(D1, 0);   //disable IN1 is OFF
    pin_write(D2, 1);   //disable IN2 is ON
}
コード例 #3
0
ファイル: uart_soft.c プロジェクト: eerimoq/simba
static ssize_t uart_soft_write_cb(void *arg_p,
                                  const void *txbuf_p,
                                  size_t size)
{
    int i, j;
    uint8_t data;
    struct uart_soft_driver_t *self_p;
    const uint8_t *tx_p = txbuf_p;

    self_p = container_of(arg_p, struct uart_soft_driver_t, chout);

    for (i = 0; i < size; i++) {
        sys_lock();
        pin_write(&self_p->tx_pin, 0);

        /* Put 8 bits on the transmission wire. */
        data = tx_p[i];

        for (j = 0; j < 8; j++) {
            time_busy_wait_us(self_p->sample_time);
            pin_write(&self_p->tx_pin, data & 1);
            data >>= 1;
        }

        time_busy_wait_us(self_p->sample_time);
        pin_write(&self_p->tx_pin, 1);
        time_busy_wait_us(self_p->sample_time);
        sys_unlock();
    }

    return (size);
}
コード例 #4
0
ファイル: main.c プロジェクト: wuwx/simba
int test_exti(struct harness_t *harness_p)
{
    int i;
    struct exti_driver_t exti;
    struct pin_driver_t pin;

    pin_init(&pin, &pin_d4_dev, PIN_OUTPUT);
    pin_write(&pin, 1);
    
    BTASSERT(exti_init(&exti,
                       &exti_d3_dev,
                       EXTI_TRIGGER_FALLING_EDGE,
                       isr,
                       NULL) == 0);
    BTASSERT(exti_start(&exti) == 0);

    for (i = 0; i < 10; i++) {
        pin_write(&pin, 0);
        time_busy_wait_us(10000);
        pin_write(&pin, 1);
        time_busy_wait_us(10000);
    }

    std_printf(FSTR("flag = %d\r\n"), (int)flag);
    BTASSERT(flag == 10);

    return (0);
}
コード例 #5
0
ファイル: haptic_damper.c プロジェクト: gubbatuba/elecanisms
void pwm_set_direction(unsigned char direction) {
    // Direction is a bit [0 or 1] specifying the direction
    // the motor should be commanded to turn. 1 is "forwards",
    // and 0 is "reverse". Assumes fast decay mode operation.
    if (pwm_direction != direction) {
        // The direction to be set is different than the motor's current
        // direction. A change should be made.
        uint16_t prev_duty;
        pwm_direction = direction;  // Update pwm_direction
        if (direction == 1) {
            // If 1, PWM_I1 should PWM, PWM_I2 should be 0.
            // printf("Setting motor direction FORWARD...\r\n");
            prev_duty = pin_read(PWM_I2);
            pin_write(PWM_I2, (uint16_t)(0));
            pin_write(PWM_I1, prev_duty);
        } else if (direction == 0) {
            // If 0, PWM_I1 should 0, PWM_I2 should be 1.
            // printf("Setting motor direction REVERSE...\r\n");
            prev_duty = pin_read(PWM_I1);
            pin_write(PWM_I1, (uint16_t)(0));
            pin_write(PWM_I2, prev_duty);
        } else {
            printf("ERR: Invalid PWM direction %d received.\r\n", direction);
        }
    }
}
コード例 #6
0
ファイル: haptic.c プロジェクト: kstegner/elec_mini4
int16_t main(void) {
     InitUSB();                              // initialize the USB registers and serial interface engine
     initChip();
     initMotor();   

    led_on(&led1);
    timer_setPeriod(LED_TIMER, 0.5);         //start internal clock with defined period
    timer_start(LED_TIMER);

    pin_write(IN1, 1);
    pin_write(IN2, 0);
    pin_write(D2, 65536*2/5);

    while (USB_USWSTAT!=CONFIG_STATE) {     // while the peripheral is not configured...
        ServiceUSB();                       // ...service USB requests
    }

    while (1) {
        ServiceUSB();                       // service any pending USB requests

        //LED1 TOGGLE TO CONFIRM RUNNING CODE
        if (timer_flag(LED_TIMER)) {
            timer_lower(LED_TIMER);
            led_toggle(&led1);

            pin_write(D2, VAL1);
        }       
    }
}
コード例 #7
0
ファイル: haptic_damper.c プロジェクト: gubbatuba/elecanisms
void pwm_set_raw_duty(uint16_t raw_duty) {
    if (pwm_direction == 1) {
        pin_write(PWM_I1, raw_duty);
    } else {
        pin_write(PWM_I2, raw_duty);
    }
}
コード例 #8
0
ファイル: gps.cpp プロジェクト: M1Fream/weather-balloon
//
// Exported functions
//
void gps_setup() {
  int gps_success = 0;
  
  strcpy(gps_time, "000000");
  strcpy(gps_aprs_lat, "0000.00N");
  strcpy(gps_aprs_lon, "00000.00E");
  
#ifdef GPS_USING_UBLOX  
  // Setup for the uBLOX MAX-6/7/8
  
  // Check to see if we need to power up the GPS
#ifdef GPS_POWER_PIN
  pinMode(GPS_POWER_PIN,   OUTPUT);
  pin_write(GPS_POWER_PIN, LOW);
#endif

#ifdef GPS_POWER_SLEEP_TIME  
  // Add a bit of a delay here to allow the GPS a chance to wake up
  // (even if we aren't powering it via a digital pin)
  delay(GPS_POWER_SLEEP_TIME);
#endif  

#ifdef GPS_LED_PIN
  // LED for GPS Status
  pinMode(GPS_LED_PIN,      OUTPUT);
  pin_write(GPS_LED_PIN,    LOW);
#endif

  // Set MAX-6 to flight mode
  int setup_attempts_remaining = 120;
  while (!gps_success && (setup_attempts_remaining--) >= 0) {
    sendUBX(setNav, sizeof(setNav)/sizeof(uint8_t)); 
    gps_success = getUBX_ACK(setNav);
	if (!gps_success) {
	  // Should find a better way to indicate a problem?
#ifdef GPS_LED_PIN
      pin_write(GPS_LED_PIN, HIGH);
#endif	  
      delay(500);
	  }
	}
  
#ifdef GPS_LED_PIN
  pin_write(GPS_LED_PIN, LOW);
#endif  

  // Finally turn off any NMEA sentences we don't need (in this case it's 
  // everything except GGA and RMC)
  sendUBX(setGLL, sizeof(setGLL)/sizeof(uint8_t));   // Disable GGL
  sendUBX(setGSA, sizeof(setGSA)/sizeof(uint8_t));   // Disable GSA
  sendUBX(setGSV, sizeof(setGSV)/sizeof(uint8_t));   // Disable GSV
  sendUBX(setVTG, sizeof(setVTG)/sizeof(uint8_t));   // Disable VTG
#endif
}
コード例 #9
0
int8_t port_pin_write(uint8_t portx, uint8_t pin, uint8_t state)
{
#if defined (__AVR_ATmega169__) || defined (__AVR_ATmega169P__)
	if (portx == portb) // it is PORTB
	{
		pin_write(PORTB,pin,state);
	}
	else if  // it is PORTD
	{
		pin_write(PORTD,pin,state);
	}
	else // out of range 
	{
		return(-1); // return ERROR
コード例 #10
0
int8_t digital_write(uint8_t pin, uint8_t value)
{
#if defined (__AVR_ATmega169__) || defined (__AVR_ATmega169P__)
	if ( pin < 8) // it is PORTB
	{
		pin_write(PORTB,pin,value);
	}
	else if  // it is PORTD
	{
		pin -= 8; // converts it to numbering for PORTD
		pin_write(PORTD,pin,value);
	}
	else // out of range 
	{
		return(-1); // return ERROR
コード例 #11
0
// Interrupt Service Routine for TIMER 3. This is used to switch between the
// buzzing and quiet periods when ON_CYCLES or OFF_CYCLES are reached.
extern "C" void __ISR (_TIMER_3_VECTOR, ipl5) T3_IntHandler (void)
{
  alarm--;
  if (alarm == 0) {
    buzzing = !buzzing;
    if (is_buzzer_on && buzzing) {
      switch(BUZZER_PIN) {
        case 9:
          OpenOC4(OC_ON | OC_TIMER3_SRC | OC_PWM_FAULT_PIN_DISABLE, DUTY_CYCLE, 0);
          break;
        case 10:
          OpenOC5(OC_ON | OC_TIMER3_SRC | OC_PWM_FAULT_PIN_DISABLE, DUTY_CYCLE, 0);
          break;
      }
      alarm = ON_CYCLES;
    } else {
      switch(BUZZER_PIN) {
        case 9:  CloseOC4(); break;
        case 10: CloseOC5(); break;
      }
      alarm = OFF_CYCLES;
      pin_write(BUZZER_PIN, LOW);
    }
  }
  // Clear interrupt flag
  // This will break other interrupts and millis() (read+clear+write race condition?)
  //   IFS0bits.T3IF = 0; // DON'T!! 
  // Instead:
  mT3ClearIntFlag();
}
コード例 #12
0
ファイル: radio_hx1.cpp プロジェクト: xpix/XTrack
void RadioHx1::setup()
{
  // Configure pins
  pinMode(PTT_PIN, OUTPUT);
  pin_write(PTT_PIN, LOW);
  pinMode(AUDIO_PIN, OUTPUT);
}
コード例 #13
0
void RadioRSUV3::setup()
{
  // Configure pins
  pinMode(PTT_PIN, OUTPUT);
  pin_write(PTT_PIN, HIGH);
  pinMode(AUDIO_PIN, OUTPUT);
}
コード例 #14
0
ファイル: quad.c プロジェクト: RyanEggert/space-lander
void quad_debug(_QUAD *self, _PIN *lut3, _PIN *lut2, _PIN *lut1, _PIN *lut0 ) {
    /*
    Given a quadrature encoder object and four configured digital output pins,
    writes the value used to index the LUT across the four pins as follows--
        LUT Index Bit   |  Source
        [LSB --> MSB]   |
        ****************************************
              0 (LSB)   | most recent value of B
              1         | most recent value of A
              2         | previously read value of B
              3 (MSB)   | previously read value of A
    */
    pin_write(lut0, self -> b_curr); // b0
    pin_write(lut1, self -> a_curr); // b1
    pin_write(lut2, self -> b_prev); // b2
    pin_write(lut3, self -> a_prev); // b3
}
コード例 #15
0
uint16_t PIDcalc(uint16_t set_point){
    actual_position = pin_read(potentiometer);
    uint16_t error;
    uint16_t duty; 
    uint16_t threshold = 500;
    // printf("actual_position %u\n\r",  actual_position);
    error = abs((set_point - actual_position));
    // printf("error %u\n\r",  error);
    if (error > threshold){
        duty = (Kp * error);
        // printf("duty %u\n\r",  duty);
        pin_write(pwmpin, duty);
        PIDcalc(set_point);  
    }
    else{
        pin_write(pwmpin, 0); 
    } 
}
コード例 #16
0
// Private : Hardware scan
void Keypad_MAX::scanKeys() {
	// Re-intialize the pins every time for sharing with other hardware.
	for (byte r=0; r<sizeKpd.rows; r++) {
		pin_mode(rowPins[r],INPUT_PULLUP);
	}

	// bitMap stores ALL the keys that are being pressed.
	for (byte c=0; c<sizeKpd.columns; c++) {
		pin_mode(columnPins[c],OUTPUT);
		pin_write(columnPins[c], LOW);	// Begin column pulse output.
		for (byte r=0; r<sizeKpd.rows; r++) {
			bitWrite(bitMap[r], c, !pin_read(rowPins[r]));  // keypress is active low so invert to high.
		}
		// Set pin to high impedance input. Effectively ends column pulse.
		pin_write(columnPins[c],HIGH);
		pin_mode(columnPins[c],INPUT);
	}
}
コード例 #17
0
ファイル: pantilt.c プロジェクト: nrubin/miniproject2
int16_t main(void) {
    init_clock();
    init_uart();
    init_ui();
    init_timer();
    init_oc();
    
    led_on(&led2);
    timer_setPeriod(&timer2, 0.5);
    timer_start(&timer2);

    val1 = 0;
    val2 = 0;

    interval = 0.02;
    min_width = 5.5E-4;
    max_width = 2.3E-3;
    pos = 0; //16 bit int with binary point in front of the MSB

    oc_servo(&oc1,&D[0],&timer1, interval,min_width, max_width, pos);
    oc_servo(&oc2,&D[2],&timer3, interval,min_width, max_width, pos);

    printf("Good morning\n");

    InitUSB();                              // initialize the USB registers and serial interface engine
    while (USB_USWSTAT!=CONFIG_STATE) {     // while the peripheral is not configured...
        ServiceUSB();                       // ...service USB requests
    }
    while (1) {
        ServiceUSB();
        //write the values to the servos (move the servos to the requested position)
        pin_write(&D[0],val1);
        pin_write(&D[2],val2);                     
        if (timer_flag(&timer2)) {
            //show a heartbeat and a status message
            timer_lower(&timer2);
            led_toggle(&led1);
            printf("val1 = %u, val2 = %u\n", val1, val2);
        }
    }
}
コード例 #18
0
int sensors_lm60(int powerPin, int readPin)
{
  uint16_t adc = 0;
  pin_write(powerPin, HIGH);   // Turn the LM60 on
  delayMicroseconds(5);           // Allow time to settle
  adc = analogRead(readPin);      // Real read
  pin_write(powerPin, LOW);    // Turn the LM60 off
  int mV = 3300L * adc / 1024L;   // Millivolts
  
  switch(TEMP_UNIT) {
    case 1: // C
      // Vo(mV) = (6.25*T) + 424 -> T = (Vo - 424) * 100 / 625
      return (4L * (mV - 424) / 25) + CALIBRATION_VAL;
    case 2: // K
      // C + 273 = K
      return (4L * (mV - 424) / 25) + 273 + CALIBRATION_VAL;
    case 3: // F
      // (9/5)C + 32 = F
      return (36L * (mV - 424) / 125) + 32 + CALIBRATION_VAL;
  }
}
コード例 #19
0
ファイル: haptic.c プロジェクト: nrubin/HapticProject
void init_motor(void){

    //outputs
    pin_digitalOut(IN1); //D2-bar
    pin_write(IN1,1);

    pin_digitalOut(IN2); //D2-bar
    pin_write(IN2,0);

    pin_digitalOut(D1); //D1
    pin_write(D1,0); //no tri-stating!

    pin_digitalOut(ENA); //ENA
    pin_write(ENA,1); //Enable the system

    pin_digitalOut(&D[7]); //SLEW
    pin_write(&D[7],0); //low slew rate

    pin_digitalOut(INV); //INV
    pin_write(INV,0); //don't invert the inputs!    

    //inputs
    pin_analogIn(CURRENT_PIN); //direction sensor
    pin_analogIn(VEMF_PIN); //Vemf sensor
    pin_analogIn(FB_PIN); //0.24% of active high side current
    pin_digitalIn(REV_PIN); //tach input
}
コード例 #20
0
ファイル: power_avr.cpp プロジェクト: LZ1NY/RabbitTrackuino
void power_save()
{
  /* Enter power saving mode. SLEEP_MODE_IDLE is the least saving
   * mode, but it's the only one that will keep the UART running.
   * In addition, we need timer0 to keep track of time, timer 1
   * to drive the buzzer and timer2 to keep pwm output at its rest
   * voltage.
   */

  set_sleep_mode(SLEEP_MODE_IDLE);
  sleep_enable();
  power_adc_disable();
  power_spi_disable();
  power_twi_disable();

  pin_write(LED_PIN, LOW);
  sleep_mode();    // Go to sleep
  pin_write(LED_PIN, HIGH);
  
  sleep_disable();  // Resume after wake up
  power_all_enable();
}
コード例 #21
0
// Exported functions
void buzzer_setup()
{
  pinMode(BUZZER_PIN, OUTPUT);
  pin_write(BUZZER_PIN, LOW);
  buzzing = false;
  is_buzzer_on = false;
  alarm = 1;

  // There are two timers capable of PWM, 2 and 3. We are using 2 for the modem,
  // so use 3 for the buzzer.
  OpenTimer3(T3_ON | T3_PS_1_8, PWM_PERIOD);
  ConfigIntTimer3(T3_INT_ON | T3_INT_PRIOR_5);
}
コード例 #22
0
void modem_hal_start()
{
  ConfigIntTimer2(T2_INT_ON | T2_INT_PRIOR_6);
  
  // The above could also be accomplished by ... ?
  /*  
  IFS0bits.T2IF = 0; // Clear the T2 interrupt flag, so that the ISR doesn't go off immediatelly
  IEC0bits.T2IE = 1;   // Enable T2 interrupt
  */

  // Turn PTT led on
  pin_write(43, HIGH);
}
コード例 #23
0
void modem_hal_stop()
{
  // Return to rest duty cycle
  SetDCOC1PWM(REST_DUTY);
  //OCxRS = REST_DUTY;

  // Disable playback interrupt
  mT2IntEnable(0);
  //IEC0bits.T2IE = 0;

  // Turn PTT led off
  pin_write(43, LOW);
}
コード例 #24
0
ファイル: main.c プロジェクト: eerimoq/simba
int main()
{
    struct nrf24l01_driver_t nrf24l01;
    struct pin_driver_t pin[3];
    uint8_t state[32];

    sys_start();

    nrf24l01_init(&nrf24l01,
                  &spi_device[0],
                  &pin_d10_dev,
                  &pin_d6_dev,
                  &exti_device[1],
                  SERVER_ADDRESS);
    nrf24l01_start(&nrf24l01);

    /* Initialize led pins. */
    pin_init(&pin[0], &pin_d7_dev, PIN_OUTPUT);
    pin_init(&pin[1], &pin_d8_dev, PIN_OUTPUT);
    pin_init(&pin[2], &pin_d9_dev, PIN_OUTPUT);

    pin_write(&pin[0], 0);
    pin_write(&pin[1], 0);
    pin_write(&pin[2], 0);

    while (1) {
        /* Read state from client. */
        nrf24l01_read(&nrf24l01, state, sizeof(state));
        std_printf(FSTR("state = 0x%x\r\n"), (int)state[0]);

        /* Upadte LED. */
        pin_write(&pin[0], (state[0] >> 0) & 0x1);
        pin_write(&pin[1], (state[0] >> 1) & 0x1);
        pin_write(&pin[2], (state[0] >> 2) & 0x1);
    }

    return (0);
}
コード例 #25
0
ファイル: sensors.cpp プロジェクト: helioz2000/loguino
int sensors_lm60(int powerPin, int readPin)
{
  pin_write(powerPin, HIGH);      // Turn the LM60 on
  analogReference(INTERNAL);      // Ref=1.1V. Okay up to 108 degC (424 + 6.25*108 = 1100mV)
  analogRead(readPin);            // Disregard the 1st conversion after changing ref (p.256)
  delay(10);                      // This is needed when switching references
  int adc = analogRead(readPin);  // Real read
  pin_write(powerPin, LOW);       // Turn the LM60 off

  int mV = 1100L * adc / 1024L;   // Millivolts

  switch(TEMP_UNIT) {
    case 1: // C
      // Vo(mV) = (6.25*T) + 424 -> T = (Vo - 424) * 100 / 625
      return (4L * (mV - 424) / 25) + CALIBRATION_VAL;
    case 2: // K
      // C + 273 = K
      return (4L * (mV - 424) / 25) + 273 + CALIBRATION_VAL;
    case 3: // F
      // (9/5)C + 32 = F
      return (36L * (mV - 424) / 125) + 32 + CALIBRATION_VAL;
  }
}
コード例 #26
0
ファイル: bud.c プロジェクト: trevhoot/BestBuds
/*
void ping() {
	pin_write(pingPin, HALF_INT);
	timer_after(&timer4, 500e-6, 1, send);	
}
*/
void motorControl(dist) {	

	while (stepCount != dist){
		
		
		if (motorOn == 1){
			stepCount += step;
			motorOn = 0;

			pin_write(stepPin, 0);
		} else if (motorOn == 0){
			motorOn = 1;
			if (stepCount > dist){
				step = -1; 
				dir = 0;
			} else if (stepCount < dist){
				step = 1;
				dir = 1;
			}
			pin_write(dirPin, dir); 
			pin_write(stepPin, 1);
		}
		timer_start(&timer1);
		led_toggle(&led1);
		
		while (1) {
			count = timer_read(&timer1);
			led_toggle(&led2);
			if (count > period){
				break;
			}
		}
		timer_stop(&timer1);
		timer_lower(&timer1);
	}
	
}
コード例 #27
0
ファイル: main.c プロジェクト: wuwx/simba
int test_falling(struct harness_t *harness_p)
{
    int i;
    struct pcint_driver_t pcint;

    pin_write(&pin, 1);
    count = 0;

    BTASSERT(pcint_init(&pcint,
                        &pcint_a9_dev,
                        PCINT_TRIGGER_FALLING_EDGE,
                        isr,
                        NULL) == 0);
    BTASSERT(pcint_start(&pcint) == 0);

    /* 10 falling, 9 rising edges. */
    for (i = 0; i < 10; i++) {
        pin_write(&pin, 1);
        time_busy_wait_us(10000);
        pin_write(&pin, 0);
        time_busy_wait_us(10000);
    }

    BTASSERT(pcint_stop(&pcint) == 0);

    /* The interrupt is disabled, no increment. */
    pin_write(&pin, 1);
    time_busy_wait_us(10000);
    pin_write(&pin, 0);
    time_busy_wait_us(10000);

    std_printf(FSTR("count: %d\r\n"), count);
    BTASSERT(count == 10);

    return (0);
}
コード例 #28
0
ファイル: class_pin.c プロジェクト: eerimoq/pumbaa
/**
 * def write(self, value)
 */
static mp_obj_t class_pin_write(mp_obj_t self_in, mp_obj_t value_in)
{
    struct class_pin_t *self_p;
    int value;

    value = mp_obj_get_int(value_in);

    if ((value != 0) && (value != 1)) {
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError,
                                                "bad pin value %d",
                                                value));
    }

    self_p = MP_OBJ_TO_PTR(self_in);
    pin_write(&self_p->drv, value);

    return (mp_const_none);
}
コード例 #29
0
void showBlank(void){

    volatile uint8_t segments = 0b00000000;
    volatile uint8_t segmentsZero = 0b00000000;

    int a;
    for(a = 0; a < 3; a++){
        int z;
        for (z = 0 ; z < 8 ; z++){
            volatile uint8_t transferSegment = segments & (1 << (7 - z));
            pin_clear(segmentClock);
            pin_write(segmentData, transferSegment);
            pin_set(segmentClock); 
        }
    } 
    pin_clear(segmentLatch);
    pin_set(segmentLatch);     
}
コード例 #30
0
void postNumber(int number, uint8_t decimal){

    volatile uint8_t segments = 0b00000000;
    volatile uint8_t segmentsZero = 0b00000000;

    #define a  1<<0
    #define b  1<<6
    #define c  1<<5
    #define d  1<<4
    #define e  1<<3
    #define f  1<<1
    #define g  1<<2
    #define dp 1<<7


    switch (number){
        case 1: segments = b | c | segmentsZero; break;
        case 2: segments = a | b | d | e | g | segmentsZero; break;
        case 3: segments = a | b | c | d | g | segmentsZero; break;
        case 4: segments = f | g | b | c | segmentsZero; break;
        case 5: segments = a | f | g | c | d | segmentsZero; break;
        case 6: segments = a | f | g | e | c | d | segmentsZero; break;
        case 7: segments = a | b | c | segmentsZero; break;
        case 8: segments = a | b | c | d | e | f | g | segmentsZero; break;
        case 9: segments = a | b | c | d | f | g | segmentsZero; break;
        case 0: segments = a | b | c | d | e | f | segmentsZero; break;
        case ' ': segments = 0 | segmentsZero; break;
        case 'c': segments = g | e | d | segmentsZero; break;
        case '-': segments = g | segmentsZero; break;
    }

    if (decimal == 1){
        segments |= dp;
    }
    int y;
    for (y = 0 ; y < 8 ; y++){
        volatile uint8_t transferSegment = segments & (1 << (7 - y));
        pin_clear(segmentClock);
        pin_write(segmentData, transferSegment);
        pin_set(segmentClock); 
    }
}